public void ShouldRenameTypes()
{
var options = new TypeScriptOptions {
// convert to camel case
MemberRenamer = source => source.Name.Substring(0, 1).ToLower() + source.Name.Substring(1)
};
var gen = Generator.GenerateTypeScript(typeof(Company <>), options);
var address = GetGeneratedType(gen, "export class Address");
Assert.NotEmpty(address);
Assert.Contains("companyId: number", address);
Assert.Contains("city: string", address);
Assert.Contains("detail: string", address);
Assert.Contains("postalCode: number", address);
var company = GetGeneratedType(gen, "export class Company");
Assert.NotEmpty(company);
Assert.Contains("income: number", gen);
Assert.Contains("addresses: Array<TAddress>", company);
Assert.Contains("addressesArray: Array<TAddress>", company);
Assert.Contains("extends BaseEntity<number>", company);
var constraints = Regex.Match(company, "<.*?>").Value;
Assert.Contains("Address", constraints);
Assert.Contains("TAddress extends Address", constraints);
}
/// <summary>
/// Generate the typescript
/// </summary>
/// <param name="types">Types to transform</param>
/// <param name="fileName">File name</param>
public void GenerateTypeScriptModels([NotNull] IEnumerable <Type> types, string fileName = "")
{
//Get file name
var file = fileName == null?this.GetGeneratedFileInfo() : new FileInfo(fileName);
if (file == null)
{
throw new FileNotFoundException("The specified file name is invalid");
}
//Generate typescript
var options = new TypeScriptOptions()
{
UseDateForDateTime = true,
UseInterfaceForClasses = (type) => false
};
var generatedTypeScript = CsToTs.Generator.GenerateTypeScript(options, types);
//Write file
if (file?.Directory != null && !file.Directory.Exists)
{
file.Directory.Create();
}
File.WriteAllText(file.FullName, generatedTypeScript, Encoding.UTF8);
}
private static string GetPrimitiveMemberType(TypeCode typeCode, TypeScriptOptions options)
{
switch (typeCode)
{
case TypeCode.Boolean:
return("boolean");
case TypeCode.Byte:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.Single:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
return("number");
case TypeCode.Char:
case TypeCode.String:
return("string");
case TypeCode.DateTime:
return(options.UseDateForDateTime ? "Date" : "string");
default:
return("any");
}
}
public void ShouldGenerateDateForDateTimes()
{
var options = new TypeScriptOptions {
UseDateForDateTime = true
};
var gen = Generator.GenerateTypeScript(typeof(Company <>), options);
var company = GetGeneratedType(gen, "export class Company");
Assert.NotEmpty(company);
Assert.Contains("CreateDate: Date", gen);
}
public void ShouldExtendDefaultBase()
{
var options = new TypeScriptOptions {
DefaultBaseType = (_) => "Entity"
};
var gen = Generator.GenerateTypeScript(typeof(BaseEntity <>), options);
var baseEntity = GetGeneratedType(gen, "export abstract class BaseEntity");
Assert.NotEmpty(baseEntity);
Assert.Contains("extends Entity", gen);
}
internal static string GenerateTypeScript(IEnumerable <Type> types, TypeScriptOptions options)
{
var context = new TypeScriptContext(options);
GetTypeScriptDefinitions(types, context);
Handlebars.Configuration.TextEncoder = SimpleEncoder.Instance;
var generator = Handlebars.Compile(Template);
return(generator(context));
}
public void ShouldImplementDefaultBase()
{
var options = new TypeScriptOptions {
UseInterfaceForClasses = _ => true,
DefaultBaseType = _ => "Entity"
};
var gen = Generator.GenerateTypeScript(typeof(BaseEntity <>), options);
var baseEntity = GetGeneratedType(gen, "export interface BaseEntity");
Assert.NotEmpty(baseEntity);
Assert.Contains("extends Entity, IBase<TKey>", gen);
}
public void ShouldRenameMembers()
{
var options = new TypeScriptOptions {
TypeRenamer = t => t == "BaseEntity" ? "EntityBase" : t
};
var gen = Generator.GenerateTypeScript(typeof(Company <>), options);
var baseEntity = GetGeneratedType(gen, "export abstract class EntityBase");
Assert.NotEmpty(baseEntity);
Assert.DoesNotContain("BaseEntity", gen);
}
public void ShouldGenerateDecorators()
{
var options = new TypeScriptOptions {
UseDecorators = _ => new string[] { "@foo()" }
};
var gen = Generator.GenerateTypeScript(typeof(Company <Address>), options);
var company = GetGeneratedType(gen, "export class Company");
Assert.NotEmpty(company);
Assert.Contains("@foo(", company);
}
public void ShouldGenerateStringsForEnumsWhenConfigured()
{
TypeScriptOptions options = new TypeScriptOptions
{
UseStringsForEnums = true
};
var gen = Generator.GenerateTypeScript(options, typeof(EntityWithEnum));
var typeEnum = GetGeneratedType(gen, "export enum TypeEnum");
Assert.NotEmpty(typeEnum);
Assert.Contains("Type1 = \"Type1\"", typeEnum);
Assert.Contains("Type2 = \"Type2\"", typeEnum);
}
public void ShouldGenerateMembersWithCamelCaseWhenConfigured()
{
TypeScriptOptions options = new TypeScriptOptions
{
MemberRenamer = info => new Regex("^.").Replace(info.Name, match => match.Value.ToLowerInvariant())
};
var gen = Generator.GenerateTypeScript(options, typeof(Address));
var address = GetGeneratedType(gen, "export class Address");
Assert.NotEmpty(address);
Assert.Contains("companyId: number", address);
Assert.Contains("city: string", address);
Assert.Contains("detail: string", address);
Assert.Contains("postalCode: number", address);
Assert.Contains("overseas?: boolean", address);
Assert.Contains("poBox?: number", address);
}
public void ShouldGenerateInterfaceForClasses()
{
var options = new TypeScriptOptions {
UseInterfaceForClasses = _ => true
};
var gen = Generator.GenerateTypeScript(typeof(Company <>), options);
Assert.Equal(5, Regex.Matches(gen, "export interface").Count);
var baseEntity = GetGeneratedType(gen, "export interface BaseEntity");
Assert.NotEmpty(baseEntity);
Assert.Contains("extends IBase<TKey>", gen);
var company = GetGeneratedType(gen, "export interface Company");
Assert.NotEmpty(company);
Assert.Contains("extends BaseEntity<number>", gen);
}
public void ShouldGenerateMethods()
{
var options = new TypeScriptOptions {
ShouldGenerateMethod = (m, md) => {
md.Parameters.Add(new TypeScript.MemberDefinition("options", "AjaxOptions", false, Enumerable.Empty <string>()));
md.Lines.Add($"return window.ajax('{m.Name}')");
return(true);
}
};
var gen = Generator.GenerateTypeScript(typeof(TestApi <Company <Address> >), options);
var testApi = GetGeneratedType(gen, "export class TestApi");
Assert.NotEmpty(testApi);
Assert.Contains("Get(options: AjaxOptions)", testApi);
Assert.Contains("return window.ajax('Get')", testApi);
Assert.Contains("Query<TItem>(", testApi);
Assert.Equal(4, Regex.Matches(testApi, "(options: AjaxOptions)").Count);
}
public void ShouldGenerateCtor()
{
var options = new TypeScriptOptions {
CtorGenerator = m => {
var parameters = "typeName: string";
var lines = new[] {
"super(typeName);"
};
return(new TypeScript.CtorDefinition(lines, parameters));
}
};
var gen = Generator.GenerateTypeScript(typeof(TestApi <Company <Address> >), options);
var testApi = GetGeneratedType(gen, "export class TestApi");
Assert.NotEmpty(testApi);
Assert.Contains("constructor(typeName: string)", testApi);
Assert.Contains("super(typeName);", testApi);
}
public static void Render_TypeScript_StackinoUno(this Package package, TypeScriptOptions options)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var generator = new TypeScriptCodeGenerator();
generator.TypeHandlers.Insert(0, new StackinoUnoTypeHandler());
generator.FragmentRenderers.Add(new EnumRenderer());
generator.FragmentRenderers.Add(new ObjectRenderer());
generator.FragmentRenderers.Add(new ServiceRenderer());
generator.Generate(package, options);
}
public TypeScriptContext(TypeScriptOptions options)
{
Types = new List <TypeDefinition>();
Enums = new List <EnumDefinition>();
Options = options ?? TypeScriptOptions.Default;
}
private static bool SkipCheck(string s, TypeScriptOptions o) => s != null && o.SkipTypePatterns.Any(p => Regex.Match(s, p).Success);
public TypeScriptCompilerArguments(TypeScriptOptions options)
{
this.options = options;
}
public TypeScriptCompiler(TypeScriptOptions options)
{
commandLineArguments = new TypeScriptCompilerArguments(options);
}
public TypeScriptWriter(string serviceHelpersModule = "folke-service-helpers", string validationModule = "folke-ko-validation", TypeScriptOptions options = 0)
{
this.serviceHelpersModule = serviceHelpersModule;
this.validationModule = validationModule;
this.options = options;
}
public static void CreateTypeScriptServices(this ApplicationPartManager applicationPartManager, string typeScriptPath, TypeScriptOptions options)
{
ControllerFeature feature = new ControllerFeature();
applicationPartManager.PopulateFeature(feature);
var controllerTypes = feature.Controllers.Select(c => c.AsType());
var converter = new Converter();
var assembly = converter.ReadControllers(controllerTypes);
var typeScript = new TypeScriptWriter(options: options);
typeScript.WriteAssembly(assembly);
typeScript.WriteToFiles(typeScriptPath);
}
