private void AppendInterfaceDef(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { AddNamespaceHeaderEnum(classModel.Name, classModel.Type.Assembly.FullName, sb); var typeName = this.GetTypeName(classModel); var visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; _docAppender.AppendClassDoc(sb, classModel, typeName); sb.AppendFormatIndented("{0}interface {1}", visibility, typeName); if (classModel.BaseType != null) { sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType)); } var interfaces = classModel.Interfaces.Where(m => CsharpTypeInfoProvider.ExposedInterfaces.Contains(m.Type)).ToList(); if (interfaces.Count > 0) { var implementations = interfaces.Select(GetFullyQualifiedTypeName).ToArray(); var prefixFormat = " implements {0}"; sb.AppendFormat(prefixFormat, string.Join(" ,", implementations)); } sb.AppendLine(" {"); GenerateProperties(classModel, sb, generatorOutput); 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()); }
private void GenerateProperties(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { 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 || PropertyTypesToIgnore(property.PropertyType.Type) || (_typesPropertiesToIgnore.ContainsKey(classModel.Type) && _typesPropertiesToIgnore[classModel.Type].Contains(property.Name))) { continue; } AddDocCommentForCustomJsonConverter(sb, property); _docAppender.AppendPropertyDoc(sb, property, this.GetPropertyName(property), this.GetPropertyType(property)); sb.AppendLineIndented($"{this.GetPropertyName(property)}: {this.GetPropertyType(property)};"); } if (classModel.Type == typeof(PropertyBase)) { sb.AppendLineIndented($"type: string;"); } } }
public static string GetTypeLitePocos(this IEnumerable <Type> types, TsGeneratorOutput output, bool useNamespace = true, bool isExported = true) { var replacements = new List <string>(); var def = TypeScript.Definitions(); foreach (var type in types) { def.For(type); var r = type.DeclaringType?.FullName; if (r != null && string.IsNullOrEmpty(type.Namespace)) { replacements.Add(r); } } var script = def.Generate(output); if (isExported) { script = script.Replace("interface ", "export interface "); } if (useNamespace) { script = script.Replace("declare module ", "namespace "); } return(script); }
private void GenerateModuleContent(ScriptBuilder sb, TsGeneratorOutput generatorOutput, List <TsClass> classes, List <TsEnum> enums) { 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); } } }
public static string GetTypeLitePoco(this Type type, TsGeneratorOutput output, bool useNamespace = true, bool isExported = true) { var name = type.DeclaringType?.FullName; var poco = TypeScript.Definitions().For(type).Generate(output); if (isExported) { poco = poco.Replace("interface ", " export interface "); } if (useNamespace) { poco = poco.Replace("declare module ", "namespace "); } return(poco); }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendFormatIndented( "{0}class {1} extends {2}", visibility, typeName, //all bottom-level classes must extend Backbone.Model. classModel.BaseType != null ? this.GetFullyQualifiedTypeName(classModel.BaseType) : "Backbone.Model"); 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; } sb.AppendLineIndented(string.Format( "get {0}(): {1} {{ return this.get(\"{0}\"); }}", this.GetPropertyName(property), this.GetPropertyType(property))); sb.AppendLineIndented(string.Format( "set {0}(v: {1}) {{ this.set(\"{0}\", v); }}", 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); } }
private void AppendClassDef(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { AddNamespaceHeader(classModel.Name, sb); var typeName = this.GetTypeName(classModel); var visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; AddRequestRenameInformation(sb, classModel); AddDocCommentForCustomJsonConverter(sb, classModel); _docAppender.AppendClassDoc(sb, classModel, typeName); sb.AppendFormatIndented("{0}class {1}", visibility, typeName); if (CsharpTypeInfoProvider.StringAbstractions.Contains(classModel.Type)) { sb.AppendLineIndented(" extends String {}"); return; } void EnforceBaseClass <TInterface, TBase>() { if (classModel.BaseType != null) { return; } if (classModel.Type == typeof(TBase)) { return; } if (typeof(TInterface).IsAssignableFrom(classModel.Type)) { classModel.BaseType = new TsClass(typeof(TBase)); } } EnforceBaseClass <IAnalyzer, AnalyzerBase>(); EnforceBaseClass <ITokenizer, TokenizerBase>(); EnforceBaseClass <ITokenFilter, TokenFilterBase>(); EnforceBaseClass <ICharFilter, CharFilterBase>(); EnforceBaseClass <IProperty, PropertyBase>(); EnforceBaseClass <IResponse, ResponseBase>(); if (classModel.BaseType != null) { sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType)); } var interfaces = classModel.Interfaces.Where(m => CsharpTypeInfoProvider.ExposedInterfaces.Contains(m.Type)).ToList(); if (interfaces.Count > 0) { var implementations = interfaces.Select(GetFullyQualifiedTypeName).ToArray(); var prefixFormat = " implements {0}"; sb.AppendFormat(prefixFormat, string.Join(" ,", implementations)); } sb.AppendLine(" {"); GenerateProperties(classModel, sb, generatorOutput); sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); //generate a closed cat response type (NEST uses catresponse<TRecord> for all) if (typeof(ICatRecord).IsAssignableFrom(classModel.Type)) { var catResponseName = classModel.Type.Name.Replace("Record", "Response"); AddNamespaceHeader(classModel.Name, sb); sb.AppendLineIndented($"class {catResponseName} extends ResponseBase {{"); using (sb.IncreaseIndentation()) sb.AppendLineIndented($"records: {typeName}[];"); sb.AppendLineIndented("}"); } }
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; string valuesList = ""; string descriptionsList = ""; foreach (var v in enumModel.Values) { _docAppender.AppendEnumValueDoc(sb, v); bool appendComma = enumModel.IsOutputValuesList || enumModel.IsOutputDescriptionsList || (i < enumModel.Values.Count); if (enumModel.IsValueAsStringOfName) { sb.AppendLineIndented(string.Format(appendComma ? "{0} = '{0}'," : "{0} = '{0}'", v.Name)); if (enumModel.IsOutputValuesList) { valuesList += string.Format((i < enumModel.Values.Count) ? "{0}|" : "{0}", v.Name); } } else { sb.AppendLineIndented(string.Format(appendComma ? "{0} = {1}," : "{0} = {1}", v.Name, v.Value)); if (enumModel.IsOutputValuesList) { valuesList += string.Format(i < enumModel.Values.Count ? "{0}|" : "{0}", v.Value); } } if (enumModel.IsOutputDescriptionsList) { descriptionsList += string.Format(i < enumModel.Values.Count ? "{0}|" : "{0}", v.Description); } i++; } if (enumModel.IsOutputValuesList) { sb.AppendLineIndented(string.Format(enumModel.IsOutputDescriptionsList ? "_ValuesList = '{0}'," : "_ValuesList = '{0}'", valuesList)); } if (enumModel.IsOutputDescriptionsList) { sb.AppendLineIndented(string.Format("_DescriptionsList = '{0}'", descriptionsList)); } } sb.AppendLineIndented("}"); _generatedEnums.Add(enumModel); }
/// <summary> /// /// </summary> /// <param name="classModel"></param> /// <param name="sb"></param> /// <param name="generatorOutput"></param> protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendFormatIndented("{0}interface {1}", visibility, typeName); if (classModel.BaseType != null) { sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType)); } 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; } var propTypeName = this.GetPropertyType(property); if (property.PropertyType.IsCollection()) { //Note: new member functon checking if property is collection or not //Also remove the array brackets from the name if (propTypeName.Length > 2 && propTypeName.Substring(propTypeName.Length - 2) == "[]") { propTypeName = propTypeName.Substring(0, propTypeName.Length - 2); } propTypeName = "KnockoutObservableArray<" + propTypeName + ">"; } else { propTypeName = "KnockoutObservable<" + propTypeName + ">"; } sb.AppendLineIndented(string.Format("{0}: {1};", this.GetPropertyName(property), propTypeName)); } } 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); sb.AppendLineIndented(string.Format(i < enumModel.Values.Count ? "{0} = {1}," : "{0} = {1}", v.Name, v.Value)); i++; } } sb.AppendLineIndented("}"); _generatedEnums.Add(enumModel); }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { base.AppendClassDefinition(classModel, sb, generatorOutput); }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { if (classModel.Type.IsInterface && CsharpTypeInfoProvider.ExposedInterfaces.Contains(classModel.Type)) { AppendInterfaceDef(classModel, sb, generatorOutput); } else { AppendClassDef(classModel, sb, generatorOutput); } }
protected override void AppendEnumDefinition(TsEnum enumModel, ScriptBuilder sb, TsGeneratorOutput output) { if (!AddNamespaceHeaderEnum(enumModel.Name, enumModel.Type.Assembly.FullName, sb)) { return; } if (_typesToIgnore.Contains(enumModel.Type)) { return; } var typeName = this.GetTypeName(enumModel); var visibility = string.Empty; _docAppender.AppendEnumDoc(sb, enumModel, typeName); var constSpecifier = this.GenerateConstEnums ? "const " : string.Empty; sb.AppendLineIndented(string.Format("{0}{2}enum {1} {{", visibility, typeName, constSpecifier)); using (sb.IncreaseIndentation()) { var i = 1; foreach (var v in enumModel.Values) { _docAppender.AppendEnumValueDoc(sb, v); var enumMemberAttribute = v.Field.GetCustomAttribute <EnumMemberAttribute>(); var name = (!string.IsNullOrEmpty(enumMemberAttribute?.Value) ? enumMemberAttribute.Value : v.Name).QuoteMaybe(); sb.AppendLineIndented(string.Format(i < enumModel.Values.Count ? "{0} = {1}," : "{0} = {1}", name, v.Value)); i++; } } sb.AppendLineIndented("}"); _generatedEnums.Add(enumModel); }
protected override void AppendEnumDefinition(TsEnum enumModel, ScriptBuilder sb, TsGeneratorOutput output) { base.AppendEnumDefinition(enumModel, sb, TsGeneratorOutput.Enums); }
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { var classes = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).ToList(); var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).ToList(); if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) || (generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) || (enums.Count == 0 && classes.Count == 0)) { return; } if ((generatorOutput & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums) { foreach (var enumModel in enums) { if (Ignore(enumModel)) { continue; } this.AppendEnumDefinition(enumModel, sb, generatorOutput); } } if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) || (generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { var cc = classes.Select(c => new { c, order = OrderTypes(c) }).ToList(); var orderedClasses = cc.OrderBy(c => c.order).ToList(); foreach (var oc in orderedClasses) { var classModel = oc.c; var t = classModel.Type; // var x = $"// {oc.order} - {oc.c.Type.FullName}"; // sb.AppendIndented(x); if (t.IsInterface && !CsharpTypeInfoProvider.ExposedInterfaces.Contains(t) && CsharpTypeInfoProvider.ExposedInterfaces.Any(i => i.IsAssignableFrom(t))) { continue; } var c = ReMapClass(classModel); if (Ignore(c)) { continue; } if (this._appended.Contains(c.Name)) { continue; } if (this._appended.Contains("I" + c.Name)) { continue; } this.AppendClassDefinition(c, sb, generatorOutput); this._appended.Add(c.Name); } } if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants) { foreach (var classModel in classes) { if (classModel.IsIgnored) { continue; } this.AppendConstantModule(classModel, sb); } } }
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("}"); } }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { if (classModel.Name == "ConnectionConfigurationValues") { return; } if (classModel.Name == "RequestData") { return; } if (classModel.Name == "ISortOrder") { return; } if (classModel.Type.IsInterface && CsharpTypeInfoProvider.ExposedInterfaces.Contains(classModel.Type)) { AppendInterfaceDef(classModel, sb, generatorOutput); } else { AppendClassDef(classModel, sb, generatorOutput); } }
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { base.AppendModule(module, sb, generatorOutput); }
private void AppendKoInterfaceDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendIndented($"{visibility}interface {typeName}"); if (classModel.BaseType != null) { sb.Append($" extends {this.GetFullyQualifiedTypeName(classModel.BaseType)}"); } 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 (TsProperty property in members) { if (property.IsIgnored) { continue; } string propTypeName = this.GetPropertyType(property); if (IsCollection(property)) { if (propTypeName.Length > 2 && propTypeName.Substring(propTypeName.Length - 2) == "[]") { propTypeName = propTypeName.Substring(0, propTypeName.Length - 2); } propTypeName = "ko.ObservableArray<" + propTypeName + ">"; } else { propTypeName = "ko.Subscribable<" + propTypeName + ">"; } sb.AppendLineIndented($"{this.GetPropertyName(property)}: {propTypeName};"); } } sb.AppendLineIndented("}"); }
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { // Use reflection to grab the internal property which was removed! var typeConverters = (TypeConvertorCollection)_typeConvertersMember.GetValue(this); var classes = module.Classes.Where(c => !typeConverters.IsConvertorRegistered(c.Type) && !c.IsIgnored) // .OrderBy(c => GetTypeName(c)) // Sorting breaks inheritance .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 => !typeConverters.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; } string moduleName = GetModuleName(module); bool 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 (TsEnum enumModel in enums) { this.AppendEnumDefinition(enumModel, sb, generatorOutput); } } if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) || (generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { foreach (TsClass 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 (TsClass classModel in classes.Where(c => !baseClasses.Contains(c.Type.FullName))) { this.AppendClassDefinition(classModel, sb, generatorOutput); } } if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants) { foreach (TsClass classModel in classes) { if (classModel.IsIgnored) { continue; } this.AppendConstantModule(classModel, sb); } } } if (generateModuleHeader) { sb.AppendLine("}"); } }
/// <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}interface {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.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); }
/// <summary> /// Appends the appropriate class definition for the specified member /// </summary> /// <param name="classModel"></param> /// <param name="sb"></param> /// <param name="generatorOutput"></param> protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { Tags.TryGetValue(classModel, out string tag); sb.AppendLineIndented($"// {classModel.Name} ({tag})"); switch (tag) { case KoClass: AppendClassDefinition(classModel, sb, generatorOutput, true); break; case KoInterface: AppendKoInterfaceDefinition(classModel, sb, generatorOutput); break; case Poco: AppendClassDefinition(classModel, sb, generatorOutput, false); break; default: base.AppendClassDefinition(classModel, sb, generatorOutput); break; } _generatedClasses.Add(classModel); }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendFormatIndented( "{0}class {1} extends {2}", visibility, typeName, //all bottom-level classes must extend Backbone.Model. classModel.BaseType != null ? this.GetFullyQualifiedTypeName(classModel.BaseType) : "Backbone.Model"); 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; } sb.AppendLineIndented(string.Format( "get {0}(): {1} {{ return this.get(\"{0}\"); }}", this.GetPropertyName(property), this.GetPropertyType(property))); sb.AppendLineIndented(string.Format( "set {0}(v: {1}) {{ this.set(\"{0}\", v); }}", this.GetPropertyName(property), this.GetPropertyType(property))); } } sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); }
private void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput, bool ko) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendIndented($"{visibility}class {typeName}"); if (classModel.BaseType != null) { string baseTypeName = this.GetFullyQualifiedTypeName(classModel.BaseType); if (baseTypeName.StartsWith(classModel.Module.Name + ".", StringComparison.Ordinal)) { baseTypeName = baseTypeName.Substring(classModel.Module.Name.Length + 1); } sb.Append($" extends {baseTypeName}"); sb.AppendLine(" {"); using (sb.IncreaseIndentation()) { sb.AppendLineIndented("constructor() {"); using (sb.IncreaseIndentation()) { sb.AppendLineIndented("super();"); } sb.AppendLineIndented("}"); } } else { 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 (TsProperty property in members.Where(m => !m.IsIgnored)) { string propTypeName = this.GetPropertyType(property); if (IsCollection(property)) { if (propTypeName.EndsWith("[]", StringComparison.Ordinal)) { propTypeName = propTypeName.Substring(0, propTypeName.Length - "[]".Length); } if (ko) { sb.AppendLineIndented($"{this.GetPropertyName(property)}: ko.ObservableArray<{propTypeName}> = ko.observableArray([]);"); } else { sb.AppendLineIndented($"{this.GetPropertyName(property)}: {propTypeName}[];"); } } else { if (ko) { sb.AppendLineIndented($"{this.GetPropertyName(property)}: ko.Subscribable<{propTypeName}> = ko.observable(null);"); } else { sb.AppendLineIndented($"{this.GetPropertyName(property)}: {propTypeName};"); } } } } sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); }
/// <summary> /// Generates TypeScript definitions for types included in this model builder. Optionally restricts output to classes or enums. /// </summary> /// <param name="output">The type of definitions to generate</param> /// <returns>TypeScript definition for types included in this model builder.</returns> public string Generate(TsGeneratorOutput output) { var model = _modelBuilder.Build(); return(_scriptGenerator.Generate(model, output)); }
protected virtual void AppendEnumDefinition(TsEnum enumModel, IndentedStringBuilder sb, TsGeneratorOutput output) { var typeName = GetTypeName(enumModel); var visibility = (output & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums || (output & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants ? "export " : ""; DocAppender.AppendEnumDoc(sb, enumModel, typeName); var constSpecifier = Options.GenerateConstEnums ? "const " : string.Empty; sb.AppendLine(string.Format("{0}{2}enum {1} {{", visibility, typeName, constSpecifier)); using (sb.Indent()) { var i = 1; foreach (var v in enumModel.Values) { DocAppender.AppendEnumValueDoc(sb, v); sb.AppendLine(string.Format(i < enumModel.Values.Count ? "{0} = {1}," : "{0} = {1}", v.Name, v.Value)); i++; } } sb.AppendLine("}"); GeneratedEnums.Add(enumModel); }