public string Expand()
{
var accessModifier = (bool)_typeDeclaration.UserData["AddExportKeyword"] ? GetAccessModifier(_typeDeclaration.TypeAttributes) : string.Empty;
var name = _typeDeclaration.Name;
var typeType = GetTypeOfType(_typeDeclaration);
var codeTypeMembers = _typeDeclaration.Members
.OfType <CodeTypeMember>()
.ToList();
var onlyOneConstructor = codeTypeMembers
.Where(member => member is CodeConstructor)
.Take(1);
var members = codeTypeMembers
.Where(member => IsSupportedType(member) && !(member is CodeConstructor))
.Union(onlyOneConstructor)
.Select(member =>
{
member.UserData["HasBaseConstructorCall"] = _typeDeclaration.BaseTypes.Count > 0;
member.UserData["GenerateFieldType"] = !_typeDeclaration.IsEnum;
member.UserData["GenerateAccessModifier"] = !_typeDeclaration.IsInterface;
member.UserData["GenerateMethodBody"] = !_typeDeclaration.IsInterface;
member.UserData["GeneratePropertyBody"] = !_typeDeclaration.IsInterface;
return(_options.IndentString + _memberFactory.GetMember(member, _options).Expand());
})
.ToList();
var membersExpression = string.Empty;
if (members.Any())
{
membersExpression = string.Join(Environment.NewLine, members.Where(member => !string.IsNullOrWhiteSpace(member)));
}
var typeParameters = _typeDeclaration.TypeParameters.OfType <CodeTypeParameter>()
.Select(parameter => _typescriptTypeParameter.Evaluate(parameter))
.ToList();
var typeParametersExpression = string.Empty;
if (typeParameters.Any())
{
typeParametersExpression = $"<{string.Join(",", typeParameters)}>";
}
var baseTypes = _typeDeclaration.BaseTypes
.OfType <CodeTypeReference>()
.Where(reference => _typescriptTypeMapper.IsValidTypeForDerivation(reference))
.Select(reference => _typescriptTypeMapper.GetTypeOutput(reference))
.ToList();
var baseTypesExpression = string.Empty;
if (baseTypes.Any() && !_typeDeclaration.IsEnum)
{
baseTypesExpression = $" extends {string.Join(",", baseTypes)}";
}
return(_options.IndentString + $"{accessModifier}{typeType} {name}{typeParametersExpression}{baseTypesExpression}{{{Environment.NewLine}{membersExpression}{Environment.NewLine}{_options.IndentString}}}");
}
public string Expand(CodeNamespace codeNamespace, CodeGeneratorOptions options)
{
var name = codeNamespace.Name;
var comments = codeNamespace.Comments
.OfType <CodeCommentStatement>()
.Select(statement => _statementFactory.GetStatement(statement, options).Expand())
.ToList();
var commentsExpression = string.Empty;
if (comments.Any())
{
commentsExpression = string.Join(Environment.NewLine, comments);
}
var imports = codeNamespace.Imports
.OfType <CodeNamespaceImport>()
.Select(import => $"import {import.Namespace};")
.ToList();
var importsExpression = string.Empty;
if (imports.Any())
{
importsExpression = $"{string.Join(Environment.NewLine, imports)}";
}
var types = codeNamespace.Types
.OfType <CodeTypeDeclaration>()
.Select(declaration =>
{
declaration.UserData["AddExportKeyword"] = !string.IsNullOrWhiteSpace(codeNamespace.Name);
return($"{Environment.NewLine}{_memberFactory.GetMember(declaration, options).Expand()}");
})
.ToList();
var typesExpression = string.Empty;
if (types.Any())
{
typesExpression = $"{string.Join(Environment.NewLine, types)}";
}
if (string.IsNullOrWhiteSpace(name))
{
return($"{importsExpression}{commentsExpression}{Environment.NewLine}{typesExpression}{Environment.NewLine}");
}
return($"{importsExpression}{commentsExpression}{Environment.NewLine}module {name}{{{typesExpression}{Environment.NewLine}}}");
}
public void GenerateCodeFromType(CodeTypeDeclaration member, TextWriter textWriter, CodeGeneratorOptions options)
{
var typeMember = _memberFactory.GetMember(member, options);
textWriter.Write(typeMember.Expand());
}
