private bool GenerateType(TypeScriptType type, TextWriter output) {
if (type.IsArray) {
return GenerateArray(type as TypeScriptArray, output);
}
else if (type.IsClass) {
return GenerateClass(type as TypeScriptClass, output);
}
else if (type.IsEnum) {
return GenerateEnum(type as TypeScriptEnum, output);
}
else if (type.IsField) {
return GenerateField(type as TypeScriptField, output);
}
else if (type.IsInterface) {
return GenerateInterface(type as TypeScriptInterface, output);
}
else if (type.IsMethod) {
return GenerateMethod(type as TypeScriptMethod, output);
}
else if (type.IsPrimitive) {
return GeneratePrimitive(type as TypeScriptPrimitive, output);
}
else if (type.IsProperty) {
return GenerateProperty(type as TypeScriptProperty, output);
}
throw new Exception($"failed to generate source for type: {type.Name}");
}
/*
class Greeter {
greeting: string;
}
*/
private bool GenerateClass(TypeScriptClass tsClass, TextWriter output) {
if (GenerateImports(tsClass, output) == false) {
return false;
}
output.Write($"export interface {tsClass.Name} ");
// Don't extend object, no need.
if (tsClass.BaseType != null && tsClass.BaseType.Name != "Object") {
output.Write($"extends {tsClass.BaseType.Name} ");
}
if (tsClass.ImplementedInterfaces.Count > 0) {
output.Write("implements ");
for (int i = 0; i < tsClass.ImplementedInterfaces.Count; i++) {
TypeScriptType tsType = tsClass.ImplementedInterfaces[i];
output.Write($"{tsType.Name}");
if (i + 1 < tsClass.ImplementedInterfaces.Count) {
output.Write(',');
}
}
}
output.WriteLine('{');
foreach (TypeScriptProperty prop in tsClass.Properties) {
// Indent
output.Write(" ");
GenerateProperty(prop, output);
}
output.WriteLine("}");
return true;
}
public TypeScriptField ConvertField(FieldInfo fieldInfo) {
object value = fieldInfo.GetRawConstantValue();
TypeScriptType tsType = null;
return new TypeScriptField(fieldInfo.Name, value, tsType);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool Convert() {
foreach (Type type in InputTypes) {
TypeScriptType tsType = ConvertType(type);
MappedTypes.Add(tsType);
}
return true;
}
public ControllerToTypeScript(TypeScriptType type, bool strictNullCheck)
: base(type, strictNullCheck)
{
if (!type.Type.IsWebController())
{
throw new ArgumentOutOfRangeException($"Type {type.Name} MUST extends System.Web.Mvc.Controller or System.Web.Http.IHttpControler", nameof(type));
}
}
public StructToTypeScript(TypeScriptType type, bool strictNullCheck)
: base(type, strictNullCheck)
{
if (!this.Type.Type.IsValueType)
{
throw new ArgumentException($"{this.Type.Name} is not a Struct.", nameof(type));
}
}
public TypeScriptOrNullType(TypeScriptType innerType)
: base(new[]
{
new TypeScriptBuildInType("null"),
innerType
})
{
InnerType = innerType;
}
public void TypeScriptType(Type type, string result, bool checkOptional = false)
{
var tst = new TypeScriptType(type, _ctxClean);
Assert.AreEqual(result, tst.Type);
if (checkOptional)
{
Assert.IsTrue(tst.NameMods.EndsWith("?"));
}
}
private TypeScriptType MaybeNull(ITypeInfo trueType, TypeScriptType type, IAttributeProvider?attributeProvider, int index)
{
if (options.NullabilityMode != NullabilityMode.NullableReference)
{
return(type);
}
var isNullable = TypeScriptGeneratorHelpers.NullableReferenceCanBeNull(attributeProvider, trueType, index);
return(TypeScriptGeneratorHelpers.BuildTargetNullableTypeByOptions(type, isNullable, options));
}
public EnumToTypeScript(TypeScriptType type, bool strictNullCheck)
: base(type, strictNullCheck)
{
if (!this.Type.Type.IsEnum)
{
throw new ArgumentException($"{this.Type.Name} is not an System.Enum.", nameof(type));
}
var underlyingType = Enum.GetUnderlyingType(this.Type.Type);
if (underlyingType != typeof(int))
{
throw new NotSupportedException($"Unsupported underlying type for enums in typescript [{underlyingType}]. Only ints are supported.");
}
}
public static TypeScriptMethod ChangeCaseCopy(
OutputSettings outputSettings,
TypeContext typeContext,
string baseName,
TypeScriptType containingType,
string otherTypeLiteral,
bool toContainingType,
bool toCamelCase)
{
TypeReference otherType = typeContext.GetLiteralReference(otherTypeLiteral);
TypeScriptMethod result = new TypeScriptMethod();
result.Name = baseName + containingType.SourceType.UnqualifiedSimpleName;
result.Appender = new CopyMethod.OutputAppender(
outputSettings,
typeContext,
containingType,
new CaseChangeCopySettings(
toContainingType,
toCamelCase),
toContainingType);
if (toContainingType)
{
result.Arguments = new List <TypeScriptMember>()
{
new TypeScriptMember()
{
Name = "source",
Type = otherType
}
};
result.Type = containingType;
}
else
{
result.Arguments = new List <TypeScriptMember>()
{
new TypeScriptMember()
{
Name = "target",
Type = otherType
}
};
result.Type = otherType;
}
return(result);
}
public OutputAppender(
OutputSettings settings,
TypeContext typeContext,
TypeScriptType containingType,
ICopySettings copySettings,
bool toContainingType)
: base(
settings,
typeContext,
hasBody: true)
{
this.containingType = containingType;
this.CopySettings = copySettings;
this.ToContainingType = toContainingType;
}
public static TypeScriptType BuildTargetNullableTypeByOptions(TypeScriptType innerType, bool isNullable, TypeScriptGenerationOptions options)
{
if (!(innerType is INullabilityWrapperType) && isNullable && options.EnableExplicitNullability)
{
if (!options.UseGlobalNullable)
{
return(new TypeScriptOrNullType(innerType));
}
if (options.UseGlobalNullable)
{
return(new TypeScriptNullableType(innerType));
}
}
return(innerType);
}
private void BeginGenerateType(TypeScriptType type) {
string path = $"{OutputDir}/{type.Name}.ts";
// Remove any old generated files.
// TODO: Just change the file mode lol.
if (File.Exists(path)) {
File.Delete(path);
}
TextWriter output = new StreamWriter(File.OpenWrite(path));
Console.WriteLine($"generating source for type: {type.Name} {type.GetType().GUID}");
Console.WriteLine($"path: {path}\n");
GenerateType(type, output);
output.Flush();
output.Close();
}
public static ToTypeScript Build(TypeScriptType type, bool strictNullCheck)
{
if (type.Type.IsWebController())
{
return new ControllerToTypeScript(type, strictNullCheck);
}
else if (type.Type.IsEnum)
{
return new EnumToTypeScript(type, strictNullCheck);
}
else if (type.Type.IsValueType)
{
return new StructToTypeScript(type, strictNullCheck);
}
else
{
return new ModelToTypeScript(type, strictNullCheck);
}
}
public TypeScriptTypeMemberDeclaration ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, ITypeInfo type, IPropertyInfo property)
{
TypeScriptType tsType = typeGenerator.BuildAndImportType(unit, property.PropertyType);
if (property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition().GetInterfaces().Any(x => x.Name == nameof(IEnumerable)))
{
var elementType = property.PropertyType.GetGenericArguments()[0];
var itemType = typeGenerator.BuildAndImportType(unit, elementType);
tsType = new TypeScriptArrayType(itemType);
}
else
{
tsType = typeGenerator.BuildAndImportType(unit, property.PropertyType);
}
var result = new TypeScriptTypeMemberDeclaration
{
Name = property.Name,
Type = tsType,
Optional = true
};
return(result);
}
public bool IsPredefined(Type input, out TypeScriptType typeScriptType) => _mappings.TryGetValue(input, out typeScriptType);
public static TypeScriptType Generic(TypeScriptType typeScriptType, params TypeScriptType[] genericArguments) => new GenericTypeScriptType(typeScriptType, genericArguments);
public void Run(Type type, TypeScriptType expected)
{
var item = new ConvertTypeToTypeScriptType().Convert(type);
Assert.Equal(JsonConvert.SerializeObject(expected), JsonConvert.SerializeObject(item));
}
public TypeScriptCastExpression(TypeScriptExpression expression, TypeScriptType targetType)
{
Expression = expression;
TargetType = targetType;
}
public TypeScriptEnumValueType(TypeScriptType enumType, string value)
{
this.enumType = enumType;
this.value = value;
}
public TypeScriptPromiseOfType(TypeScriptType targetType)
{
TargetType = targetType;
}
public void TypeToTypeScriptType(Type type, TypeScriptType expected)
{
new LocalContext(new ConvertConfiguration(), null, type).GetTypeScriptType(type).Should().Be(expected);
}
public void TypeScriptTypeToTypeScriptTests(TypeScriptType typeScriptType, string expected)
{
typeScriptType.ToTypeScriptType().Should().Be(expected);
}
public static TypeScriptType Array(TypeScriptType typeScriptType) => new ArrayTypeScriptType(typeScriptType);
public TypeScriptTypeSpreadMemberDeclaration(TypeScriptType type)
{
Type = type;
}
private TypeScriptType ConvertType(Type type) {
if (type == null) return null;
// ERROR: Hospital class contains fields of type Hospital
// Self referencing classes cause a stack overflow from infinite recursion.
Console.WriteLine($"converting type {type.FullName} {type.GUID}");
// We don't want to convert types more than once so we map the converted ones
// to their GUID
if (type_map.ContainsKey(type.GUID)) {
return type_map[type.GUID];
}
TypeScriptType result = null;
// Some weird edge cases
{
// Technically not 'Primitives' but in TypeScript we are limited to very
// few basic primatives
switch (type.Name) {
case "Decimal":
case "String":
case "DateTime":
result = ConvertPrimitive(type);
break;
}
// The collection interface has weird name.
// There's a bette way to handle this i'm sure.
if (type.Name.StartsWith("ICollection")) {
result = ConvertICollection(type);
}
// Nullable types in dotnet are wrapped in a 'System.Nullable' type
if (type.FullName.StartsWith("System.Nullable")) {
result = ConvertNullableProperty(type);
}
}
// This following only executes as long as there is no
// result set from the previous edge cases.
if (result == null) {
if (type.IsPrimitive) {
result = ConvertPrimitive(type);
}
else if (type.IsClass) {
result = ConvertClass(type);
}
else if (type.IsInterface) {
result = ConvertInterface(type);
}
else if (type.IsArray) {
result = ConvertArray(type);
}
else if (type.IsEnum) {
result = ConvertEnum(type);
}
}
if (result == null) {
throw new Exception($"type failed to find converter: '{type.FullName}'");
}
Console.WriteLine($"mapped type '{type.FullName} {type.GUID}'");
return result;
} // ConvertType
public TypeScriptNullableType(TypeScriptType innerType)
{
InnerType = innerType;
}
/// <summary>
/// Construct an instance
/// </summary>
/// <param name="name">The declared name of the property</param>
/// <param name="type">The type of the declared property</param>
public TypeScriptProperty(string name, TypeScriptType type) :
base(name) {
this.IsProperty = true;
this.Type = type;
}
public TypeScriptType GetTypeScriptType(Type type, bool import = true)
{
if (!Configuration.ShouldConvertType(type))
{
return(TypeScriptType.Any);
}
if (Configuration.PredefinedMapping.IsPredefined(type, out var typeResult))
{
return(typeResult);
}
var actualType = Nullable.GetUnderlyingType(type) ?? type;
if (Configuration.PredefinedMapping.IsPredefined(actualType, out var actualResult))
{
return(actualResult);
}
var dictionary = TypeHelper.GetDictionaryType(actualType);
if (dictionary != null)
{
return(TypeScriptType.Dictionary(GetTypeScriptType(dictionary.GetTypeInfo().GetGenericArguments()[0]), GetTypeScriptType(dictionary.GetTypeInfo().GetGenericArguments()[1])));
}
var enumerable = TypeHelper.GetEnumerableType(actualType);
if (enumerable != null)
{
return(TypeScriptType.Array(GetTypeScriptType(enumerable.GetTypeInfo().GetGenericArguments()[0])));
}
var taskType = TypeHelper.GetTaskType(actualType);
if (taskType != null)
{
return(GetTypeScriptType(taskType.GetTypeInfo().GetGenericArguments()[0]));
}
if (actualType.IsConstructedGenericType)
{
var typeDefinition = actualType.GetGenericTypeDefinition();
var tsTypeDefinition = GetTypeScriptType(typeDefinition);
var genericArguments = actualType.GetTypeInfo().GetGenericArguments();
return(TypeScriptType.Generic(tsTypeDefinition, genericArguments.Select(x => GetTypeScriptType(x)).ToArray()));
}
if (actualType.IsGenericParameter)
{
return(new BuiltInTypeScriptType(actualType.Name));
}
if (_type != type && !Imports.ContainsKey(actualType))
{
var typeScriptResult = _convertContext.GetTypeScriptFile(actualType);
if (import)
{
Imports.Add(actualType, typeScriptResult);
}
}
return(new BuiltInTypeScriptType(Configuration.GetTypeName(actualType)));
}
public TypeScriptInterfacePropertyMember(string name, TypeScriptType result)
{
Name = name;
Result = result;
}
public TypeScriptArrayType(TypeScriptType itemType)
{
ItemType = itemType;
}
public static TypeScriptType Dictionary(TypeScriptType key, TypeScriptType value) => new DictionaryTypeScriptType(key, value);
public ModelToTypeScript(TypeScriptType type, bool strictNullCheck)
: base(type, strictNullCheck) { }
public TypeRedirectBuildingContext([NotNull] ITypeInfo type, [NotNull] TypeScriptType typeScriptType)
: base(type)
{
this.typeScriptType = typeScriptType;
}
public ToTypeScript(TypeScriptType type, bool strictNullCheck)
{
this.Type = type.ThrowIfNull(nameof(type));
this.StrictNullCheck = strictNullCheck;
}
