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)
{
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)
{
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)
{
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();
}
}
protected virtual void WriteHeader(FileTemplate fileTemplate, IOutputCache output)
{
if (fileTemplate.Header?.Description != null)
{
this.Write(fileTemplate.Header, output);
output.BreakLine();
}
}
protected virtual void WriteUsings(FileTemplate fileTemplate, IOutputCache output)
{
List <UsingTemplate> usings = this.GetUsings(fileTemplate).ToList();
if (usings.Count <= 0)
{
return;
}
this.Write(usings, output);
output.BreakLine();
}
protected override void BeforeBlock(ICodeFragment fragment, IOutputCache output)
{
ConstructorTemplate constructorTemplate = (ConstructorTemplate)fragment;
if (constructorTemplate.ConstructorCall != null)
{
output.BreakLine()
.Indent()
.Add(": ")
.Add(constructorTemplate.ConstructorCall)
.UnIndent();
}
}
protected override void WriteHeader(FileTemplate fileTemplate, IOutputCache output, bool appendBlankLine = true)
{
base.WriteHeader(fileTemplate, output, false);
Dictionary <string, bool> linters = fileTemplate.Linters ?? new Dictionary <string, bool> {
{ "eslint", false }, { "tslint", false }
};
foreach (KeyValuePair <string, bool> linter in linters)
{
switch (linter.Key.ToLower())
{
case "eslint":
output.Add("/* eslint-disable */");
break;
case "tslint":
output.Add("// tslint:disable");
break;
}
output.BreakLine();
}
output.BreakLine();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ConstraintTemplate template = (ConstraintTemplate)fragment;
if (template.Types.Count == 0)
{
return;
}
output.BreakLine()
.Indent()
.Add("where ")
.Add(template.Name)
.Add(" : ")
.Add(template.Types, ", ")
.UnIndent();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
PropertyTemplate template = (PropertyTemplate)fragment;
PropertyTemplate previousProperty = output.LastFragments.TakeWhile(x => !(x is ClassTemplate)).OfType <PropertyTemplate>().Skip(1).FirstOrDefault();
if (previousProperty?.Attributes.Count > 0 || previousProperty != null && template.Attributes.Count > 0)
{
output.BreakLine();
}
if (template.Comment != null && !string.IsNullOrWhiteSpace(template.Comment.Description))
{
output.Add(template.Comment).BreakLine();
}
if (template.Attributes.Count > 0)
{
output.Add(template.Attributes);
}
output.Add(template.Visibility == Visibility.None ? string.Empty : template.Visibility.ToString().ToLower())
.Add(" ")
.Add(template.IsVirtual ? "virtual " : string.Empty)
.Add(template.IsStatic ? "static " : string.Empty)
.Add(template.Type)
.Add(" ")
.Add(template.Name);
if (template.HasGetter || template.HasSetter)
{
output.Add(" { ")
.Add(template.HasGetter ? "get; " : string.Empty)
.Add(template.HasSetter ? "set; " : string.Empty)
.Add("}");
}
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue)
.CloseLine();
}
if (template.Expression != null)
{
output.Add(" => ")
.Add(template.Expression)
.CloseLine();
}
output.BreakLineIfNotEmpty();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
FieldTemplate template = (FieldTemplate)fragment;
FieldTemplate lastTemplate = output.LastFragments.FirstOrDefault() as FieldTemplate;
if (template.Attributes.Count > 0 || lastTemplate?.Attributes.Count > 0)
{
output.BreakLine();
}
output.Add(template.Attributes)
.If(template.Visibility != Visibility.None).Add(template.Visibility.ToString().ToLower()).Add(" ").EndIf()
.If(template.IsStatic).Add("static ").EndIf()
.If(template.IsConstant).Add("const ").EndIf()
.If(template.IsReadonly).Add("readonly ").EndIf()
.Add(template.Type).Add(" ")
.Add(template.Name)
.If(template.DefaultValue != null && !template.Class.IsInterface).Add(" = ").Add(template.DefaultValue).EndIf()
.CloseLine();
}
public override void Write(ICodeFragment fragment, IOutputCache output)
{
EnumTemplate template = (EnumTemplate)fragment;
template.BasedOn = null;
base.Write(fragment, output);
output.BreakLine()
.Add($"export const {template.Name}Values = [").Add(template.Values.Select(x => x.Value), ", ").Add("]").CloseLine()
.Add($"export const {template.Name}Names = [").Add(template.Values.Select(x => Code.String(x.Name)), ", ").Add("]").CloseLine()
.Add($"export const {template.Name}ValueMapping: {{ [key: number]: string }} = {{ ");
bool isFirst = true;
foreach (EnumValueTemplate value in template.Values)
{
if (isFirst)
{
isFirst = false;
}
else
{
output.Add(", ");
}
output.Add(value.Value).Add(": ").Add(Code.String(value.Name));
}
output.Add(" }").CloseLine()
.Add($"export const {template.Name}NameMapping: {{ [key: string]: number }} = {{ ");
isFirst = true;
foreach (EnumValueTemplate value in template.Values)
{
if (isFirst)
{
isFirst = false;
}
else
{
output.Add(", ");
}
output.Add(Code.String(value.Name)).Add(": ").Add(value.Value);
}
output.Add(" }").CloseLine();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
BaseLanguage language = this.options.Language.CastTo <BaseLanguage>();
ClassTemplate template = (ClassTemplate)fragment;
output.Add(template.Comment);
output.Add(template.Attributes);
output.Add(language.ClassScope).Add(" ");
if (template.IsAbstract && language.HasAbstractClasses && !template.IsInterface)
{
output.Add("abstract ");
}
if (template.IsStatic && language.HasStaticClasses)
{
output.Add("static ");
}
else if (!string.IsNullOrEmpty(language.PartialKeyword))
{
output.Add(language.PartialKeyword).Add(" ");
}
if (template.IsInterface)
{
output.Add("interface ");
}
else
{
output.Add("class ");
}
output.Add(template.Name);
if (template.Generics.Count > 0)
{
output.Add("<").Add(template.Generics.Select(x => Code.Instance.Type(x.Name)), ", ").Add(">");
}
template.BasedOn.OrderBy(x => x.ToType().IsInterface).ForEach(x => output.Add(x));
output.Add(template.Generics.Select(x => x.ToConstraints()).Where(x => x.Types.Count > 0));
output.StartBlock();
if (template.IsInterface)
{
template.Fields.ForEach(x => x.Visibility = Visibility.None);
template.Properties.ForEach(x => x.Visibility = Visibility.None);
}
bool isFirst = true;
if (template.Classes.Count > 0)
{
output.Add(template.Classes);
isFirst = false;
}
if (template.Fields.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Fields);
isFirst = false;
}
if (template.Properties.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Properties);
isFirst = false;
}
if (template.Code != null)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Code);
isFirst = false;
}
if (template.Methods.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
MethodTemplate last = template.Methods.Last();
foreach (MethodTemplate method in template.Methods)
{
output.Add(method);
if (method != last)
{
output.BreakLine();
}
}
}
if (this.options.Formatting.CollapseEmptyClasses && output.LastFragments.First().Equals(template))
{
output.UnBreakLine();
output.Add(this.options.Formatting.CollapsedClassesSpacer, true);
}
output.EndBlock();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
output.BreakLine();
}