/// <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); }
/// <summary> /// Generates TypeScript definitions for classes and/or enums in the model. /// </summary> /// <param name="model">The code model with classes to generate definitions for.</param> /// <param name="generatorOutput">The type of definitions to generate</param> /// <returns>TypeScript definitions for classes and/or enums in the model..</returns> public string Generate(TsModel model, TsGeneratorOutput generatorOutput) { var sb = new ScriptBuilder(this.IndentationString); if ((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties || (generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants) { // We can't generate constants together with properties or fields, because we can't set values in a .d.ts file. throw new InvalidOperationException("Cannot generate constants together with properties or fields"); } foreach (var reference in _references.Concat(model.References)) { this.AppendReference(reference, sb); } sb.AppendLine(); } // We can't just sort by the module name, because a formatter can jump in and change it so // format by the desired target name foreach (var module in model.Modules.OrderBy(m => GetModuleName(m))) { this.AppendModule(module, sb, generatorOutput); } return(sb.ToString()); }
/// <summary> /// Generates TypeScript definitions for classes and/or enums in the model. /// </summary> /// <param name="model">The code model with classes to generate definitions for.</param> /// <param name="generatorOutput">The type of definitions to generate</param> /// <returns>TypeScript definitions for classes and/or enums in the model..</returns> public string Generate(TsModel model, TsGeneratorOutput generatorOutput) { var sb = new ScriptBuilder(this.IndentationString); if ((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties || (generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants) { // We can't generate constants together with properties or fields, because we can't set values in a .d.ts file. throw new InvalidOperationException("Cannot generate constants together with properties or fields"); } foreach (var reference in _references.Concat(model.References)) { this.AppendReference(reference, sb); } sb.AppendLine(); } foreach (var module in model.Modules) { this.AppendModule(module, sb, generatorOutput); } return(sb.ToString()); }
/// <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}class {1}", visibility, 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) { if (property.IsIgnored) { continue; } _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) { var classes = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).OrderBy(c => GetTypeName(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("declare "); } sb.AppendLine(string.Format("namespace {0} {{", 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 classModel in classes) { 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("}"); } }
/// <summary> /// Generates reference to other d.ts file and appends it to the output. /// </summary> /// <param name="reference">The reference file to generate reference for.</param> /// <param name="sb">The output</param> protected virtual void AppendReference(string reference, ScriptBuilder sb) { sb.AppendFormat("/// <reference path=\"{0}\" />", reference); sb.AppendLine(); }