/// <summary>
/// Generates class definition and appends it to the output.
/// </summary>
/// <param name="classModel">The class to generate definition for.</param>
/// <param name="sb">The output.</param>
/// <param name="generatorOutput"></param>
protected virtual void AppendConstantModule(TsClass classModel, ScriptBuilder sb)
{
if (!classModel.Constants.Any())
{
return;
}
string typeName = this.GetTypeName(classModel);
sb.AppendLineIndented(string.Format("export namespace {0} {{", typeName));
using (sb.IncreaseIndentation())
{
foreach (var property in classModel.Constants)
{
if (property.IsIgnored)
{
continue;
}
_docAppender.AppendConstantModuleDoc(sb, property, this.GetPropertyName(property), this.GetPropertyType(property));
sb.AppendFormatIndented("export const {0}: {1} = {2};", this.GetPropertyName(property), this.GetPropertyType(property), this.GetPropertyConstantValue(property));
sb.AppendLine();
}
}
sb.AppendLineIndented("}");
_generatedClasses.Add(classModel);
}
protected virtual void AppendEnumDefinition(TsEnum enumModel, ScriptBuilder sb, TsGeneratorOutput output)
{
string typeName = this.GetTypeName(enumModel);
string visibility = (output & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums || (output & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants ? "export " : "";
_docAppender.AppendEnumDoc(sb, enumModel, typeName);
string constSpecifier = this.GenerateConstEnums ? "const " : string.Empty;
sb.AppendLineIndented(string.Format("{0}{2}enum {1} {{", visibility, typeName, constSpecifier));
using (sb.IncreaseIndentation())
{
int i = 1;
foreach (var v in enumModel.Values)
{
_docAppender.AppendEnumValueDoc(sb, v);
switch (EnumMode)
{
case TsEnumModes.String:
sb.AppendLineIndented($"{v.Name} = \"{v.Name}\"{(i < enumModel.Values.Count ? "," : "")}");
break;
default:
sb.AppendLineIndented($"{v.Name} = {v.Value}{(i < enumModel.Values.Count ? "," : "")}");
break;
}
i++;
}
}
sb.AppendLineIndented("}");
_generatedEnums.Add(enumModel);
}
/// <summary>
/// Generates class definition and appends it to the output.
/// </summary>
/// <param name="classModel">The class to generate definition for.</param>
/// <param name="sb">The output.</param>
/// <param name="generatorOutput"></param>
protected virtual void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
string typeName = this.GetTypeName(classModel);
string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : "";
_docAppender.AppendClassDoc(sb, classModel, typeName);
sb.AppendFormatIndented("{0}{1} {2}", visibility, Mode == TsGenerationModes.Definitions ? "interface" : "class", typeName);
if (classModel.BaseType != null)
{
sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType));
}
if (classModel.Interfaces.Count > 0)
{
var implementations = classModel.Interfaces.Select(GetFullyQualifiedTypeName).ToArray();
var prefixFormat = classModel.Type.IsInterface ? " extends {0}"
: classModel.BaseType != null ? " , {0}"
: " extends {0}";
sb.AppendFormat(prefixFormat, string.Join(" ,", implementations));
}
sb.AppendLine(" {");
var members = new List <TsProperty>();
if ((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties)
{
members.AddRange(classModel.Properties);
}
if ((generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
members.AddRange(classModel.Fields);
}
using (sb.IncreaseIndentation())
{
foreach (var property in members.Where(p => !p.IsIgnored).OrderBy(p => this.GetPropertyName(p)))
{
_docAppender.AppendPropertyDoc(sb, property, this.GetPropertyName(property), this.GetPropertyType(property));
sb.AppendLineIndented(string.Format("{0}: {1};", this.GetPropertyName(property), this.GetPropertyType(property)));
}
}
sb.AppendLineIndented("}");
_generatedClasses.Add(classModel);
}
protected virtual void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
List <TsClass> classesByName = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).OrderBy(c => GetTypeName(c)).ToList();
List <TsClass> classes = SortByDependency(classesByName);
var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).OrderBy(e => GetTypeName(e)).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Constants && !classes.Any(c => c.Constants.Any()))
{
return;
}
var moduleName = GetModuleName(module);
var generateModuleHeader = moduleName != string.Empty;
if (generateModuleHeader)
{
if (generatorOutput != TsGeneratorOutput.Enums &&
(generatorOutput & TsGeneratorOutput.Constants) != TsGeneratorOutput.Constants)
{
sb.Append(Mode == TsGenerationModes.Definitions ? "declare " : " export ");
}
sb.AppendLine($"{(Mode == TsGenerationModes.Definitions ? "namespace" : "module")} {moduleName} {{");
using (sb.IncreaseIndentation())
{
GenerateModuleContent(sb, generatorOutput, classes, enums);
}
sb.AppendLine("}");
}
else
{
GenerateModuleContent(sb, generatorOutput, classes, enums);
}
}
protected virtual void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
var classes = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).OrderBy(c => GetTypeName(c)).ToList();
var baseClasses = classes
.Where(c => c.BaseType != null)
.Select(c => c.BaseType.Type.FullName)
.Distinct()
.OrderBy(c => c)
.ToList();
var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).OrderBy(e => GetTypeName(e)).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Properties && !classes.Any(c => c.Fields.Any() || c.Properties.Any()))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Constants && !classes.Any(c => c.Constants.Any()))
{
return;
}
var moduleName = GetModuleName(module);
var generateModuleHeader = moduleName != string.Empty;
if (generateModuleHeader)
{
if (generatorOutput != TsGeneratorOutput.Enums &&
(generatorOutput & TsGeneratorOutput.Constants) != TsGeneratorOutput.Constants)
{
sb.Append(Mode == TsGenerationModes.Definitions ? "declare " : " export ");
}
sb.AppendLine($"{(Mode == TsGenerationModes.Definitions ? "namespace" : "module")} {moduleName} {{");
}
using (sb.IncreaseIndentation())
{
if ((generatorOutput & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums)
{
foreach (var enumModel in enums)
{
this.AppendEnumDefinition(enumModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
foreach (var baseClassModel in classes.Where(c => baseClasses.Contains(c.Type.FullName)))
{
this.AppendClassDefinition(baseClassModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
foreach (var classModel in classes.Where(c => !baseClasses.Contains(c.Type.FullName)))
{
this.AppendClassDefinition(classModel, sb, generatorOutput);
}
}
if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants)
{
foreach (var classModel in classes)
{
if (classModel.IsIgnored)
{
continue;
}
this.AppendConstantModule(classModel, sb);
}
}
}
if (generateModuleHeader)
{
sb.AppendLine("}");
}
}