TypeScriptToLua · Perryvw · Nov 13, 2019
diff --git a/src/BundlerTransformer.ts b/src/BundlerTransformer.ts
@@ -0,0 +1,30 @@
+import { TranspiledFile } from "./Transpile";
+import { LuaProjectTransformer } from "./CustomLuaTransformers";
+import { createBlock, Statement } from "./LuaAST";
+
+type BundlerTransformerFactory = (outFile: string) => LuaProjectTransformer;
+
+function notUndefined<T>(value: T | undefined): value is T {
+    return value !== undefined;
+}
+
+// TODO: Implement correctly, this is just a PoC!
+export const bundlerTransformer: BundlerTransformerFactory = (outFile: string) => (projectFiles: TranspiledFile[]) => {
+    const bundledFile: TranspiledFile = {
+        fileName: outFile,
+        declaration: projectFiles
+            .map(f => f.declaration)
+            .filter(notUndefined)
+            .join("\n"),
+        luaAst: createBlock(
+            ([] as Statement[]).concat(
+                ...projectFiles
+                    .map(f => f.luaAst)
+                    .filter(notUndefined)
+                    .map(ast => ast.statements)
+            )
+        ),
+
+    };
+    return [bundledFile];
+};
diff --git a/src/CustomLuaTransformers.ts b/src/CustomLuaTransformers.ts
@@ -0,0 +1,31 @@
+import { Diagnostic } from "typescript";
+import { CompilerOptions } from "./CompilerOptions";
+import { TranspiledFile } from "./Transpile";
+import { bundlerTransformer } from "./BundlerTransformer";
+
+export interface CustomLuaTransformers {
+    /** Custom transformers to evaluate before printing */
+    before: LuaProjectTransformer[];
+    /** Custom transformers to evaluate after printing */
+    after: LuaProjectTransformer[];
+}
+
+export type LuaProjectTransformer = (projectFiles: TranspiledFile[]) => TranspiledFile[];
+
+export function getCustomLuaTransformers(
+    options: CompilerOptions,
+    diagnostics: Diagnostic[]
+    //customTransformers: ts.CustomTransformers,
+): CustomLuaTransformers {
+    const beforePrinting: LuaProjectTransformer[] = [];
+    if (options.outFile) {
+        beforePrinting.push(bundlerTransformer(options.outFile));
+    }
+
+    const afterPrinting: LuaProjectTransformer[] = [];
+
+    return {
+        before: beforePrinting,
+        after: afterPrinting,
+    };
+}
diff --git a/src/TSTransformers.ts → src/CustomTSTransformers.ts b/src/TSTransformers.ts → src/CustomTSTransformers.ts
@@ -6,7 +6,7 @@ import { CompilerOptions, TransformerImport } from "./CompilerOptions";
 import * as diagnosticFactories from "./diagnostics";
 import { noImplicitSelfTransformer } from "./NoImplicitSelfTransformer";
 
-export function getCustomTransformers(
+export function getCustomTSTransformers(
     program: ts.Program,
     diagnostics: ts.Diagnostic[],
     customTransformers: ts.CustomTransformers,

diff --git a/src/Transpile.ts b/src/Transpile.ts
@@ -5,7 +5,8 @@ import { Block } from "./LuaAST";
 import { LuaPrinter } from "./LuaPrinter";
 import { LuaTransformer } from "./LuaTransformer";
 import { TranspileError } from "./TranspileError";
-import { getCustomTransformers } from "./TSTransformers";
+import { getCustomTSTransformers } from "./CustomTSTransformers";
+import { getCustomLuaTransformers } from "./CustomLuaTransformers";
 
 export interface TranspiledFile {
     fileName: string;
@@ -97,7 +98,7 @@ export function transpile({
         }
     };
 
-    const transformers = getCustomTransformers(program, diagnostics, customTransformers, processSourceFile);
+    const transformers = getCustomTSTransformers(program, diagnostics, customTransformers, processSourceFile);
 
     const writeFile: ts.WriteFileCallback = (fileName, data, _bom, _onError, sourceFiles = []) => {
         for (const sourceFile of sourceFiles) {
@@ -120,6 +121,13 @@ export function transpile({
     const oldNoEmit = options.noEmit;
     options.noEmit = false;
 
+    const luaTransformers = getCustomLuaTransformers(options, diagnostics);
+
+    // TODO: Make sure source files have been transformed at this point, but not printed
+    for (const luaTransformer of luaTransformers.before) {
+        transpiledFiles = luaTransformer(transpiledFiles);
+    }
+
     if (targetSourceFiles) {
         for (const file of targetSourceFiles) {
             if (isEmittableJsonFile(file)) {
@@ -144,5 +152,10 @@ export function transpile({
         transpiledFiles = [];
     }
 
+    // TODO: Make sure source files have been transformed AND printed at this point
+    for (const luaTransformer of luaTransformers.after) {
+        transpiledFiles = luaTransformer(transpiledFiles);
+    }
+
     return { diagnostics, transpiledFiles };
 }