public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
UsingTemplate template = (UsingTemplate)fragment;
if (template is UnknownExportTemplate unknownUsing)
{
output.Add(unknownUsing.Code).BreakLine();
return;
}
if (template.Path == null || template.Type == null)
{
Logger.Error("Invalid TypeScript import/export (path or type is missing)");
return;
}
string action = template is ExportTemplate ? "export" : "import";
string typeName = template.Type;
if (!typeName.StartsWith("*"))
{
typeName = $"{{ {typeName} }}";
}
output.Add($"{action} {typeName} from ")
.Add(this.options.Formatting.Quote)
.Add(template.Path.TrimEnd(".ts"))
.Add(this.options.Formatting.Quote)
.CloseLine();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
BaseLanguage language = this.options.Language.CastTo <BaseLanguage>();
EnumTemplate template = (EnumTemplate)fragment;
output.Add(template.Attributes)
.Add(language.ClassScope)
.Add(" enum ")
.Add(template.Name);
if (template.BasedOn != null)
{
output.Add(" : ").Add(template.BasedOn);
}
output.StartBlock();
EnumValueTemplate last = template.Values.LastOrDefault();
foreach (EnumValueTemplate enumTemplateValue in template.Values)
{
output.Add($"{enumTemplateValue.FormattedName} = ")
.Add(enumTemplateValue.Value)
.Add(last == enumTemplateValue ? string.Empty : ",")
.BreakLine();
}
output.EndBlock();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
FileTemplate template = (FileTemplate)fragment;
if (string.IsNullOrEmpty(template.Name))
{
Logger.Trace("Empty file skipped");
return;
}
if (template.Header.Description != null)
{
AssemblyName assemblyName = (Assembly.GetEntryAssembly() ?? Assembly.GetCallingAssembly()).GetName();
template.Header.Description = string.Format(template.Header.Description, $"{assemblyName.Name} {assemblyName.Version}");
}
template.FullPath = FileSystem.Combine(template.RelativePath, template.Name);
this.WriteHeader(template, output);
if (template is StaticFileTemplate staticFile)
{
output.Add(staticFile.Content, true);
}
else
{
this.WriteUsings(template, output);
output.Add(template.Namespaces);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
CommentTemplate comment = (CommentTemplate)fragment;
if (comment.IsEmpty())
{
return;
}
foreach (string line in this.SplitLines(comment.Description))
{
if (line.TrimStart().StartsWith("/*"))
{
if (line.EndsWith("*/"))
{
output.Add(line);
}
else
{
output.Add(line.Replace("*/", "*/ //"));
}
}
else
{
output.Add($"// {line}".Trim());
}
output.BreakLine();
}
}
public void Write(TypeTemplate template, IOutputCache output)
{
if (template.IsNullable)
{
output.Add(string.Format(this.NullableFormatter, template.Name));
}
else
{
output.Add(template.Name);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
NumberTemplate template = (NumberTemplate)fragment;
if (template.FloatValue.HasValue)
{
output.Add($"{template.FloatValue?.ToString(CultureInfo.InvariantCulture)}f");
}
else
{
output.Add(template.LongValue?.ToString(CultureInfo.InvariantCulture) ?? template.DoubleValue?.ToString(CultureInfo.InvariantCulture));
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
output.Add(template.Name)
.Add(": ")
.Add(template.Type);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
public override void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
output.Add(template.Name)
.If(template.IsOptional).Add("?").EndIf()
.Add(": ")
.Add(template.Type);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
public void Write(GenericTypeTemplate template, IOutputCache output)
{
TypeTemplate keyType = template.Types.First();
TypeTemplate valueType = template.Types.Second();
if (keyType.Name == "string" || keyType.Name == "number")
{
output.Add($"{{ [key: {keyType.Name}]: {valueType.Name}; }}");
}
else
{
output.Add($"{{ /* unsupported type for key. Expected string or number. Got '{keyType.Name}' */. }}");
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ReturnTemplate template = (ReturnTemplate)fragment;
if (template.Code == null)
{
output.Add("return").CloseLine();
}
else
{
output.Add("return ")
.Add(template.Code)
.CloseLine();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
template.Attributes.ForEach(x => x.IsInline = true);
output.Add(template.Attributes)
.Add(template.Type)
.Add(" ")
.Add(template.Name);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
MethodTemplate template = (MethodTemplate)fragment;
if (template.Generics != null && template.Generics.Any(x => x.DefaultType != null))
{
throw new InvalidOperationException($"This language does not support default types for generic methods. {template.Class.Name}.{template.Name}");
}
output.Add(template.Comment)
.Add(template.Attributes)
.Add(template.Visibility.ToString().ToLower()).Add(" ")
.If(template.IsStatic).Add("static ").EndIf()
.If(template.IsOverride).Add("override ").EndIf()
.If(template.Type != null).Add(template.Type).Add(" ").EndIf()
.Add(template.Name)
.If(template.Generics != null && template.Generics.Count > 0).Add("<").Add(template.Generics, ", ").Add(">").EndIf()
.Add("(")
.If(template is ExtensionMethodTemplate).Add("this ").EndIf()
.Add(template.Parameters.OrderBy(x => x.DefaultValue == null ? 0 : 1), ", ")
.Add(")");
this.BeforeBlock(fragment, output);
output.StartBlock()
.Add(template.Code)
.EndBlock();
}
public void Write(ICodeFragment fragment, IOutputCache output)
{
UsingDeclarationTemplate template = (UsingDeclarationTemplate)fragment;
output.Add("using ")
.Add(template.Code);
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
TypeScriptTemplate template = (TypeScriptTemplate)fragment;
output.Add(template.Code);
if (template.CloseAfter)
{
output.CloseLine();
}
if (template.BreakAfter)
{
output.BreakLine();
}
if (template.StartBlockAfter)
{
output.StartBlock();
}
if (template.EndBlockAfter)
{
output.EndBlock();
}
if (template.IndentAfter)
{
output.Indent();
}
if (template.UnindentAfter)
{
output.UnIndent();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
PropertyTemplate template = (PropertyTemplate)fragment;
FieldTemplate fieldTemplate = new FieldTemplate(template.Class, template.Name, template.Type).FormatName(output.Language, true);
if (fieldTemplate.Name == template.Name)
{
fieldTemplate.Name += "Field";
}
fieldTemplate.DefaultValue = template.DefaultValue;
output.Add(fieldTemplate);
if (template.HasGetter)
{
output.If(template.Visibility != Visibility.None).Add(template.Visibility.ToString().ToLower()).Add(" ").EndIf()
.If(template.IsStatic).Add("static ").EndIf()
.Add($"get {template.Name}(): ")
.Add(template.Type)
.StartBlock()
.Add(Code.Return(Code.This().Field(fieldTemplate.Name)))
.EndBlock();
}
if (template.HasSetter)
{
output.If(template.Visibility != Visibility.None).Add(template.Visibility.ToString().ToLower()).Add(" ").EndIf()
.If(template.IsStatic).Add("static ").EndIf()
.Add($"set {template.Name}(value: ")
.Add(template.Type)
.Add(")")
.StartBlock()
.Add(Code.This().Field(fieldTemplate.Name).Assign(Code.Local("value")).Close())
.EndBlock();
}
}
public void Write(ICodeFragment fragment, IOutputCache output)
{
MethodGenericTemplate template = (MethodGenericTemplate)fragment;
output.Add(template.Alias)
.If(template.DefaultType != null).Add(" = ").Add(template.DefaultType).EndIf();
}
public void Write(GenericTypeTemplate template, IOutputCache output)
{
output.Add(template.Name)
.Add("<")
.Add(template.Types, ", ")
.Add(">");
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
NullCoalescingTemplate template = (NullCoalescingTemplate)fragment;
output.Add(" ?? ")
.Add(template.Code);
}
private void WriteChained(ChainedCodeFragment fragment, IOutputCache output)
{
this.progressedChainedCodeFragments.Add(fragment.First());
bool isFirst = true;
foreach (ChainedCodeFragment codeFragment in fragment.First().Yield().Cast <ChainedCodeFragment>())
{
if (!isFirst)
{
output.Add(codeFragment.Separator);
}
isFirst = false;
this.Write(codeFragment, output);
//output.Add(codeFragment, this);
if (codeFragment.NewLineAfter)
{
output.BreakLine();
}
if (codeFragment.CloseAfter)
{
output.CloseLine();
}
if (codeFragment.BreakAfter)
{
output.BreakLine().ExtraIndent();
}
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
AnonymousObjectTemplate template = (AnonymousObjectTemplate)fragment;
output.Add("{")
.Indent();
PropertyValueTemplate last = template.Properties.LastOrDefault();
foreach (PropertyValueTemplate property in template.Properties)
{
output.Add($"{property.Name}: ")
.Add(property.Value)
.If(property != last).Add(",").EndIf()
.BreakLine();
}
output.UnIndent().Add("}");
}
protected virtual void WriteHeader(FileTemplate fileTemplate, IOutputCache output, bool appendBlankLine = true)
{
if (fileTemplate.Header?.Description != null)
{
output.Add(fileTemplate.Header)
.If(appendBlankLine).BreakLine().EndIf();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
CastTemplate template = (CastTemplate)fragment;
output.Add("(")
.Add(template.Type)
.Add(")");
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
NullCoalescingOperatorTemplate template = (NullCoalescingOperatorTemplate)fragment;
output.Add(template.LeftCode)
.Add(" ?? ")
.Add(template.RightCode);
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
TypeOfTemplate template = (TypeOfTemplate)fragment;
output.Add("typeof(")
.Add(template.Type)
.Add(")");
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
StringTemplate template = (StringTemplate)fragment;
output.Add(this.options.Formatting.Quote)
.Add(template.Value)
.Add(this.options.Formatting.Quote);
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ParenthesisTemplate template = (ParenthesisTemplate)fragment;
output.Add("(")
.Add(template.Code)
.Add(")");
}
public void Write(ICodeFragment fragment, IOutputCache output)
{
YieldReturnTemplate template = (YieldReturnTemplate)fragment;
output.Add("yield return ")
.Add(template.Code)
.CloseLine();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
AttributeTemplate template = (AttributeTemplate)fragment;
output.Add("[")
.Add(template.Name);
if (template.HasValue || template.Properties.Count > 0)
{
output.Add("(");
if (template.HasValue)
{
output.Add(template.Code);
}
if (template.Properties.Count > 0)
{
foreach (KeyValuePair <string, object> pair in template.Properties)
{
output.Add($"{pair.Key} = {this.Language.ConvertValue(pair.Value)}");
}
}
output.Add(")");
}
output.Add("]");
if (template.IsInline)
{
output.Add(" ");
}
else
{
output.BreakLine();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
LambdaTemplate template = (LambdaTemplate)fragment;
output.Add("(");
if (template.Parameters != null)
{
output.Add(template.Parameters, ", ");
}
else if (template.ParameterNames?.Count == 1)
{
output.Add(template.ParameterNames[0]);
}
else if (template.ParameterNames?.Count > 1)
{
output.Add(string.Join(", ", template.ParameterNames));
}
output.Add(")")
.Add(" =>");
if (template.Code is MultilineCodeFragment)
{
output.StartBlock();
}
else
{
output.Add(" ");
}
output.Add(template.Code);
if (template.Code is MultilineCodeFragment)
{
output.EndBlock(this.options.Formatting.StartBlockInNewLine);
}
}
public override void Write(ICodeFragment fragment, IOutputCache output)
{
VerbatimStringTemplate template = (VerbatimStringTemplate)fragment;
output.Add("@")
.Add(this.options.Formatting.Quote)
.Add(template.Value, true)
.Add(this.options.Formatting.Quote);
}