Function getBundleResult

src/transpilation/bundle.ts:88–143

(program: ts.Program, files: ProcessedFile[])

}

export function getBundleResult(program: ts.Program, files: ProcessedFile[]): [ts.Diagnostic[], EmitFile] {
    const diagnostics: ts.Diagnostic[] = [];

    const options = program.getCompilerOptions() as CompilerOptions;
    const bundleFile = cast(options.luaBundle, isNonNull);
    const entryModule = cast(options.luaBundleEntry, isNonNull);

    // Resolve project settings relative to project file.
    const resolvedEntryModule = path.resolve(getProjectRoot(program), entryModule);
    const outputPath = path.resolve(getEmitOutDir(program), bundleFile);
    const entryModuleFilePath =
        program.getSourceFile(entryModule)?.fileName ?? program.getSourceFile(resolvedEntryModule)?.fileName;

    if (entryModuleFilePath === undefined) {
        diagnostics.push(couldNotFindBundleEntryPoint(entryModule));
    }

    // For each file: ["<module path>"] = function() <lua content> end,
    const moduleTableEntries = files.map(f => moduleSourceNode(f, createModulePath(f.fileName, program)));

    // Create ____modules table containing all entries from moduleTableEntries
    const moduleTable = createModuleTableNode(moduleTableEntries);

    // return require("<entry module path>")
    const args = options.luaTarget === LuaTarget.Lua50 ? "unpack(arg == nil and {} or arg)" : "...";
    // Avoid producing a tail-call (which removes the bundle's stack frame) by assigning the `require` result to a local and returning it.
    const entryPath = createModulePath(entryModuleFilePath ?? entryModule, program);
    const entryPoint = `local ____entry = require(${entryPath}, ${args})\nreturn ____entry\n`;

    const footers: string[] = [];
    if (options.sourceMapTraceback) {
        // Generates SourceMapTraceback for the entire file
        footers.push('local __TS__SourceMapTraceBack = require("lualib_bundle").__TS__SourceMapTraceBack\n');
        footers.push(`${sourceMapTracebackBundlePlaceholder}\n`);
    }

    const sourceChunks = [requireOverride(options), moduleTable, ...footers, entryPoint];

    if (!options.noHeader) {
        sourceChunks.unshift(tstlHeader);
    }

    const bundleNode = joinSourceChunks(sourceChunks);
    let { code, map } = bundleNode.toStringWithSourceMap();
    code = code.replace(sourceMapTracebackBundlePlaceholder, printStackTraceBundleOverride(bundleNode));

    return [
        diagnostics,
        {
            outputPath,
            code,
            sourceMap: map.toString(),
            sourceFiles: files.flatMap(x => x.sourceFiles ?? []),
        },
    ];
}

function moduleSourceNode({ code, sourceMapNode }: ProcessedFile, modulePath: string): SourceNode {