import * as ts from "typescript";

import { EmitHost } from "..";

import { CompilerOptions } from "../CompilerOptions";

import { Printer } from "../LuaPrinter";

import { Visitors } from "../transformation/context";

import { EmitFile, getConfigDirectory, ProcessedFile, resolvePlugin } from "./utils";

import * as performance from "../measure-performance";

export interface Plugin {

/**

* An augmentation to the map of visitors that transform TypeScript AST to Lua AST.

*

* Key is a `SyntaxKind` of a processed node.

*/

visitors?: Visitors;

/**

* A function that converts Lua AST to a string.

*

* At most one custom printer can be provided across all plugins.

*/

printer?: Printer;

/**

* This function is called before transpilation of the TypeScript program starts.

*/

beforeTransform?: (program: ts.Program, options: CompilerOptions, emitHost: EmitHost) => ts.Diagnostic[] | void;

/**

* This function is called after translating the input program to Lua, but before resolving dependencies or bundling.

*/

afterPrint?: (

program: ts.Program,

options: CompilerOptions,

emitHost: EmitHost,

result: ProcessedFile[]

) => ts.Diagnostic[] | void;

/**

* This function is called after translating the input program to Lua, after resolving dependencies and after bundling.

*/

beforeEmit?: (

program: ts.Program,

options: CompilerOptions,

emitHost: EmitHost,

result: EmitFile[]

) => ts.Diagnostic[] | void;

/**

* This function is called after translating the input program to Lua, after resolving dependencies, after bundling and writing files to disk.

*/

afterEmit?: (

program: ts.Program,

options: CompilerOptions,

emitHost: EmitHost,

result: EmitFile[]

) => ts.Diagnostic[] | void;

/**

* This function is called when trying to resolve the .lua file corresponding to a Lua require statement. Allows you to provide

* your own module resolution logic. If return value is undefined, regular module resolution is done.

*/

moduleResolution?: (

moduleIdentifier: string,

requiringFile: string,

options: CompilerOptions,

emitHost: EmitHost

) => string | undefined;

}

export function getPlugins(program: ts.Program): { diagnostics: ts.Diagnostic[]; plugins: Plugin[] } {

performance.startSection("getPlugins");

const diagnostics: ts.Diagnostic[] = [];

const pluginsFromOptions: Plugin[] = [];

const options = program.getCompilerOptions() as CompilerOptions;

for (const [index, pluginOption] of (options.luaPlugins ?? []).entries()) {

const optionName = `tstl.luaPlugins[${index}]`;

const factory = (() => {

if ("plugin" in pluginOption) {

return pluginOption.plugin;

} else {

const { error: resolveError, result: factory } = resolvePlugin(

"plugin",

`${optionName}.name`,

getConfigDirectory(options),

pluginOption.name,

pluginOption.import

);

if (resolveError) diagnostics.push(resolveError);

return factory;

}

})();

if (factory === undefined) continue;

const plugin = typeof factory === "function" ? factory(pluginOption) : factory;

pluginsFromOptions.push(plugin);

}

if (options.tstlVerbose) {

console.log(`Loaded ${pluginsFromOptions.length} plugins`);

}

performance.endSection("getPlugins");

return { diagnostics, plugins: pluginsFromOptions };

}