public static void Main(params string[] args)
{
const string modelsNamespace = "AspNetCoreExample.Api.Models";
var customTypeGenerator = new CustomTypeGenerator()
.WithTypeRedirect <Guid>("Guid", @"dataTypes\Guid")
.WithTypeLocationRule(
x => TypeInfo.From <ControllerBase>().IsAssignableFrom(x),
x => $"api/{x.Name}".Replace("Controller", "Api")
)
.WithTypeLocationRule(
x => x.FullName.StartsWith(modelsNamespace),
x => "dto/" + x.FullName.Substring(modelsNamespace.Length + 1).Replace(".", "/")
)
.WithTypeBuildingContext(ApiControllerTypeBuildingContext.Accept, (unit, type) => new ApiControllerTypeBuildingContext(unit, type));
var typeScriptCodeGenerator = new TypeScriptGenerator(
new TypeScriptGenerationOptions
{
EnableExplicitNullability = true,
EnableOptionalProperties = false,
EnumGenerationMode = EnumGenerationMode.TypeScriptEnum,
LinterDisableMode = LinterDisableMode.TsLint,
UseGlobalNullable = true,
NullabilityMode = NullabilityMode.Optimistic,
},
customTypeGenerator,
new TypesProvider()
);
var targetPath = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory).FullName, "../../../output");
typeScriptCodeGenerator.GenerateFiles(targetPath, JavaScriptTypeChecker.TypeScript);
}
public static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
Parser.Default.ParseArguments <Options>(args).WithParsed(o =>
{
var targetAssembly = AssemblyUtils.GetAssemblies(o.Assembly);
var customTypeGenerator = GetSingleImplementation <ICustomTypeGenerator>(targetAssembly);
var typesProvider = GetSingleImplementation <ITypesProvider>(targetAssembly);
if (customTypeGenerator == null || typesProvider == null)
{
return;
}
var options = new TypeScriptGenerationOptions
{
EnableExplicitNullability = o.EnableExplicitNullability,
EnableOptionalProperties = o.EnableOptionalProperties,
EnumGenerationMode = o.EnumGenerationMode,
UseGlobalNullable = o.UseGlobalNullable,
NullabilityMode = o.NullabilityMode,
LinterDisableMode = o.LinterDisableMode,
};
var typeGenerator = new TypeScriptGenerator(options, customTypeGenerator, typesProvider);
typeGenerator.GenerateFiles(o.OutputDirectory, JavaScriptTypeChecker.TypeScript);
});
}
public void FlowAndTypeScriptEnumIncompatibilityTest()
{
var options = new TypeScriptGenerationOptions {
EnumGenerationMode = EnumGenerationMode.TypeScriptEnum
};
var generator = new TypeScriptGenerator(options, CustomTypeGenerator.Null, TypesProvider.Default);
Action filesGeneration = () => generator.GenerateFiles("", JavaScriptTypeChecker.Flow);
filesGeneration.Should().Throw <ArgumentException>().And.Message.Should().Be("Flow is not compatible with TypeScript enums");
}
protected void GenerateFiles(ICustomTypeGenerator customTypeGenerator, string folderName, params Type[] rootTypes)
{
var path = $"{TestContext.CurrentContext.TestDirectory}/{folderName}/{JavaScriptTypeChecker}";
if (Directory.Exists(path))
Directory.Delete(path, recursive : true);
Directory.CreateDirectory(path);
var generator = new TypeScriptGenerator(TestOptions, customTypeGenerator, new TypesProvider(rootTypes));
generator.GenerateFiles(path, JavaScriptTypeChecker);
}
public static void Main(params string[] args)
{
var targetPath = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory).FullName, "../../../output");
var options = new TypeScriptGenerationOptions
{
EnableOptionalProperties = false,
LinterDisableMode = LinterDisableMode.TsLint,
UseGlobalNullable = true,
NullabilityMode = NullabilityMode.Optimistic,
};
var typeScriptCodeGenerator = new TypeScriptGenerator(options, new AspNetCoreExampleCustomGenerator(), new TypesProvider());
typeScriptCodeGenerator.GenerateFiles(targetPath);
}
private static void ExecuteAndUnload(string assemblyPath, out WeakReference alcWeakRef, Options options)
{
var alc = new DirectoryAssemblyLoadContext(assemblyPath);
var targetAssembly = alc.LoadFromAssemblyPath(assemblyPath);
alcWeakRef = new WeakReference(alc, trackResurrection: true);
var customTypeGenerator = GetSingleImplementation <ICustomTypeGenerator>(targetAssembly);
var typesProvider = GetSingleImplementation <IRootTypesProvider>(targetAssembly);
if (customTypeGenerator == null || typesProvider == null)
{
return;
}
var typeGenerator = new TypeScriptGenerator(options.ToTypeScriptGenerationOptions(), customTypeGenerator, typesProvider);
typeGenerator.GenerateFiles(options.OutputDirectory);
alc.Unload();
}
static void Main(string[] args)
{
var apiAssemblies = new[] { typeof(SkillApiInstaller).Assembly, typeof(CommentsApiInstaller).Assembly };
var services = apiAssemblies.SelectMany(x => x.GetTypes().Where(x => x.BaseType == typeof(BusBasedService)));
var publicServiceMethods = services.SelectMany(x => x.GetMethods().Where(m => m.DeclaringType == x && m.IsPublic));
//service methods have to use only one public parameter - input param. And it should have output parameter - out param.
var inputParameters = publicServiceMethods.Select(x => x.GetParameters().Single().ParameterType);
var outputParameters = publicServiceMethods.Select(x => x.ReturnType.GetGenericArguments().Single());
var customGen = new CustomTypeGenerator()
.WithTypeLocationRule(x => true, x => DeterminePath(x))
.WithPropertyResolver(new CamelCasePropertyResolver());
var typesToGenerate = inputParameters.Concat(outputParameters).Concat(new[] { typeof(Page <>) }).ToArray();
var rootTypesProvider = new RootTypesProvider(typesToGenerate);
var generator = new TypeScriptGenerator(TypeScriptGenerationOptions.Default, customGen, rootTypesProvider);
generator.GenerateFiles("../../src/Kaizen.Ui.Angular/src/app/shared/models");
}
private static void GenerateByOptions(Options o)
{
Console.WriteLine("Generating TypeScript");
if (o.Assembly.Count() != 1 || o.Directory.Any())
{
var(customTypeGenerator, typesProvider) = AdhocProject.GetCompilation(o.Directory.ToArray(), o.Assembly.ToArray()).GetCustomization();
var typeGenerator = new TypeScriptGenerator(o.ToTypeScriptGenerationOptions(), customTypeGenerator, typesProvider);
typeGenerator.GenerateFiles(o.OutputDirectory);
return;
}
ExecuteAndUnload(Path.GetFullPath(o.Assembly.Single()), out var testAlcWeakRef, o);
// это нужно для того чтобы сборка из AssemblyLoadContext была выгружена
// https://docs.microsoft.com/en-us/dotnet/standard/assembly/unloadability?view=netcore-3.1
for (var i = 0; testAlcWeakRef.IsAlive && i < 10; i++)
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
// здесь может случиться deadlock
// https://github.com/dotnet/runtime/issues/535
GC.WaitForPendingFinalizers();
}
}
