protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var elementType = type.GetGenericArguments()[0];
var itemType = typeGenerator.BuildAndImportType(targetUnit, elementType);
return(new TypeScriptArrayType(itemType));
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var genericArgs = type.GetGenericArguments();
var keyType = typeGenerator.BuildAndImportType(targetUnit, genericArgs[0]);
var valueType = typeGenerator.BuildAndImportType(targetUnit, genericArgs[1]);
if (typeGenerator.Options.NullabilityMode != NullabilityMode.NullableReference)
{
keyType = keyType.NotNull();
valueType = valueType.NotNull();
}
return(new TypeScriptTypeDefintion
{
Members =
{
new TypeScriptTypePropertyGetterDeclaration
{
Argument = new TypeScriptArgumentDeclaration
{
Name = "key",
Type = keyType,
},
ResultType = valueType,
Optional = true,
}
}
});
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var itemType = type.IsGenericType ? type.GetGenericArguments()[0] : TypeInfo.From(typeof(void));
var itemTypeScriptType = typeGenerator.BuildAndImportType(targetUnit, itemType);
return(new TypeScriptPromiseOfType(itemTypeScriptType));
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider)
{
var itemType = typeGenerator.ResolveType(elementType).ReferenceFrom(targetUnit, typeGenerator, null);
var resultType = TypeScriptGeneratorHelpers.BuildTargetNullableTypeByOptions(itemType, CanItemBeNull(attributeProvider), options);
return(new TypeScriptArrayType(resultType));
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
if (builtinTypes.TryGetValue(type, out var typeScriptType))
{
return(new TypeScriptBuildInType(typeScriptType));
}
throw new ArgumentOutOfRangeException(nameof(type), $"Type '{type}' is not found");
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider)
{
if (builtinTypes.ContainsKey(type))
{
return(new TypeScriptBuildInType(builtinTypes[type]));
}
throw new ArgumentOutOfRangeException();
}
public string GetReferenceFromUnitToAnother(TypeScriptUnit currentUnit, TypeScriptUnit targetUnit)
{
var path1 = new Uri(@"C:\a\a\a\a\a\a\a\a\" + currentUnit.Path);
var path2 = new Uri(@"C:\a\a\a\a\a\a\a\a\" + targetUnit.Path);
var diff = path1.MakeRelativeUri(path2);
return("./" + diff.OriginalString);
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
return(targetUnit.AddTypeImport(type, new TypeScriptInterfaceDeclaration {
Name = typeName
}, new TypeScriptUnit {
Path = path
}));
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var itemTypeScriptType = typeGenerator.ResolveType(itemType).ReferenceFrom(targetUnit, typeGenerator);
return(useGlobalNullable
? (TypeScriptType) new TypeScriptNullableType(itemTypeScriptType)
: new TypeScriptOrNullType(itemTypeScriptType));
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
return(targetUnit.AddTypeImport(type, new TypeScriptInterfaceDeclaration {
Name = typeName
}, new TypeScriptUnit {
Path = path
}));
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
if (builtinTypes.ContainsKey(type))
{
return(new TypeScriptBuildInType(builtinTypes[type]));
}
throw new ArgumentOutOfRangeException();
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
if (type.Equals(Type))
{
return(typeScriptType);
}
throw new ArgumentException($"Expected type {Type}, but got {type}");
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var typeReference = typeGenerator.BuildAndImportType(targetUnit, type.GetGenericTypeDefinition());
return(new TypeScriptGenericTypeReference(
(TypeScriptTypeReference)typeReference,
type.GetGenericArguments().Select(x => GetArgumentType(x, typeGenerator, targetUnit)).ToArray()
));
}
public TypeScriptType ReferenceFrom(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
if (!type.Equals(Type))
{
throw new InvalidOperationException($"Expected type {Type} with different meta, but got different type: {type}");
}
return(TypeScriptGeneratorHelpers.BuildTargetNullableTypeByOptions(
ReferenceFromInternal(type, targetUnit, typeGenerator),
type.CanBeNull(typeGenerator.Options.NullabilityMode),
typeGenerator.Options));
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var typeReference = typeGenerator.ResolveType(type.GetGenericTypeDefinition()).ReferenceFrom(targetUnit, typeGenerator);
var arguments = new List <TypeScriptType>();
foreach (var argument in type.GetGenericArguments())
{
var targetType = typeGenerator.ResolveType(argument).ReferenceFrom(targetUnit, typeGenerator);
arguments.Add(targetType is INullabilityWrapperType nullabilityType ? nullabilityType.InnerType : targetType);
}
return(new TypeScriptGenericTypeReference(typeReference as TypeScriptTypeReference, arguments.ToArray()));
}
public TypeScriptUnit GetOrCreateTypeUnit(string path)
{
if (units.TryGetValue(path, out var result))
{
return(result);
}
result = new TypeScriptUnit
{
Path = path,
};
units.Add(path, result);
return(result);
}
protected override TypeScriptType ReferenceFromInternal(ITypeInfo type, TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var itemTypeScriptType = typeGenerator.BuildAndImportType(targetUnit, type.GetGenericArguments()[0]);
if (typeGenerator.Options.NullabilityMode == NullabilityMode.None)
{
return(itemTypeScriptType);
}
return(typeGenerator.Options.UseGlobalNullable
? (TypeScriptType) new TypeScriptNullableType(itemTypeScriptType)
: new TypeScriptOrNullType(itemTypeScriptType));
}
public TypeScriptTypeMemberDeclaration ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, Type type, PropertyInfo property)
{
if (type == typeof(EnumWithConstGetterContainingRootType) && property.PropertyType.IsEnum && !property.CanWrite)
{
return(new TypeScriptTypeMemberDeclaration
{
Name = property.Name.ToLowerCamelCase(),
Optional = false,
Type = new TypeScriptStringLiteralType(property.GetMethod.Invoke(Activator.CreateInstance(type), null).ToString()),
});
}
return(null);
}
public TypeScriptTypeMemberDeclaration?ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, ITypeInfo typeInfo, IPropertyInfo propertyInfo)
{
if (!TryGetGetOnlyEnumPropertyValue(typeInfo, propertyInfo, out var value))
{
return(null);
}
return(new TypeScriptTypeMemberDeclaration
{
Name = propertyInfo.Name.ToLowerCamelCase(),
Optional = false,
Type = GetConstEnumType(typeGenerator, unit, propertyInfo, value !),
});
private static TypeScriptType GetConstEnumType(ITypeGenerator typeGenerator, TypeScriptUnit unit, PropertyInfo property, string value)
{
switch (typeGenerator.Options.EnumGenerationMode)
{
case EnumGenerationMode.FixedStringsAndDictionary:
return(new TypeScriptStringLiteralType(value));
case EnumGenerationMode.TypeScriptEnum:
return(new TypeScriptEnumValueType(typeGenerator.BuildAndImportType(unit, property, property.PropertyType), value));
default:
throw new ArgumentOutOfRangeException();
}
}
public TypeScriptTypeMemberDeclaration ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, Type type, PropertyInfo property)
{
var(isNullable, _) = TypeScriptGeneratorHelpers.ProcessNullable(property, property.PropertyType, typeGenerator.Options.NullabilityMode);
if (!TryGetGetOnlyEnumPropertyValue(type, property, out var value))
{
return(null);
}
return(new TypeScriptTypeMemberDeclaration
{
Name = property.Name.ToLowerCamelCase(),
Optional = isNullable && typeGenerator.Options.EnableOptionalProperties,
Type = GetConstEnumType(typeGenerator, unit, property, value),
});
}
private static TypeScriptType GetMethodResult(TypeScriptUnit targetUnit, MethodInfo methodInfo,
Func <ICustomAttributeProvider, Type, TypeScriptType> buildAndImportType, bool declareErrorResultType = true)
{
var realType = methodInfo.ReturnType;
if (realType.IsGenericType && realType.GetGenericTypeDefinition() == typeof(Task <>))
{
realType = realType.GetGenericArguments()[0];
}
else if (realType == typeof(Task))
{
realType = typeof(void);
}
return(new TypeScriptPromiseOfType(buildAndImportType(methodInfo, realType)));
}
public TypeScriptTypeMemberDeclaration?ResolveProperty(TypeScriptUnit unit, ITypeGenerator typeGenerator, ITypeInfo typeInfo, IPropertyInfo propertyInfo)
{
if (!typeInfo.Equals(TypeInfo.From <EnumWithConstGetterContainingRootType>()) || !propertyInfo.PropertyType.IsEnum)
{
return(null);
}
var value = typeInfo is TypeInfo
? GetValueFromPropertyInfo(typeInfo, propertyInfo)
: GetValueFromPropertySymbol(typeInfo, propertyInfo);
if (!string.IsNullOrEmpty(value))
{
return(new TypeScriptTypeMemberDeclaration
{
Name = propertyInfo.Name.ToLowerCamelCase(),
Optional = false,
Type = new TypeScriptStringLiteralType(value !),
});
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider)
{
return(new TypeScriptTypeDefintion
{
Members =
{
new TypeScriptTypePropertyGetterDeclaration
{
Argument = new TypeScriptArgumentDeclaration
{
Name = "key",
Type = GetKeyType(targetUnit, typeGenerator, attributeProvider),
},
ResultType = GetValueType(targetUnit, typeGenerator, attributeProvider),
Optional = true,
}
}
});
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator)
{
var keyTypeScriptType = typeGenerator.ResolveType(keyType).ReferenceFrom(targetUnit, typeGenerator);
var valueTypeScriptType = typeGenerator.ResolveType(valueType).ReferenceFrom(targetUnit, typeGenerator);
return(new TypeScriptTypeDefintion
{
Members =
{
new TypeScriptTypePropertyGetterDeclaration
{
Argument = new TypeScriptArgumentDeclaration
{
Name = "key",
Type = keyTypeScriptType,
},
ResultType = valueTypeScriptType,
Optional = true,
}
}
});
}
private TypeScriptTypeDeclaration GenerateInternalApiController(TypeScriptUnit targetUnit, Type type, Func <ICustomAttributeProvider, Type, TypeScriptType> buildAndImportType)
{
var baseApi = GetApiBase(type);
var apiName = GetApiName(type);
var interfaceName = "I" + apiName;
var methodInfos = GetMethodsToImplement(type);
var definition = new TypeScriptInterfaceDefinition();
definition.Members.AddRange(methodInfos
.SelectMany(x => BuildApiInterfaceMember(x, buildAndImportType, type)));
targetUnit.AddSymbolImport(baseApi.Name, baseApi.Location);
var interfaceDeclaration = new TypeScriptInterfaceDeclaration
{
Name = interfaceName,
Definition = definition
};
var typeScriptClassDefinition = new TypeScriptClassDefinition
{
BaseClass = new TypeScriptTypeReference(baseApi.Name),
ImplementedInterfaces = new TypeScriptType[] { new TypeScriptTypeReference(interfaceName) },
};
typeScriptClassDefinition.Members.AddRange(
methodInfos
.SelectMany(x => BuildApiImplMember(x, buildAndImportType, type)));
targetUnit.Body.Add(new TypeScriptExportStatement
{
Declaration = new TypeScriptClassDeclaration
{
Name = GetApiClassName(apiName),
Defintion = typeScriptClassDefinition
}
});
return(interfaceDeclaration);
}
public TypeScriptType ReferenceFrom(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider)
{
var typeReference = typeGenerator.ResolveType(type.GetGenericTypeDefinition()).ReferenceFrom(targetUnit, typeGenerator, null);
var arguments = new List <TypeScriptType>();
var nullableIndex = 1;
foreach (var argument in type.GetGenericArguments())
{
var targetType = typeGenerator.ResolveType(argument).ReferenceFrom(targetUnit, typeGenerator, null);
if (options.NullabilityMode == NullabilityMode.NullableReference)
{
var isNullable = TypeScriptGeneratorHelpers.NullableReferenceCanBeNull(attributeProvider, argument, nullableIndex);
nullableIndex += TypeScriptGeneratorHelpers.GetGenericArgumentsToSkip(argument);
arguments.Add(TypeScriptGeneratorHelpers.BuildTargetNullableTypeByOptions(targetType, !argument.IsValueType && isNullable, options));
}
else
{
arguments.Add(targetType is INullabilityWrapperType nullabilityType ? nullabilityType.InnerType : targetType);
}
}
return(new TypeScriptGenericTypeReference((TypeScriptTypeReference)typeReference, arguments.ToArray()));
}
private TypeScriptTypeDeclaration GenerateInternalApiController(TypeScriptUnit targetUnit, Type type,
Func <ICustomAttributeProvider, Type, TypeScriptType> buildAndImportType)
{
var baseApiClassName = "ApiBase";
var apiName = type.Name;
var interfaceName = "I" + apiName;
var typeScriptClassDefinition = new TypeScriptClassDefinition
{
BaseClass = new TypeScriptTypeReference(baseApiClassName),
ImplementedInterfaces = new TypeScriptType[] { new TypeScriptTypeReference(interfaceName) }
};
var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(m => !m.IsSpecialName)
.Where(x => x.DeclaringType == type)
.ToArray();
typeScriptClassDefinition.Members.AddRange(methodInfos.SelectMany(x => BuildApiImplMember(targetUnit, x, buildAndImportType, type)));
targetUnit.Body.Add(new TypeScriptExportStatement
{
Declaration = new TypeScriptClassDeclaration
{
Name = apiName,
Defintion = typeScriptClassDefinition
}
});
var definition = new TypeScriptInterfaceDefinition();
definition.Members.AddRange(methodInfos.SelectMany(x => BuildApiInterfaceMember(targetUnit, x, buildAndImportType)));
targetUnit.AddDefaultSymbolImport(baseApiClassName, $"../apiBase/{baseApiClassName}");
var interfaceDeclaration = new TypeScriptInterfaceDeclaration
{
Name = interfaceName,
Definition = definition
};
return(interfaceDeclaration);
}
private IEnumerable <TypeScriptClassMemberDefinition> BuildApiImplMember(TypeScriptUnit targetUnit, MethodInfo methodInfo,
Func <ICustomAttributeProvider, Type, TypeScriptType> buildAndImportType, Type controllerType)
{
var functionDefinition = new TypeScriptFunctionDefinition
{
IsAsync = true,
Result = GetMethodResult(targetUnit, methodInfo, buildAndImportType),
Body = { CreateCall(methodInfo, controllerType) }
};
functionDefinition.Arguments.AddRange(
methodInfo.GetParameters().Where(AcceptParameter).Select(x => new TypeScriptArgumentDeclaration
{
Name = x.Name,
Type = buildAndImportType(x, x.ParameterType)
})
);
yield return(new TypeScriptClassMemberDefinition
{
Name = methodInfo.Name.ToLowerCamelCase(),
Definition = functionDefinition
});
}
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);
}
