@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Project/functions/getParsedCommandLine.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsedCommandLine = getParsedCommandLine;
+const inspector_1 = __importDefault(require("inspector"));
+const validateCompilerOptions_1 = require("./validateCompilerOptions");
+const DiagnosticError_1 = require("../../Shared/errors/DiagnosticError");
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const typescript_1 = __importDefault(require("typescript"));
+function createParseConfigFileHost() {
+    return {
+        fileExists: typescript_1.default.sys.fileExists,
+        getCurrentDirectory: typescript_1.default.sys.getCurrentDirectory,
+        onUnRecoverableConfigFileDiagnostic: d => {
+            throw new DiagnosticError_1.DiagnosticError([d]);
+        },
+        readDirectory: typescript_1.default.sys.readDirectory,
+        readFile: typescript_1.default.sys.readFile,
+        useCaseSensitiveFileNames: typescript_1.default.sys.useCaseSensitiveFileNames,
+    };
+}
+function getParsedCommandLine(data) {
+    const parsedCommandLine = typescript_1.default.getParsedCommandLineOfConfigFile(data.tsConfigPath, {}, createParseConfigFileHost());
+    if (parsedCommandLine === undefined) {
+        throw new ProjectError_1.ProjectError("Unable to load TS program!");
+    }
+    else if (parsedCommandLine.errors.length > 0) {
+        throw new DiagnosticError_1.DiagnosticError(parsedCommandLine.errors);
+    }
+    if (globalThis.RBXTSC_DEV || inspector_1.default.url() !== undefined) {
+        if (!parsedCommandLine.options.composite) {
+            parsedCommandLine.options.incremental = false;
+            parsedCommandLine.options.tsBuildInfoFile = undefined;
+        }
+    }
+    (0, validateCompilerOptions_1.validateCompilerOptions)(parsedCommandLine.options, data.projectPath);
+    return parsedCommandLine;
+}
+//# sourceMappingURL=getParsedCommandLine.js.map

package/out/Project/functions/getProjectReferences.d.ts

@@ -0,0 +1,2 @@
+import { ReferencedProjectInfo } from "../../Shared/types";
+export declare function getProjectReferences(tsConfigPath: string, luau: boolean): Array<ReferencedProjectInfo>;

package/out/Project/functions/getProjectReferences.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectReferences = getProjectReferences;
+const path_translator_1 = require("@roblox-ts/path-translator");
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+function getProjectReferences(tsConfigPath, luau) {
+    const visited = new Set();
+    return collectProjectReferences(tsConfigPath, visited, luau);
+}
+function collectProjectReferences(tsConfigPath, visited, luau) {
+    const normalizedPath = path_1.default.normalize(tsConfigPath);
+    if (visited.has(normalizedPath)) {
+        return [];
+    }
+    visited.add(normalizedPath);
+    const parsed = parseProjectConfig(tsConfigPath);
+    if (!parsed) {
+        return [];
+    }
+    const results = [];
+    for (const ref of parsed.references) {
+        const refConfigPath = resolveReferencePath(tsConfigPath, ref.path);
+        const refParsed = parseProjectConfig(refConfigPath);
+        if (!refParsed) {
+            continue;
+        }
+        results.push(...collectProjectReferences(refConfigPath, visited, luau), {
+            tsConfigPath: refConfigPath,
+            rootDir: refParsed.rootDir,
+            outDir: refParsed.outDir,
+            pathTranslator: new path_translator_1.PathTranslator(refParsed.rootDir, refParsed.outDir, undefined, true, luau),
+        });
+    }
+    return results;
+}
+function parseProjectConfig(tsConfigPath) {
+    var _a, _b, _c;
+    const configFile = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
+    if (configFile.error) {
+        return undefined;
+    }
+    const configDir = path_1.default.dirname(tsConfigPath);
+    const parsedConfig = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, configDir);
+    const rootDir = (_a = parsedConfig.options.rootDir) !== null && _a !== void 0 ? _a : configDir;
+    const outDir = (_b = parsedConfig.options.outDir) !== null && _b !== void 0 ? _b : configDir;
+    return {
+        tsConfigPath,
+        rootDir: path_1.default.resolve(configDir, rootDir),
+        outDir: path_1.default.resolve(configDir, outDir),
+        references: (_c = parsedConfig.projectReferences) !== null && _c !== void 0 ? _c : [],
+    };
+}
+function resolveReferencePath(fromConfigPath, refPath) {
+    const configDir = path_1.default.dirname(fromConfigPath);
+    const resolvedPath = path_1.default.resolve(configDir, refPath);
+    if (typescript_1.default.sys.directoryExists(resolvedPath)) {
+        return path_1.default.join(resolvedPath, "tsconfig.json");
+    }
+    return resolvedPath;
+}
+//# sourceMappingURL=getProjectReferences.js.map

package/out/Project/functions/getResolvedProjectReferences.d.ts

@@ -0,0 +1,3 @@
+import { ReferencedProjectInfo } from "../../Shared/types";
+import ts from "typescript";
+export declare function getResolvedProjectReferences(program: ts.Program, luau: boolean): Array<ReferencedProjectInfo>;

package/out/Project/functions/getResolvedProjectReferences.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolvedProjectReferences = getResolvedProjectReferences;
+const path_translator_1 = require("@roblox-ts/path-translator");
+const path_1 = __importDefault(require("path"));
+function getResolvedProjectReferences(program, luau) {
+    const resolvedRefs = program.getResolvedProjectReferences();
+    if (!resolvedRefs) {
+        return [];
+    }
+    const visited = new Set();
+    const results = [];
+    function collectReferences(refs) {
+        for (const ref of refs) {
+            if (!ref)
+                continue;
+            const configPath = path_1.default.normalize(ref.sourceFile.fileName);
+            if (visited.has(configPath))
+                continue;
+            visited.add(configPath);
+            if (ref.references) {
+                collectReferences(ref.references);
+            }
+            const options = ref.commandLine.options;
+            const configDir = path_1.default.dirname(configPath);
+            const rootDir = options.rootDir ? path_1.default.resolve(configDir, options.rootDir) : configDir;
+            const outDir = options.outDir ? path_1.default.resolve(configDir, options.outDir) : configDir;
+            results.push({
+                tsConfigPath: configPath,
+                rootDir,
+                outDir,
+                pathTranslator: new path_translator_1.PathTranslator(rootDir, outDir, undefined, true, luau),
+                fileNames: ref.commandLine.fileNames,
+            });
+        }
+    }
+    collectReferences(resolvedRefs);
+    return results;
+}
+//# sourceMappingURL=getResolvedProjectReferences.js.map

package/out/Project/functions/setupProjectWatchProgram.d.ts

@@ -0,0 +1,2 @@
+import { ProjectOptions } from "../../Shared/types";
+export declare function setupProjectWatchProgram(tsConfigPath: string, projectOptions: ProjectOptions): void;

package/out/Project/functions/setupProjectWatchProgram.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupProjectWatchProgram = setupProjectWatchProgram;
+const chokidar_1 = __importDefault(require("chokidar"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const checkFileName_1 = require("./checkFileName");
+const cleanup_1 = require("./cleanup");
+const compileFiles_1 = require("./compileFiles");
+const copyFiles_1 = require("./copyFiles");
+const copyInclude_1 = require("./copyInclude");
+const copyItem_1 = require("./copyItem");
+const createPathTranslator_1 = require("./createPathTranslator");
+const createProgramFactory_1 = require("./createProgramFactory");
+const createProjectData_1 = require("./createProjectData");
+const getChangedSourceFiles_1 = require("./getChangedSourceFiles");
+const getParsedCommandLine_1 = require("./getParsedCommandLine");
+const getProjectReferences_1 = require("./getProjectReferences");
+const tryRemoveOutput_1 = require("./tryRemoveOutput");
+const isCompilableFile_1 = require("../util/isCompilableFile");
+const walkDirectorySync_1 = require("../util/walkDirectorySync");
+const constants_1 = require("../../Shared/constants");
+const DiagnosticError_1 = require("../../Shared/errors/DiagnosticError");
+const assert_1 = require("../../Shared/util/assert");
+const getRootDirs_1 = require("../../Shared/util/getRootDirs");
+const typescript_1 = __importDefault(require("typescript"));
+const CHOKIDAR_OPTIONS = {
+    awaitWriteFinish: {
+        pollInterval: 10,
+        stabilityThreshold: 50,
+    },
+    ignoreInitial: true,
+};
+function fixSlashes(fsPath) {
+    return fsPath.replace(/\\/g, "/");
+}
+function setupProjectWatchProgram(tsConfigPath, projectOptions) {
+    const referencedProjects = (0, getProjectReferences_1.getProjectReferences)(tsConfigPath, projectOptions.luau);
+    const projectStates = new Map();
+    const rootData = (0, createProjectData_1.createProjectData)(tsConfigPath, projectOptions);
+    rootData.referencedProjects = referencedProjects;
+    const rootRojoConfigPath = rootData.rojoConfigPath;
+    const rootIncludePath = rootData.projectOptions.includePath;
+    for (const refProject of referencedProjects) {
+        const refProjectOptions = { ...projectOptions };
+        refProjectOptions.noInclude = true;
+        if (rootRojoConfigPath) {
+            refProjectOptions.rojo = rootRojoConfigPath;
+        }
+        const data = (0, createProjectData_1.createProjectData)(refProject.tsConfigPath, refProjectOptions);
+        data.referencedProjects = referencedProjects;
+        if (rootIncludePath) {
+            data.rootProjectIncludePath = rootIncludePath;
+        }
+        const { fileNames, options } = (0, getParsedCommandLine_1.getParsedCommandLine)(data);
+        projectStates.set(refProject.tsConfigPath, {
+            data,
+            fileNamesSet: new Set(fileNames),
+            options,
+            program: undefined,
+            pathTranslator: undefined,
+            createProgram: (0, createProgramFactory_1.createProgramFactory)(data, options),
+            rootDirs: (0, getRootDirs_1.getRootDirs)(options),
+            isRoot: false,
+        });
+    }
+    const { fileNames: rootFileNames, options: rootOptions } = (0, getParsedCommandLine_1.getParsedCommandLine)(rootData);
+    projectStates.set(tsConfigPath, {
+        data: rootData,
+        fileNamesSet: new Set(rootFileNames),
+        options: rootOptions,
+        program: undefined,
+        pathTranslator: undefined,
+        createProgram: (0, createProgramFactory_1.createProgramFactory)(rootData, rootOptions),
+        rootDirs: (0, getRootDirs_1.getRootDirs)(rootOptions),
+        isRoot: true,
+    });
+    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);
+    const diagnosticReporter = typescript_1.default.createDiagnosticReporter(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, rootOptions);
+    }
+    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 refreshProgram(state) {
+        state.program = state.createProgram([...state.fileNamesSet], state.options);
+        state.pathTranslator = (0, createPathTranslator_1.createPathTranslator)(state.program, state.data);
+    }
+    function buildProject(state) {
+        refreshProgram(state);
+        (0, assert_1.assert)(state.program && state.pathTranslator);
+        if (state.isRoot) {
+            (0, cleanup_1.cleanup)(state.pathTranslator);
+            (0, copyInclude_1.copyInclude)(state.data);
+        }
+        (0, copyFiles_1.copyFiles)(state.data, state.pathTranslator, new Set(state.rootDirs));
+        const sourceFiles = (0, getChangedSourceFiles_1.getChangedSourceFiles)(state.program);
+        return (0, compileFiles_1.compileFiles)(state.program.getProgram(), state.data, state.pathTranslator, sourceFiles);
+    }
+    function runInitialCompile() {
+        const allDiagnostics = [];
+        for (const refProject of referencedProjects) {
+            const state = projectStates.get(refProject.tsConfigPath);
+            if (state) {
+                const result = buildProject(state);
+                allDiagnostics.push(...result.diagnostics);
+                if (result.emitSkipped) {
+                    return allDiagnostics;
+                }
+            }
+        }
+        const rootState = projectStates.get(tsConfigPath);
+        if (rootState) {
+            const result = buildProject(rootState);
+            allDiagnostics.push(...result.diagnostics);
+            if (!result.emitSkipped) {
+                initialCompileCompleted = true;
+            }
+        }
+        return allDiagnostics;
+    }
+    const filesToCompile = new Map();
+    const filesToCopy = new Map();
+    const filesToClean = new Map();
+    function getOrCreateSet(map, key) {
+        let set = map.get(key);
+        if (!set) {
+            set = new Set();
+            map.set(key, set);
+        }
+        return set;
+    }
+    function runIncrementalCompile(additions, changes, removals) {
+        const affectedProjects = new Set();
+        for (const fsPath of additions) {
+            const state = findProjectForFile(fsPath);
+            if (!state)
+                continue;
+            affectedProjects.add(state.data.tsConfigPath);
+            if (fs_extra_1.default.statSync(fsPath).isDirectory()) {
+                (0, walkDirectorySync_1.walkDirectorySync)(fsPath, item => {
+                    if ((0, isCompilableFile_1.isCompilableFile)(item)) {
+                        state.fileNamesSet.add(item);
+                        getOrCreateSet(filesToCompile, state.data.tsConfigPath).add(item);
+                    }
+                });
+            }
+            else if ((0, isCompilableFile_1.isCompilableFile)(fsPath)) {
+                state.fileNamesSet.add(fsPath);
+                getOrCreateSet(filesToCompile, state.data.tsConfigPath).add(fsPath);
+            }
+            else {
+                (0, checkFileName_1.checkFileName)(fsPath);
+                getOrCreateSet(filesToCopy, state.data.tsConfigPath).add(fsPath);
+            }
+        }
+        for (const fsPath of changes) {
+            const state = findProjectForFile(fsPath);
+            if (!state)
+                continue;
+            affectedProjects.add(state.data.tsConfigPath);
+            if ((0, isCompilableFile_1.isCompilableFile)(fsPath)) {
+                getOrCreateSet(filesToCompile, state.data.tsConfigPath).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);
+                        }
+                    }
+                }
+                getOrCreateSet(filesToCopy, state.data.tsConfigPath).add(fsPath);
+            }
+        }
+        for (const fsPath of removals) {
+            const state = findProjectForFile(fsPath);
+            if (!state)
+                continue;
+            affectedProjects.add(state.data.tsConfigPath);
+            state.fileNamesSet.delete(fsPath);
+            getOrCreateSet(filesToClean, state.data.tsConfigPath).add(fsPath);
+        }
+        for (const refProject of referencedProjects) {
+            if (affectedProjects.has(refProject.tsConfigPath)) {
+                affectedProjects.add(tsConfigPath);
+                break;
+            }
+        }
+        const allDiagnostics = [];
+        for (const refProject of referencedProjects) {
+            if (!affectedProjects.has(refProject.tsConfigPath))
+                continue;
+            const state = projectStates.get(refProject.tsConfigPath);
+            if (!state)
+                continue;
+            refreshProgram(state);
+            (0, assert_1.assert)(state.program && state.pathTranslator);
+            const toCompile = filesToCompile.get(refProject.tsConfigPath);
+            const sourceFiles = (0, getChangedSourceFiles_1.getChangedSourceFiles)(state.program, state.options.incremental ? undefined : toCompile ? [...toCompile] : undefined);
+            const emitResult = (0, compileFiles_1.compileFiles)(state.program.getProgram(), state.data, state.pathTranslator, sourceFiles);
+            allDiagnostics.push(...emitResult.diagnostics);
+            if (emitResult.emitSkipped) {
+                return allDiagnostics;
+            }
+            const toClean = filesToClean.get(refProject.tsConfigPath);
+            if (toClean) {
+                for (const fsPath of toClean) {
+                    (0, tryRemoveOutput_1.tryRemoveOutput)(state.pathTranslator, state.pathTranslator.getOutputPath(fsPath));
+                    if (state.options.declaration) {
+                        (0, tryRemoveOutput_1.tryRemoveOutput)(state.pathTranslator, state.pathTranslator.getOutputDeclarationPath(fsPath));
+                    }
+                }
+            }
+            const toCopy = filesToCopy.get(refProject.tsConfigPath);
+            if (toCopy) {
+                for (const fsPath of toCopy) {
+                    (0, copyItem_1.copyItem)(state.data, state.pathTranslator, fsPath);
+                }
+            }
+        }
+        if (affectedProjects.has(tsConfigPath)) {
+            const state = projectStates.get(tsConfigPath);
+            if (state) {
+                refreshProgram(state);
+                (0, assert_1.assert)(state.program && state.pathTranslator);
+                const toCompile = filesToCompile.get(tsConfigPath);
+                const sourceFiles = (0, getChangedSourceFiles_1.getChangedSourceFiles)(state.program, state.options.incremental ? undefined : toCompile ? [...toCompile] : undefined);
+                const emitResult = (0, compileFiles_1.compileFiles)(state.program.getProgram(), state.data, state.pathTranslator, sourceFiles);
+                allDiagnostics.push(...emitResult.diagnostics);
+                if (!emitResult.emitSkipped) {
+                    const toClean = filesToClean.get(tsConfigPath);
+                    if (toClean) {
+                        for (const fsPath of toClean) {
+                            (0, tryRemoveOutput_1.tryRemoveOutput)(state.pathTranslator, state.pathTranslator.getOutputPath(fsPath));
+                            if (state.options.declaration) {
+                                (0, tryRemoveOutput_1.tryRemoveOutput)(state.pathTranslator, state.pathTranslator.getOutputDeclarationPath(fsPath));
+                            }
+                        }
+                    }
+                    const toCopy = filesToCopy.get(tsConfigPath);
+                    if (toCopy) {
+                        for (const fsPath of toCopy) {
+                            (0, copyItem_1.copyItem)(state.data, state.pathTranslator, fsPath);
+                        }
+                    }
+                }
+            }
+        }
+        filesToCompile.clear();
+        filesToCopy.clear();
+        filesToClean.clear();
+        return allDiagnostics;
+    }
+    function runCompile() {
+        try {
+            if (!initialCompileCompleted) {
+                return runInitialCompile();
+            }
+            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: 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());
+    });
+}
+//# sourceMappingURL=setupProjectWatchProgram.js.map

package/out/Project/functions/setupSolutionWatchProgram.d.ts

@@ -0,0 +1,2 @@
+import { ProjectOptions } from "../../Shared/types";
+export declare function setupSolutionWatchProgram(rootTsConfigPath: string, projectOptions: ProjectOptions): void;