@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/CLI/commands/build.js

@@ -0,0 +1,438 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const assert_1 = __importDefault(require("assert"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const CLIError_1 = require("../errors/CLIError");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const checkFileName_1 = require("../../Project/functions/checkFileName");
+const cleanup_1 = require("../../Project/functions/cleanup");
+const compileFiles_1 = require("../../Project/functions/compileFiles");
+const copyFiles_1 = require("../../Project/functions/copyFiles");
+const copyInclude_1 = require("../../Project/functions/copyInclude");
+const copyItem_1 = require("../../Project/functions/copyItem");
+const createPathTranslator_1 = require("../../Project/functions/createPathTranslator");
+const createProgramFactory_1 = require("../../Project/functions/createProgramFactory");
+const createProjectData_1 = require("../../Project/functions/createProjectData");
+const getChangedSourceFiles_1 = require("../../Project/functions/getChangedSourceFiles");
+const getParsedCommandLine_1 = require("../../Project/functions/getParsedCommandLine");
+const tryRemoveOutput_1 = require("../../Project/functions/tryRemoveOutput");
+const isCompilableFile_1 = require("../../Project/util/isCompilableFile");
+const walkDirectorySync_1 = require("../../Project/util/walkDirectorySync");
+const LogService_1 = require("../../Shared/classes/LogService");
+const constants_1 = require("../../Shared/constants");
+const DiagnosticError_1 = require("../../Shared/errors/DiagnosticError");
+const LoggableError_1 = require("../../Shared/errors/LoggableError");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+const hasErrors_1 = require("../../Shared/util/hasErrors");
+const typescript_1 = __importDefault(require("typescript"));
+function getTsConfigProjectOptions(tsConfigPath) {
+    if (tsConfigPath !== undefined) {
+        const rawJson = typescript_1.default.sys.readFile(tsConfigPath);
+        if (rawJson !== undefined) {
+            return typescript_1.default.parseConfigFileTextToJson(tsConfigPath, rawJson).config.rbxts;
+        }
+    }
+}
+function findTsConfigPath(projectPath) {
+    let tsConfigPath = path_1.default.resolve(projectPath);
+    if (!fs_extra_1.default.existsSync(tsConfigPath) || !fs_extra_1.default.statSync(tsConfigPath).isFile()) {
+        tsConfigPath = typescript_1.default.findConfigFile(tsConfigPath, typescript_1.default.sys.fileExists);
+        if (tsConfigPath === undefined) {
+            throw new CLIError_1.CLIError("Unable to find tsconfig.json!");
+        }
+    }
+    return path_1.default.resolve(process.cwd(), tsConfigPath);
+}
+module.exports = typescript_1.default.identity({
+    command: ["$0", "build"],
+    describe: "Build a project",
+    builder: (parser) => parser
+        .option("project", {
+        alias: "p",
+        string: true,
+        default: ".",
+        describe: "project path",
+    })
+        .option("watch", {
+        alias: "w",
+        boolean: true,
+        describe: "enable watch mode",
+    })
+        .option("usePolling", {
+        implies: "watch",
+        boolean: true,
+        describe: "use polling for watch mode",
+    })
+        .option("verbose", {
+        boolean: true,
+        describe: "enable verbose logs",
+    })
+        .option("noInclude", {
+        boolean: true,
+        describe: "do not copy include files",
+    })
+        .option("logTruthyChanges", {
+        boolean: true,
+        describe: "logs changes to truthiness evaluation from Lua truthiness rules",
+    })
+        .option("writeOnlyChanged", {
+        boolean: true,
+        hidden: true,
+    })
+        .option("writeTransformedFiles", {
+        boolean: true,
+        hidden: true,
+        describe: "writes resulting TypeScript ASTs after transformers to out directory",
+    })
+        .option("optimizedLoops", {
+        boolean: true,
+        hidden: true,
+    })
+        .option("type", {
+        choices: [constants_1.ProjectType.Game, constants_1.ProjectType.Model, constants_1.ProjectType.Package],
+        describe: "override project type",
+    })
+        .option("includePath", {
+        alias: "i",
+        string: true,
+        describe: "folder to copy runtime files to",
+    })
+        .option("rojo", {
+        string: true,
+        describe: "manually select Rojo project file",
+    })
+        .option("allowCommentDirectives", {
+        boolean: true,
+        hidden: true,
+    })
+        .option("luau", {
+        boolean: true,
+        describe: "emit files with .luau extension",
+    }),
+    handler: async (argv) => {
+        try {
+            let rootData;
+            {
+                const tsConfigPath = findTsConfigPath(argv.project);
+                const projectOptions = Object.assign({}, constants_1.DEFAULT_PROJECT_OPTIONS, getTsConfigProjectOptions(tsConfigPath), argv);
+                rootData = (0, createProjectData_1.createProjectData)(tsConfigPath, projectOptions);
+            }
+            LogService_1.LogService.verbose = rootData.projectOptions.verbose === true;
+            const diagnosticReporter = typescript_1.default.createDiagnosticReporter(typescript_1.default.sys, true);
+            const projectStates = new Map();
+            function createProjectState(data, isRoot) {
+                const { fileNames, options, projectReferences } = (0, getParsedCommandLine_1.getParsedCommandLine)(data);
+                return {
+                    data,
+                    fileNamesSet: new Set(fileNames),
+                    compilerOptions: options,
+                    createProgram: (0, createProgramFactory_1.createProgramFactory)(data, options, projectReferences),
+                    rootDirs: (0, getRootDirs_1.getRootDirs)(options),
+                    isRoot,
+                    pathTranslator: (0, createPathTranslator_1.createPathTranslator)(options, data),
+                };
+            }
+            for (const refProject of rootData.referencedProjects) {
+                const options = {
+                    ...rootData.projectOptions,
+                    noInclude: true,
+                    includePath: rootData.projectOptions.includePath,
+                    rojo: rootData.rojoConfigPath,
+                };
+                const data = (0, createProjectData_1.createProjectData)(refProject.tsConfigPath, options);
+                projectStates.set(data.tsConfigPath, createProjectState(data, false));
+            }
+            const rootState = createProjectState(rootData, true);
+            projectStates.set(rootData.tsConfigPath, rootState);
+            function getProjectPathTranslator(tsConfigPath) {
+                const project = projectStates.get(tsConfigPath);
+                (0, assert_1.default)(project);
+                return project.pathTranslator;
+            }
+            function buildProject(state, changedFiles, copyAllFiles) {
+                const relPath = path_1.default.relative(path_1.default.dirname(rootData.projectPath), state.data.projectPath);
+                LogService_1.LogService.writeLineIfVerbose(`Building project: ${relPath}`);
+                const program = state.createProgram([...state.fileNamesSet], state.compilerOptions);
+                if (copyAllFiles) {
+                    (0, copyFiles_1.copyFiles)(state.data, state.pathTranslator, new Set(state.rootDirs));
+                }
+                const sourceFiles = (0, getChangedSourceFiles_1.getChangedSourceFiles)(program, state.compilerOptions.incremental ? undefined : changedFiles);
+                const result = (0, compileFiles_1.compileFiles)(program.getProgram(), state.data, state.pathTranslator, getProjectPathTranslator, sourceFiles);
+                return { result, pathTranslator: state.pathTranslator };
+            }
+            function buildAllProjects() {
+                (0, cleanup_1.cleanup)(rootState.pathTranslator);
+                (0, copyInclude_1.copyInclude)(rootState.data);
+                const allDiagnostics = [];
+                let depEmitSkipped = false;
+                for (const refProject of rootData.referencedProjects) {
+                    const state = projectStates.get(refProject.tsConfigPath);
+                    (0, assert_1.default)(state);
+                    const { result } = buildProject(state, undefined, true);
+                    allDiagnostics.push(...result.diagnostics);
+                    if (result.emitSkipped) {
+                        depEmitSkipped = true;
+                        break;
+                    }
+                    if ((0, hasErrors_1.hasErrors)(result.diagnostics)) {
+                        break;
+                    }
+                }
+                const { result: rootResult } = buildProject(rootState, undefined, true);
+                allDiagnostics.push(...rootResult.diagnostics);
+                return { diagnostics: allDiagnostics, emitSkipped: depEmitSkipped || rootResult.emitSkipped };
+            }
+            if (rootData.projectOptions.watch) {
+                const CHOKIDAR_OPTIONS = {
+                    awaitWriteFinish: {
+                        pollInterval: 10,
+                        stabilityThreshold: 50,
+                    },
+                    ignoreInitial: true,
+                };
+                function fixSlashes(fsPath) {
+                    return fsPath.replace(/\\/g, "/");
+                }
+                let initialCompileCompleted = false;
+                let collecting = false;
+                let filesToAdd = new Set();
+                let filesToChange = new Set();
+                let filesToDelete = new Set();
+                const watchReporter = typescript_1.default.createWatchStatusReporter(typescript_1.default.sys, true);
+                function reportText(messageText) {
+                    watchReporter({
+                        category: typescript_1.default.DiagnosticCategory.Message,
+                        messageText,
+                        code: 0,
+                        file: undefined,
+                        length: undefined,
+                        start: undefined,
+                    }, typescript_1.default.sys.newLine, rootState.compilerOptions);
+                }
+                function reportEmitResult(diagnostics) {
+                    for (const diagnostic of diagnostics) {
+                        diagnosticReporter(diagnostic);
+                    }
+                    const amtErrors = diagnostics.filter(v => v.category === typescript_1.default.DiagnosticCategory.Error).length;
+                    reportText(`Found ${amtErrors} error${amtErrors === 1 ? "" : "s"}. Watching for file changes.`);
+                }
+                function findProjectForFile(filePath) {
+                    const normalizedPath = path_1.default.normalize(filePath);
+                    for (const state of projectStates.values()) {
+                        for (const rootDir of state.rootDirs) {
+                            if (normalizedPath.startsWith(path_1.default.normalize(rootDir) + path_1.default.sep)) {
+                                return state;
+                            }
+                        }
+                    }
+                    return undefined;
+                }
+                function runIncrementalCompile(additions, changes, removals) {
+                    const bucketsByProject = new Map();
+                    const affectedProjects = new Set();
+                    function getProjectBuckets(state) {
+                        let b = bucketsByProject.get(state);
+                        if (!b) {
+                            b = { toCompile: new Set(), toCopy: new Set(), toClean: new Set() };
+                            bucketsByProject.set(state, b);
+                        }
+                        return b;
+                    }
+                    for (const fsPath of additions) {
+                        const state = findProjectForFile(fsPath);
+                        if (!state) {
+                            continue;
+                        }
+                        affectedProjects.add(state);
+                        const bucket = getProjectBuckets(state);
+                        if (fs_extra_1.default.statSync(fsPath).isDirectory()) {
+                            (0, walkDirectorySync_1.walkDirectorySync)(fsPath, item => {
+                                if ((0, isCompilableFile_1.isCompilableFile)(item)) {
+                                    state.fileNamesSet.add(item);
+                                    bucket.toCompile.add(item);
+                                }
+                            });
+                        }
+                        else if ((0, isCompilableFile_1.isCompilableFile)(fsPath)) {
+                            state.fileNamesSet.add(fsPath);
+                            bucket.toCompile.add(fsPath);
+                        }
+                        else {
+                            (0, checkFileName_1.checkFileName)(fsPath);
+                            bucket.toCopy.add(fsPath);
+                        }
+                    }
+                    for (const fsPath of changes) {
+                        const state = findProjectForFile(fsPath);
+                        if (!state) {
+                            continue;
+                        }
+                        affectedProjects.add(state);
+                        const bucket = getProjectBuckets(state);
+                        if ((0, isCompilableFile_1.isCompilableFile)(fsPath)) {
+                            bucket.toCompile.add(fsPath);
+                        }
+                        else {
+                            if (fsPath.endsWith(constants_1.DTS_EXT)) {
+                                const transformerWatcher = state.data.transformerWatcher;
+                                if (transformerWatcher) {
+                                    const contents = typescript_1.default.sys.readFile(fsPath);
+                                    if (contents) {
+                                        transformerWatcher.updateFile(fsPath, contents);
+                                    }
+                                }
+                            }
+                            bucket.toCopy.add(fsPath);
+                        }
+                    }
+                    for (const fsPath of removals) {
+                        const state = findProjectForFile(fsPath);
+                        if (!state) {
+                            continue;
+                        }
+                        affectedProjects.add(state);
+                        const bucket = getProjectBuckets(state);
+                        state.fileNamesSet.delete(fsPath);
+                        bucket.toClean.add(fsPath);
+                    }
+                    let dependencyAffected = false;
+                    for (const refProject of rootData.referencedProjects) {
+                        const state = projectStates.get(refProject.tsConfigPath);
+                        (0, assert_1.default)(state);
+                        if (affectedProjects.has(state)) {
+                            dependencyAffected = true;
+                        }
+                        else if (dependencyAffected) {
+                            affectedProjects.add(state);
+                        }
+                    }
+                    if (dependencyAffected) {
+                        affectedProjects.add(rootState);
+                    }
+                    const allDiagnostics = [];
+                    for (const tsConfigPath of [
+                        ...rootData.referencedProjects.map(p => p.tsConfigPath),
+                        rootState.data.tsConfigPath,
+                    ]) {
+                        const state = projectStates.get(tsConfigPath);
+                        (0, assert_1.default)(state);
+                        if (!affectedProjects.has(state)) {
+                            continue;
+                        }
+                        const { toCompile, toClean, toCopy } = getProjectBuckets(state);
+                        const { result, pathTranslator } = buildProject(state, toCompile.size > 0 ? [...toCompile] : undefined, false);
+                        allDiagnostics.push(...result.diagnostics);
+                        if (result.emitSkipped) {
+                            break;
+                        }
+                        else {
+                            for (const fsPath of toClean) {
+                                (0, tryRemoveOutput_1.tryRemoveOutput)(pathTranslator, pathTranslator.getOutputPath(fsPath));
+                                if (state.compilerOptions.declaration) {
+                                    (0, tryRemoveOutput_1.tryRemoveOutput)(pathTranslator, pathTranslator.getOutputDeclarationPath(fsPath));
+                                }
+                            }
+                            for (const fsPath of toCopy) {
+                                (0, copyItem_1.copyItem)(state.data, pathTranslator, fsPath);
+                            }
+                        }
+                    }
+                    return allDiagnostics;
+                }
+                function runCompile() {
+                    try {
+                        if (!initialCompileCompleted) {
+                            const result = buildAllProjects();
+                            if (!result.emitSkipped) {
+                                initialCompileCompleted = true;
+                            }
+                            return result.diagnostics;
+                        }
+                        else {
+                            const additions = filesToAdd;
+                            const changes = filesToChange;
+                            const removals = filesToDelete;
+                            filesToAdd = new Set();
+                            filesToChange = new Set();
+                            filesToDelete = new Set();
+                            return runIncrementalCompile(additions, changes, removals);
+                        }
+                    }
+                    catch (e) {
+                        if (e instanceof DiagnosticError_1.DiagnosticError) {
+                            return [...e.diagnostics];
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                function closeEventCollection() {
+                    collecting = false;
+                    reportEmitResult(runCompile());
+                }
+                function openEventCollection() {
+                    if (!collecting) {
+                        collecting = true;
+                        reportText("File change detected. Starting incremental compilation...");
+                        setTimeout(closeEventCollection, 100);
+                    }
+                }
+                function collectAddEvent(fsPath) {
+                    filesToAdd.add(fixSlashes(fsPath));
+                    openEventCollection();
+                }
+                function collectChangeEvent(fsPath) {
+                    filesToChange.add(fixSlashes(fsPath));
+                    openEventCollection();
+                }
+                function collectDeleteEvent(fsPath) {
+                    filesToDelete.add(fixSlashes(fsPath));
+                    openEventCollection();
+                }
+                const allRootDirs = [];
+                for (const state of projectStates.values()) {
+                    allRootDirs.push(...state.rootDirs);
+                }
+                const chokidarOptions = {
+                    ...CHOKIDAR_OPTIONS,
+                    usePolling: rootData.projectOptions.usePolling,
+                };
+                chokidar_1.default
+                    .watch(allRootDirs, chokidarOptions)
+                    .on("add", collectAddEvent)
+                    .on("addDir", collectAddEvent)
+                    .on("change", collectChangeEvent)
+                    .on("unlink", collectDeleteEvent)
+                    .on("unlinkDir", collectDeleteEvent)
+                    .once("ready", () => {
+                    reportText("Starting compilation in watch mode...");
+                    reportEmitResult(runCompile());
+                });
+            }
+            else {
+                const allDiagnostics = buildAllProjects().diagnostics;
+                for (const diagnostic of allDiagnostics) {
+                    diagnosticReporter(diagnostic);
+                }
+                if ((0, hasErrors_1.hasErrors)(allDiagnostics)) {
+                    process.exitCode = 1;
+                }
+            }
+        }
+        catch (e) {
+            process.exitCode = 1;
+            if (e instanceof LoggableError_1.LoggableError) {
+                e.log();
+                debugger;
+            }
+            else {
+                throw e;
+            }
+        }
+    },
+});
+//# sourceMappingURL=build.js.map

package/out/CLI/errors/CLIError.d.ts

@@ -0,0 +1,4 @@
+import { DiagnosticError } from "../../Shared/errors/DiagnosticError";
+export declare class CLIError extends DiagnosticError {
+    constructor(message: string);
+}

package/out/CLI/errors/CLIError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIError = void 0;
+const DiagnosticError_1 = require("../../Shared/errors/DiagnosticError");
+const createTextDiagnostic_1 = require("../../Shared/util/createTextDiagnostic");
+class CLIError extends DiagnosticError_1.DiagnosticError {
+    constructor(message) {
+        super([(0, createTextDiagnostic_1.createTextDiagnostic)(message)]);
+    }
+}
+exports.CLIError = CLIError;
+//# sourceMappingURL=CLIError.js.map

package/out/CLI/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../Project";
+export { COMPILER_VERSION } from "../Shared/constants";
+import "./util/patchFs";

package/out/CLI/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPILER_VERSION = void 0;
+__exportStar(require("../Project"), exports);
+var constants_1 = require("../Shared/constants");
+Object.defineProperty(exports, "COMPILER_VERSION", { enumerable: true, get: function () { return constants_1.COMPILER_VERSION; } });
+require("./util/patchFs");
+//# sourceMappingURL=index.js.map

package/out/CLI/test.d.ts

@@ -0,0 +1 @@
+export {};

package/out/CLI/test.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const compileFiles_1 = require("../Project/functions/compileFiles");
+const copyFiles_1 = require("../Project/functions/copyFiles");
+const copyInclude_1 = require("../Project/functions/copyInclude");
+const createPathTranslator_1 = require("../Project/functions/createPathTranslator");
+const createProgramFactory_1 = require("../Project/functions/createProgramFactory");
+const createProjectData_1 = require("../Project/functions/createProjectData");
+const getChangedSourceFiles_1 = require("../Project/functions/getChangedSourceFiles");
+const getParsedCommandLine_1 = require("../Project/functions/getParsedCommandLine");
+const constants_1 = require("../Shared/constants");
+const diagnostics_1 = require("../Shared/diagnostics");
+const assert_1 = require("../Shared/util/assert");
+const formatDiagnostics_1 = require("../Shared/util/formatDiagnostics");
+const getRootDirs_1 = require("../Shared/util/getRootDirs");
+const isPathDescendantOf_1 = require("../Shared/util/isPathDescendantOf");
+const DIAGNOSTIC_TEST_NAME_REGEX = /^(\w+)(?:\.\d+)?$/;
+describe("should compile tests project", () => {
+    var _a;
+    const data = (0, createProjectData_1.createProjectData)(path_1.default.join(constants_1.PACKAGE_ROOT, "tests", "tsconfig.json"), Object.assign({}, constants_1.DEFAULT_PROJECT_OPTIONS, {
+        project: "",
+        allowCommentDirectives: true,
+        optimizedLoops: true,
+    }));
+    const { fileNames, options, projectReferences } = (0, getParsedCommandLine_1.getParsedCommandLine)(data);
+    const createProgram = (0, createProgramFactory_1.createProgramFactory)(data, options, projectReferences);
+    const program = createProgram(fileNames, options);
+    const pathTranslator = (0, createPathTranslator_1.createPathTranslator)(options, data);
+    fs_extra_1.default.removeSync(program.getCompilerOptions().outDir);
+    it("should copy include files", () => (0, copyInclude_1.copyInclude)(data));
+    it("should copy non-compiled files", () => (0, copyFiles_1.copyFiles)(data, pathTranslator, new Set((0, getRootDirs_1.getRootDirs)(program.getCompilerOptions()))));
+    const diagnosticsFolder = path_1.default.join(constants_1.PACKAGE_ROOT, "tests", "src", "diagnostics");
+    for (const sourceFile of (0, getChangedSourceFiles_1.getChangedSourceFiles)(program)) {
+        const fileName = path_1.default.relative(process.cwd(), sourceFile.fileName);
+        if ((0, isPathDescendantOf_1.isPathDescendantOf)(path_1.default.normalize(sourceFile.fileName), diagnosticsFolder)) {
+            let fileBaseName = path_1.default.basename(sourceFile.fileName);
+            const ext = path_1.default.extname(fileBaseName);
+            if (ext === constants_1.TS_EXT || ext === constants_1.TSX_EXT) {
+                fileBaseName = path_1.default.basename(sourceFile.fileName, ext);
+            }
+            const diagnosticName = (_a = fileBaseName.match(DIAGNOSTIC_TEST_NAME_REGEX)) === null || _a === void 0 ? void 0 : _a[1];
+            (0, assert_1.assert)(diagnosticName && diagnostics_1.errors[diagnosticName], `Diagnostic test for unknown diagnostic ${fileBaseName}`);
+            const expectedId = diagnostics_1.errors[diagnosticName].id;
+            it(`should compile ${fileName} and report diagnostic ${diagnosticName}`, done => {
+                process.env.ROBLOX_TS_EXPECTED_DIAGNOSTIC_ID = String(expectedId);
+                const emitResult = (0, compileFiles_1.compileFiles)(program.getProgram(), data, pathTranslator, () => pathTranslator, [
+                    sourceFile,
+                ]);
+                delete process.env.ROBLOX_TS_EXPECTED_DIAGNOSTIC_ID;
+                if (emitResult.diagnostics.length > 0 &&
+                    emitResult.diagnostics.every(d => (0, diagnostics_1.getDiagnosticId)(d) === expectedId)) {
+                    done();
+                }
+                else if (emitResult.diagnostics.length === 0) {
+                    done(new Error(`Expected diagnostic ${diagnosticName} to be reported.`));
+                }
+                else {
+                    done(new Error("Unexpected diagnostics:\n" + (0, formatDiagnostics_1.formatDiagnostics)(emitResult.diagnostics)));
+                }
+            });
+        }
+        else {
+            it(`should compile ${fileName}`, done => {
+                const emitResult = (0, compileFiles_1.compileFiles)(program.getProgram(), data, pathTranslator, () => pathTranslator, [
+                    sourceFile,
+                ]);
+                if (emitResult.diagnostics.length > 0) {
+                    done(new Error("\n" + (0, formatDiagnostics_1.formatDiagnostics)(emitResult.diagnostics)));
+                }
+                else {
+                    done();
+                }
+            });
+        }
+    }
+});
+//# sourceMappingURL=test.js.map

package/out/CLI/util/patchFs.d.ts

@@ -0,0 +1 @@
+export {};

package/out/CLI/util/patchFs.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const NOOP = () => { };
+const ASYNC_NOOP = async () => { };
+(_a = fs_extra_1.default.copy) !== null && _a !== void 0 ? _a : (fs_extra_1.default.copy = ASYNC_NOOP);
+(_b = fs_extra_1.default.copySync) !== null && _b !== void 0 ? _b : (fs_extra_1.default.copySync = NOOP);
+(_c = fs_extra_1.default.existsSync) !== null && _c !== void 0 ? _c : (fs_extra_1.default.existsSync = () => false);
+(_d = fs_extra_1.default.outputFile) !== null && _d !== void 0 ? _d : (fs_extra_1.default.outputFile = ASYNC_NOOP);
+(_e = fs_extra_1.default.outputFileSync) !== null && _e !== void 0 ? _e : (fs_extra_1.default.outputFileSync = NOOP);
+(_f = fs_extra_1.default.pathExists) !== null && _f !== void 0 ? _f : (fs_extra_1.default.pathExists = async () => false);
+(_g = fs_extra_1.default.pathExistsSync) !== null && _g !== void 0 ? _g : (fs_extra_1.default.pathExistsSync = () => false);
+(_h = fs_extra_1.default.readdir) !== null && _h !== void 0 ? _h : (fs_extra_1.default.readdir = async () => []);
+(_j = fs_extra_1.default.readdirSync) !== null && _j !== void 0 ? _j : (fs_extra_1.default.readdirSync = () => []);
+(_k = fs_extra_1.default.readFileSync) !== null && _k !== void 0 ? _k : (fs_extra_1.default.readFileSync = () => Buffer.from(""));
+(_l = fs_extra_1.default.readJson) !== null && _l !== void 0 ? _l : (fs_extra_1.default.readJson = ASYNC_NOOP);
+(_m = fs_extra_1.default.readJSONSync) !== null && _m !== void 0 ? _m : (fs_extra_1.default.readJSONSync = NOOP);
+(_o = fs_extra_1.default.realpathSync) !== null && _o !== void 0 ? _o : (fs_extra_1.default.realpathSync = ((path) => path));
+(_p = fs_extra_1.default.removeSync) !== null && _p !== void 0 ? _p : (fs_extra_1.default.removeSync = NOOP);
+(_q = fs_extra_1.default.stat) !== null && _q !== void 0 ? _q : (fs_extra_1.default.stat = () => ({}));
+(_r = fs_extra_1.default.statSync) !== null && _r !== void 0 ? _r : (fs_extra_1.default.statSync = () => ({}));
+//# sourceMappingURL=patchFs.js.map

package/out/Project/classes/VirtualFileSystem.d.ts

@@ -0,0 +1,14 @@
+export declare const PATH_SEP = "/";
+export declare function pathJoin(...parts: Array<string>): string;
+export declare class VirtualFileSystem {
+    private root;
+    constructor();
+    private getPathParts;
+    writeFile(filePath: string, content: string): void;
+    private get;
+    readFile(filePath: string): string | undefined;
+    fileExists(filePath: string): boolean;
+    directoryExists(dirPath: string): boolean;
+    getDirectories(dirPath: string): string[];
+    getFilePaths(): string[];
+}