/// <summary>
/// Creates a set of dependencies that references the decorator.
/// </summary>
/// <returns>A set of dependencies that references the decorator.</returns>
public CodeDependencies CreateImportDependency()
{
// Source is optional; might be an ambient type (like "any").
if (string.IsNullOrWhiteSpace(Import)) return CodeDependencies.Empty;
// Construct dependencies referencing the mapped type.
return CodeDependencies.FromImports(new[] { new Import(DecoratorName, Import) });
}
/// <summary>
/// Is overridden to define how the type reference is translated by this strategy.
/// </summary>
/// <param name="referencedType">Type reference that should be tranlated.</param>
/// <param name="translator">Full translator that can be used to translate parts of the complete type reference.</param>
/// <returns>Result of the translation.</returns>
protected override TypeReferenceTranslationResult Translate(Type referencedType, ITypeReferenceTranslator translator)
{
var translatedTypeArguments = referencedType.GetGenericArguments().Select(translator.Translate);
var referencedTypeName = referencedType.GetNameWithoutGenericTypeParameters()
+ $"<{ string.Join(", ", translatedTypeArguments.Select(x => x.ReferencedTypeName)) }>";
return(new TypeReferenceTranslationResult(referencedTypeName,
CodeDependencies.FromCodeFragments(new[] { CodeFragmentId.ForClrType(referencedType.GetGenericTypeDefinition()) })
.Merge(translatedTypeArguments.Aggregate(CodeDependencies.Empty, (x, n) => x.Merge(n.Dependencies)))));
}
/// <summary>
/// Creates a <see cref="TypeReferenceTranslationResult"/>.
/// </summary>
/// <param name="referencedTypeName">Name, by which the type should be referenced in the translation.</param>
/// <param name="dependencies">Dependencies that are required by referencing the type.</param>
public TypeReferenceTranslationResult(string referencedTypeName, CodeDependencies dependencies)
{
if (string.IsNullOrWhiteSpace(referencedTypeName))
{
throw new ArgumentException("ReferencedTypeName cannot be empty.", nameof(referencedTypeName));
}
ReferencedTypeName = referencedTypeName;
Dependencies = dependencies ?? throw new ArgumentNullException(nameof(dependencies));
}
/// <summary>
/// Creates a set of dependencies that references the mapped type.
/// </summary>
/// <returns>A set of dependencies that references the mapped type.</returns>
public CodeDependencies CreateImportDependency()
{
// Source is optional; might be an ambient type (like "any").
if (string.IsNullOrWhiteSpace(Source))
{
return(CodeDependencies.Empty);
}
// Construct dependencies referencing the mapped type.
return(CodeDependencies.FromImports(new[] { new Import(Name, Source) }));
}
private string GenerateDependencyInitialization(CodeDependencies dependencies, ITemplatingEngine templatingEngine)
{
if (!Configuration.RuntimeDependencyLoading)
{
return(string.Empty);
}
var loadableDependencies = dependencies.CodeFragments
.Where(x => x.TryRecreateClrType(out var type) && !type.IsInterface)
.Select(x => x.ExportedName).Concat(dependencies.Imports.Select(x => x.Name));
return(templatingEngine.UseTemplate("DependencyInitialization", new Dictionary <string, string>
{
{ "Dependencies", string.Join(", ", loadableDependencies) }
}));
}
/// <summary>
/// Creates a DecoratorTranslationResult.
/// </summary>
/// <param name="decoratorCode">TypeScript code that contains the decorators.</param>
/// <param name="dependencies">Dependencies that are required for the decorators.</param>
public DecoratorTranslationResult(string decoratorCode, CodeDependencies dependencies)
{
DecoratorCode = decoratorCode;
Dependencies = dependencies ?? throw new ArgumentNullException(nameof(dependencies));
}
/// <summary>
/// Is overridden to define how the type reference is translated by this strategy.
/// </summary>
/// <param name="referencedType">Type reference that should be tranlated.</param>
/// <param name="translator">Full translator that can be used to translate parts of the complete type reference.</param>
/// <returns>Result of the translation.</returns>
public TypeReferenceTranslationResult Translate(Type referencedType)
=> new TypeReferenceTranslationResult(
referencedType.Name,
CodeDependencies.FromCodeFragments(new[] { CodeFragmentId.ForClrType(referencedType) }));
private string GeneratePropertyDefinitions(Type type, ITemplatingEngine templatingEngine, out CodeDependencies dependencies)
{
var propertyCodeSnippets = new List <string>();
var deps = CodeDependencies.Empty;
foreach (var property in type.GetProperties())
{
Logger.WriteInformation($"Translating property {property.Name} on type {type}.");
var typeReferenceTranslation = TypeReferenceTranslator.Translate(property.PropertyType);
deps = deps.Merge(typeReferenceTranslation.Dependencies);
propertyCodeSnippets.Add(templatingEngine.UseTemplate("InterfacePropertyDefinition", new Dictionary <string, string>
{
{ "PropertyName", GetTypeScriptPropertyName(property) },
{ "Documentation", GenerateDocumentationComment(property) },
{ "PropertyType", typeReferenceTranslation.ReferencedTypeName }
}));
}
dependencies = deps;
return(string.Join(Environment.NewLine, propertyCodeSnippets));
}
