@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Project/functions/setupSolutionWatchProgram.js

@@ -0,0 +1,355 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSolutionWatchProgram = setupSolutionWatchProgram;
+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 setupSolutionWatchProgram(rootTsConfigPath, projectOptions) {
+    const referencedProjects = (0, getProjectReferences_1.getProjectReferences)(rootTsConfigPath, projectOptions.luau);
+    const projectStates = new Map();
+    const rootData = (0, createProjectData_1.createProjectData)(rootTsConfigPath, projectOptions);
+    rootData.referencedProjects = referencedProjects;
+    rootData.isCompositeProject = true;
+    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;
+        data.isCompositeProject = true;
+        data.isReferencedProject = true;
+        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(rootTsConfigPath, {
+        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(rootTsConfigPath);
+        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(rootTsConfigPath);
+                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(rootTsConfigPath)) {
+            const state = projectStates.get(rootTsConfigPath);
+            if (state) {
+                refreshProgram(state);
+                (0, assert_1.assert)(state.program && state.pathTranslator);
+                const toCompile = filesToCompile.get(rootTsConfigPath);
+                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(rootTsConfigPath);
+                    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(rootTsConfigPath);
+                    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 (solution build)...");
+        reportEmitResult(runCompile());
+    });
+}
+//# sourceMappingURL=setupSolutionWatchProgram.js.map

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

@@ -0,0 +1,2 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+export declare function tryRemoveOutput(pathTranslator: PathTranslator, outPath: string): void;

package/out/Project/functions/tryRemoveOutput.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryRemoveOutput = tryRemoveOutput;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const LogService_1 = require("../../Shared/classes/LogService");
+const constants_1 = require("../../Shared/constants");
+function isOutputFileOrphaned(pathTranslator, filePath) {
+    if (filePath.endsWith(constants_1.DTS_EXT) && !pathTranslator.declaration) {
+        return true;
+    }
+    for (const path of pathTranslator.getInputPaths(filePath)) {
+        if (fs_extra_1.default.pathExistsSync(path)) {
+            return false;
+        }
+    }
+    if (pathTranslator.buildInfoOutputPath === filePath) {
+        return false;
+    }
+    return true;
+}
+function tryRemoveOutput(pathTranslator, outPath) {
+    if (isOutputFileOrphaned(pathTranslator, outPath)) {
+        fs_extra_1.default.removeSync(outPath);
+        LogService_1.LogService.writeLineIfVerbose(`remove ${outPath}`);
+    }
+}
+//# sourceMappingURL=tryRemoveOutput.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function validateCompilerOptions(opts: ts.CompilerOptions, projectPath: string): void;

package/out/Project/functions/validateCompilerOptions.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCompilerOptions = validateCompilerOptions;
+const fs_1 = __importDefault(require("fs"));
+const kleur_1 = __importDefault(require("kleur"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../Shared/constants");
+const ProjectError_1 = require("../../Shared/errors/ProjectError");
+const typescript_1 = __importDefault(require("typescript"));
+const ENFORCED_OPTIONS = {
+    target: typescript_1.default.ScriptTarget.ESNext,
+    module: typescript_1.default.ModuleKind.CommonJS,
+    moduleDetection: typescript_1.default.ModuleDetectionKind.Force,
+    moduleResolution: typescript_1.default.ModuleResolutionKind.Node10,
+    noLib: true,
+    strict: true,
+    allowSyntheticDefaultImports: true,
+};
+function y(str) {
+    return kleur_1.default.yellow(str);
+}
+function validateTypeRoots(projectPath, typeRoots) {
+    for (const typeRoot of typeRoots) {
+        const resolvedTypeRoot = path_1.default.resolve(projectPath, typeRoot);
+        if (resolvedTypeRoot.endsWith(constants_1.RBXTS_SCOPE) && fs_1.default.existsSync(resolvedTypeRoot)) {
+            return true;
+        }
+    }
+    return false;
+}
+function validateCompilerOptions(opts, projectPath) {
+    var _a, _b;
+    const errors = new Array();
+    if (opts.noLib !== ENFORCED_OPTIONS.noLib) {
+        errors.push(`${y(`"noLib"`)} must be ${y(`true`)}`);
+    }
+    if (opts.strict !== ENFORCED_OPTIONS.strict) {
+        errors.push(`${y(`"strict"`)} must be ${y(`true`)}`);
+    }
+    if (opts.target !== ENFORCED_OPTIONS.target) {
+    }
+    if (opts.module !== ENFORCED_OPTIONS.module) {
+        errors.push(`${y(`"module"`)} must be ${y(`commonjs`)}`);
+    }
+    if (opts.moduleDetection !== ENFORCED_OPTIONS.moduleDetection) {
+        errors.push(`${y(`"moduleDetection"`)} must be ${y(`"force"`)}`);
+    }
+    if (opts.moduleResolution !== ENFORCED_OPTIONS.moduleResolution) {
+        errors.push(`${y(`"moduleResolution"`)} must be ${y(`"Node"`)}`);
+    }
+    if (opts.allowSyntheticDefaultImports !== ENFORCED_OPTIONS.allowSyntheticDefaultImports) {
+        errors.push(`${y(`"allowSyntheticDefaultImports"`)} must be ${y(`true`)}`);
+    }
+    if (opts.typeRoots === undefined || !validateTypeRoots(projectPath, opts.typeRoots)) {
+        errors.push(`${y(`"typeRoots"`)} must contain a path to ${y(`${constants_1.NODE_MODULES}/${constants_1.RBXTS_SCOPE}`)} (e.g., "node_modules/@rbxts" or "../../node_modules/@rbxts")`);
+    }
+    for (const typesLocation of (_a = opts.types) !== null && _a !== void 0 ? _a : []) {
+        const typeRoots = (_b = opts.typeRoots) !== null && _b !== void 0 ? _b : ["node_modules/@rbxts"];
+        if (!typeRoots.some(typeRoot => {
+            const typesPath = path_1.default.resolve(projectPath, typeRoot, typesLocation);
+            return fs_1.default.existsSync(typesPath) || fs_1.default.existsSync(typesPath + constants_1.DTS_EXT);
+        })) {
+            errors.push(`${y(`"types"`)} ${y(typesLocation)} were not found. Make sure the path is relative to \`typeRoots\``);
+        }
+    }
+    if (opts.rootDir === undefined && opts.rootDirs === undefined) {
+        errors.push(`${y(`"rootDir"`)} or ${y(`"rootDirs"`)} must be defined`);
+    }
+    if (opts.outDir === undefined) {
+        errors.push(`${y(`"outDir"`)} must be defined`);
+    }
+    if (opts.importsNotUsedAsValues !== undefined) {
+        const suggestedValue = opts.importsNotUsedAsValues === typescript_1.default.ImportsNotUsedAsValues.Preserve ? "true" : "false";
+        errors.push(`${y(`"importsNotUsedAsValues"`)} is no longer supported, use ${y(`"verbatimModuleSyntax": ${suggestedValue}`)} instead`);
+    }
+    if (errors.length > 0) {
+        throw new ProjectError_1.ProjectError([
+            `Invalid "tsconfig.json" configuration!`,
+            `https://roblox-ts.com/docs/quick-start#project-folder-setup`,
+            errors.map(e => `- ${e}\n`).join(""),
+        ].join("\n"));
+    }
+}
+//# sourceMappingURL=validateCompilerOptions.js.map

package/out/Project/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./classes/VirtualProject";
+export * from "./functions/cleanup";
+export * from "./functions/createProjectData";
+export type { ProjectData, ProjectOptions, ReferencedProjectInfo } from "../Shared/types";

package/out/Project/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./classes/VirtualProject"), exports);
+__exportStar(require("./functions/cleanup"), exports);
+__exportStar(require("./functions/createProjectData"), exports);
+//# sourceMappingURL=index.js.map

package/out/Project/preEmitDiagnostics/fileUsesCommentDirectives.d.ts

@@ -0,0 +1,3 @@
+import { ProjectData } from "../../Shared/types";
+import ts from "typescript";
+export declare function fileUsesCommentDirectives(data: ProjectData, sourceFile: ts.SourceFile): ts.Diagnostic[];

package/out/Project/preEmitDiagnostics/fileUsesCommentDirectives.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileUsesCommentDirectives = fileUsesCommentDirectives;
+const diagnostics_1 = require("../../Shared/diagnostics");
+function fileUsesCommentDirectives(data, sourceFile) {
+    var _a;
+    if (data.projectOptions.allowCommentDirectives) {
+        return [];
+    }
+    const diagnostics = new Array();
+    for (const commentDirective of (_a = sourceFile.commentDirectives) !== null && _a !== void 0 ? _a : []) {
+        diagnostics.push(diagnostics_1.errors.noCommentDirectives({
+            sourceFile,
+            range: commentDirective.range,
+        }));
+    }
+    const tsNoCheckPragma = sourceFile.pragmas.get("ts-nocheck");
+    if (tsNoCheckPragma) {
+        for (const pragma of Array.isArray(tsNoCheckPragma) ? tsNoCheckPragma : [tsNoCheckPragma]) {
+            diagnostics.push(diagnostics_1.errors.noCommentDirectives({
+                sourceFile,
+                range: pragma.range,
+            }));
+        }
+    }
+    return diagnostics;
+}
+//# sourceMappingURL=fileUsesCommentDirectives.js.map

package/out/Project/transformers/builtin/transformPaths.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+export interface TsTransformPathsConfig {
+    useRootDirs?: boolean;
+}
+export default function transformer(program: ts.Program, config: TsTransformPathsConfig): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile | ts.Bundle) => ts.SourceFile | ts.Bundle;