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));
}
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 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));
}
private bool CanItemBeNull(IAttributeProvider?attributeProvider)
{
if (elementType.IsValueType || elementType.IsEnum || attributeProvider == null)
{
return(false);
}
if (options.NullabilityMode == NullabilityMode.NullableReference)
{
return(TypeScriptGeneratorHelpers.NullableReferenceCanBeNull(attributeProvider, elementType, 1));
}
return(options.NullabilityMode == NullabilityMode.Pessimistic
? !attributeProvider.IsNameDefined(AnnotationsNames.ItemNotNull)
: attributeProvider.IsNameDefined(AnnotationsNames.ItemCanBeNull));
}
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),
});
}
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 TypeScriptType GetValueType(TypeScriptUnit targetUnit, ITypeGenerator typeGenerator, IAttributeProvider?attributeProvider)
{
var value = typeGenerator.ResolveType(valueType).ReferenceFrom(targetUnit, typeGenerator, null);
return(MaybeNull(valueType, value, attributeProvider, 1 + TypeScriptGeneratorHelpers.GetGenericArgumentsToSkip(keyType)));
}
