private static string generateInner(IEnumerable <Type> types, TsReflectionFilters filters)
{
var cb = new TypescriptCodeBuilder();
var lastNamespace = "";
var scope = null as ScriptScope;
types = types.OrderBy(t => t.ToTsName()).OrderBy(t => t.GetTsNamespace());
foreach (var t in types)
{
// namespace
var ns = t.GetTsNamespace();
if (ns != lastNamespace)
{
scope?.Dispose();
scope = cb.EnterNameSpace(ns);
lastNamespace = ns;
}
// class
var baseTypes = t.BaseType?.ToTsName() != "any" && filters.TypeFilter(t.BaseType)
? new[] { t.BaseType.ToTsFullName() }
: null;
var interfaces = t.GetInterfaces()
.Where(i => filters.TypeFilter(i))
.Select(i => i.ToTsFullName())
.ToArray();
if (t.IsEnum)
{
GenerateEnum(t, cb);
}
else
{
using (cb.EnterClass(t.ToTsName(), baseTypes, interfaces, Ambient.export))
{
// property
foreach (var prop in t.GetProperties().Where(p => filters.PropertyFilter(t, p)))
{
cb.AppendLine($"{prop.Name} : {prop.PropertyType.ToTsFullName()};");
}
// field
foreach (var field in t.GetFields().Where(f => filters.FieldFilter(t, f)))
{
cb.AppendLine($"{field.Name} : {field.FieldType.ToTsFullName()};");
}
}
}
}
scope?.Dispose();
return(cb.ToString());
}
public static string GenerateDefinition(Type type, bool listup = false, TsReflectionFilters filters = null)
{
if (type == null)
{
throw new ArgumentNullException("type must be not null.");
}
if (filters == null)
{
filters = TsReflectionFilters.DefaultFilters;
}
var types = new List <Type> {
type
};
if (listup)
{
types = type.ListUpDependeceTypes(filters);
}
return(generateInner(types, filters));
}
public static List <Type> ListUpDependeceTypes(Type[] types, TsReflectionFilters filters = null)
{
if (types == null)
{
throw new ArgumentNullException("types must be not null.");
}
if (types.Length < 1)
{
throw new ArgumentOutOfRangeException("types.Length must be > 0.");
}
var typeList = new List <Type>();
var stack = new List <Type>();
stack.AddRange(types);
var index = 0;
if (filters == null)
{
filters = TsReflectionFilters.DefaultFilters;
}
while (stack.Count > index)
{
var target = stack[index];
index++;
if (typeList.Contains(target))
{
continue;
}
if (typeList.Any(t => t.ToTsFullName() == target.ToTsFullName()))
{
continue;
}
if (target.IsNotPublic)
{
continue;
}
if (target.IsTsBuiltinType())
{
continue;
}
if (target.IsGenericParameter)
{
continue;
}
if (target.IsEnum)
{
if (!stack.Contains(target.BaseType))
{
stack.Add(target.BaseType);
}
if (filters.EnumFilter(target))
{
typeList.Add(target);
}
continue;
}
if (target.IsArray)
{
if (!stack.Contains(target.GetElementType()))
{
stack.Add(target.GetElementType());
}
continue;
}
if (target.IsTsCollection() || target.IsTsDictionary())
{
if (target.IsGenericType)
{
foreach (var t in target.GenericTypeArguments)
{
if (!stack.Contains(t))
{
stack.Add(t);
}
}
}
continue;
}
if (target.BaseType != null)
{
if (!stack.Contains(target.BaseType))
{
stack.Add(target.BaseType);
}
}
var interfaces = target.GetInterfaces();
foreach (var i in interfaces)
{
if (!stack.Contains(i))
{
stack.Add(i);
}
}
var properties = target.GetProperties();
foreach (var p in properties)
{
if (filters.PropertyFilter(target, p))
{
if (!stack.Contains(p.PropertyType))
{
stack.Add(p.PropertyType);
}
}
}
var fields = target.GetFields();
foreach (var f in fields)
{
if (filters.FieldFilter(target, f))
{
if (!stack.Contains(f.FieldType))
{
stack.Add(f.FieldType);
}
}
}
var methods = target.GetMethods();
foreach (var m in methods)
{
if (filters.MethodFilter(target, m))
{
if (!stack.Contains(m.ReturnType))
{
stack.Add(m.ReturnType);
}
foreach (var p in m.GetParameters())
{
if (!stack.Contains(p.ParameterType))
{
stack.Add(p.ParameterType);
}
}
}
}
if (target.IsGenericType)
{
foreach (var t in target.GenericTypeArguments)
{
if (!stack.Contains(t))
{
stack.Add(t);
}
}
var gt = target.GetGenericTypeDefinition();
if (gt != null && gt != target)
{
if (!stack.Contains(gt))
{
stack.Add(gt);
}
continue;
}
}
if (filters.TypeFilter(target))
{
typeList.Add(target);
}
}
return(typeList);
}
public static string GenerateDefinition(IEnumerable <Type> types, bool listup = false, TsReflectionFilters filters = null)
{
if (!(types?.Count() > 0))
{
throw new ArgumentNullException("types count must > 0.");
}
if (filters == null)
{
filters = TsReflectionFilters.DefaultFilters;
}
if (listup)
{
var listupTypes = new List <Type>();
foreach (var t in types)
{
listupTypes.AddRange(t.ListUpDependeceTypes(filters));
}
return(generateInner(listupTypes.Distinct(), filters));
}
else
{
return(generateInner(types.Distinct(), filters));
}
}
public static List <Type> ListUpDependeceTypes(this Type type, TsReflectionFilters filters = null)
=> ListUpDependeceTypes(new[] { type }, filters);
