/// <summary>
/// Creates a TsCollection from TsType
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private TsCollection CreateCollectionType(TsType type, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
var resolved = new TsCollection(type.Type, propertyVisibilityFormatter);
resolved.ItemsType = this.ResolveType(resolved.ItemsType, propertyVisibilityFormatter, false);
return(resolved);
}
/// <summary>
/// Initializes a new instance of the TsModelBuilder class.
/// </summary>
public TsModelBuilder()
{
this.Classes = new Dictionary <Type, TsClass>();
this.Enums = new Dictionary <Type, TsEnum>();
PropertyVisibilityFormatter = (property) => true;
}
/// <summary>
/// Resolves references in the property.
/// </summary>
/// <param name="property"></param>
public override void VisitProperty(TsProperty property, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
property.PropertyType = this.ResolveType(property.PropertyType, propertyVisibilityFormatter);
if (property.GenericArguments != null)
{
for (int i = 0; i < property.GenericArguments.Count; i++)
{
property.GenericArguments[i] = this.ResolveType(property.GenericArguments[i], propertyVisibilityFormatter);
}
}
}
/// <summary>
/// Resolves references in the class.
/// </summary>
/// <param name="classModel"></param>
public override void VisitClass(TsClass classModel, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
if (classModel.Module != null)
{
classModel.Module = this.ResolveModule(classModel.Module.Name);
}
if (classModel.BaseType != null && classModel.BaseType != TsType.Any)
{
classModel.BaseType = this.ResolveType(classModel.BaseType, propertyVisibilityFormatter, false);
}
for (int i = 0; i < classModel.Interfaces.Count; i++)
{
classModel.Interfaces[i] = this.ResolveType(classModel.Interfaces[i], propertyVisibilityFormatter, false);
}
}
/// <summary>
/// Resolves TsType to the more specialized type.
/// </summary>
/// <param name="toResolve">The type to resolve.</param>
/// <returns></returns>
private TsType ResolveType(TsType toResolve, TsPropertyVisibilityFormatter propertyVisibilityFormatter, bool useOpenGenericDefinition = true)
{
if (!(toResolve is TsType))
{
return(toResolve);
}
if (_knownTypes.ContainsKey(toResolve.Type))
{
return(_knownTypes[toResolve.Type]);
}
else if (toResolve.Type.IsGenericType && useOpenGenericDefinition)
{
// We stored its open type definition instead
TsType openType = null;
if (_knownTypes.TryGetValue(toResolve.Type.GetGenericTypeDefinition(), out openType))
{
return(openType);
}
}
else if (toResolve.Type.IsGenericType)
{
var genericType = TsType.Create(toResolve.Type, propertyVisibilityFormatter);
_knownTypes[toResolve.Type] = genericType;
return(genericType);
}
var typeFamily = TsType.GetTypeFamily(toResolve.Type);
TsType type = null;
switch (typeFamily)
{
case TsTypeFamily.System: type = new TsSystemType(toResolve.Type); break;
case TsTypeFamily.Collection: type = this.CreateCollectionType(toResolve, propertyVisibilityFormatter); break;
case TsTypeFamily.Enum: type = new TsEnum(toResolve.Type); break;
default: type = TsType.Any; break;
}
_knownTypes[toResolve.Type] = type;
return(type);
}
/// <summary>
/// Initializes a new instance of the TsCollection class with the specific CLR type.
/// </summary>
/// <param name="type">The CLR collection represented by this instance of the TsCollection.</param>
public TsCollection(Type type, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
: base(type)
{
var enumerableType = TsType.GetEnumerableType(this.Type);
if (enumerableType != null)
{
this.ItemsType = TsType.Create(enumerableType, propertyVisibilityFormatter);
}
else if (typeof(IEnumerable).IsAssignableFrom(this.Type))
{
this.ItemsType = TsType.Any;
}
else
{
throw new ArgumentException($"The type '{this.Type.FullName}' is not collection.");
}
this.Dimension = GetCollectionDimension(type);
}
/// <summary>
/// Factory method so that the correct TsType can be created for a given CLR type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static TsType Create(System.Type type, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
var family = GetTypeFamily(type);
switch (family)
{
case TsTypeFamily.System:
return(new TsSystemType(type));
case TsTypeFamily.Collection:
return(new TsCollection(type, propertyVisibilityFormatter));
case TsTypeFamily.Class:
return(new TsClass(type, propertyVisibilityFormatter));
case TsTypeFamily.Enum:
return(new TsEnum(type));
default:
return(new TsType(type));
}
}
/// <summary>
/// Runs specific model visitor.
/// </summary>
/// <param name="visitor">The model visitor to run.</param>
public void RunVisitor(ITsModelVisitor visitor, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
visitor.VisitModel(this);
foreach (var module in this.Modules)
{
visitor.VisitModule(module);
}
foreach (var classModel in this.Classes)
{
visitor.VisitClass(classModel, propertyVisibilityFormatter);
foreach (var property in classModel.Properties.Union(classModel.Fields).Union(classModel.Constants))
{
visitor.VisitProperty(property, propertyVisibilityFormatter);
}
}
foreach (var enumModel in this.Enums)
{
visitor.VisitEnum(enumModel);
}
}
/// <summary>
/// Initializes a new instance of the TsClass class with the specific CLR type.
/// </summary>
/// <param name="type">The CLR type represented by this instance of the TsClass</param>
/// <param name="propertyVisibilityFormatter"></param>
public TsClass(Type type, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
: base(type)
{
this.Properties = this.Type
.GetProperties()
.Where(pi => pi.DeclaringType == this.Type)
.Select(pi => new TsProperty(pi))
.Where(tp => propertyVisibilityFormatter(tp))
.ToList();
this.Fields = this.Type
.GetFields()
.Where(fi => fi.DeclaringType == this.Type &&
!(fi.IsLiteral && !fi.IsInitOnly)) // skip constants
.Select(fi => new TsProperty(fi))
.Where(tp => propertyVisibilityFormatter(tp))
.ToList();
this.Constants = this.Type
.GetFields()
.Where(fi => fi.DeclaringType == this.Type &&
fi.IsLiteral && !fi.IsInitOnly) // constants only
.Select(fi => new TsProperty(fi))
.Where(tp => propertyVisibilityFormatter(tp))
.ToList();
if (type.IsGenericType)
{
this.Name = type.Name.Remove(type.Name.IndexOf('`'));
this.GenericArguments = type
.GetGenericArguments()
.Select(ty => TsType.Create(ty, propertyVisibilityFormatter))
.ToList();
}
else
{
this.Name = type.Name;
this.GenericArguments = new TsType[0];
}
if (this.Type.BaseType != null && this.Type.BaseType != typeof(object) && this.Type.BaseType != typeof(ValueType))
{
this.BaseType = new TsType(this.Type.BaseType);
}
var interfaces = this.Type.GetInterfaces();
this.Interfaces = interfaces
.Where(@interface => @interface.GetCustomAttribute <TsInterfaceAttribute>(false) != null)
.Except(interfaces.SelectMany(@interface => @interface.GetInterfaces()))
.Select(ty => TsType.Create(ty, propertyVisibilityFormatter)).ToList();
var attribute = this.Type.GetCustomAttribute <TsClassAttribute>(false);
if (attribute != null)
{
if (!string.IsNullOrEmpty(attribute.Name))
{
this.Name = attribute.Name;
}
if (attribute.Module != null)
{
this.Module.Name = attribute.Module;
}
}
var ignoreAttribute = this.Type.GetCustomAttribute <TsIgnoreAttribute>(false);
if (ignoreAttribute != null)
{
this.IsIgnored = true;
}
}
public TypeScriptFluent WithPropertyVisibilityFormatter(TsPropertyVisibilityFormatter formatter)
{
_modelBuilder.PropertyVisibilityFormatter = formatter;
return(this);
}
/// <summary>
/// When overridden in a derived class, it can examine or modify the property model.
/// </summary>
/// <param name="property">The model property being visited.</param>
public virtual void VisitProperty(TsProperty property, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
}
/// <summary>
/// When overridden in a derived class, it can examine or modify the class model.
/// </summary>
/// <param name="classModel">The model class being visited.</param>
public virtual void VisitClass(TsClass classModel, TsPropertyVisibilityFormatter propertyVisibilityFormatter)
{
}
