public static Type[] GetTypeDependencies(Type type, IReflectiveWriterOptions options)
{
// Don't reflect dependencies on statically mapped types
if (options.TypeConverter.HasStaticMapping(type))
{
return(Type.EmptyTypes);
}
var propertyDependencies = type
.GetProperties(options.PropertyFlags)
.Select(p => p.PropertyType)
.Distinct()
.ToArray();
var fieldDependencies = type
.GetFields(options.FieldFlags)
.Select(f => f.FieldType)
.Distinct()
.ToArray();
var methodDependencies = options.ReflectMethods(type)
? type
.GetMethods(options.MethodFlags)
.Where(m => !m.IsSpecialName)
.Where(m => options.ReflectMethod(type, m))
.SelectMany(m => m.GetParameters().Select(p => p.ParameterType).Union(new[] { m.ReturnType }))
.Where(m => m != typeof(void))
.ToArray()
: Array.Empty <Type>();
return(propertyDependencies
.Union(fieldDependencies)
.Union(methodDependencies)
.ToArray());
}
public static void Configure(IReflectiveWriterOptions options)
{
options.GetTypeDependenciesStrategy = options.GetTypeDependenciesStrategy.ExtendStrategy(original =>
(type, o) =>
{
var uta = type.GetCustomAttribute <UnionTypeAttribute>();
return(Enumerable.Union(original(type, o), uta?.UnionTypes ?? Array.Empty <Type>()).ToArray());
});
options.ComplexTypeStrategy = options.ComplexTypeStrategy.ExtendStrategy(original =>
(writer, typeInfo, type) =>
{
var uta = type.GetCustomAttribute <UnionTypeAttribute>();
if (uta == null)
{
original(writer, typeInfo, type);
}
else
{
var unionTypes = String.Join(" | ", uta.UnionTypes
.Select(t => options.TypeConverter.Convert(t).FullName));
writer.WriteLine($"export type {typeInfo.TypeReference.FullName} = {unionTypes};");
}
});
options.TypeConverter.Convert = options.TypeConverter.Convert.ExtendStrategy(original =>
(type, parent, memberInfo) =>
{
if (memberInfo is PropertyInfo pi)
{
var constAttr = pi.GetCustomAttribute <AsConstAttribute>();
if (constAttr != null)
{
string literalType;
var value = constAttr.ConstValue;
if (value is Boolean b)
{
literalType = b ? "true" : "false";
}
else if (value is String s)
{
literalType = $"'{s}'";
}
else if (value is Enum e)
{
var enumTypeName = options.TypeConverter.TypeName(e.GetType());
var enumMemberName = options.TypeConverter.EnumName(e.ToString());
literalType = $"{enumTypeName}.{enumMemberName}";
}
else
{
literalType = value.ToString() ?? string.Empty;
}
return(new TypeReference(literalType)
{
ExistingType = true
});
}
}
return(original(type, parent, memberInfo));
});
}
public ReflectiveWriter(IReflectiveWriterOptions?options = null)
{
_options = options ?? new ReflectiveWriterOptions();
}
public static void ConfigureMobxWriter(IReflectiveWriterOptions options) => ConfigureMobxWriter(new MobxOptions())(options);
