@depup/fork-ts-checker-webpack-plugin 9.1.0-depup.0

package/lib/typescript/worker/lib/file-system/real-file-system.js

@@ -0,0 +1,191 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realFileSystem = void 0;
+const path_1 = require("path");
+const fs = __importStar(require("fs-extra"));
+const existsCache = new Map();
+const readStatsCache = new Map();
+const readFileCache = new Map();
+const readDirCache = new Map();
+const realPathCache = new Map();
+/**
+ * It's an implementation of the FileSystem interface which reads and writes directly to the real file system.
+ */
+exports.realFileSystem = {
+    exists(path) {
+        return exists(getRealPath(path));
+    },
+    readFile(path, encoding) {
+        return readFile(getRealPath(path), encoding);
+    },
+    readDir(path) {
+        return readDir(getRealPath(path));
+    },
+    readStats(path) {
+        return readStats(getRealPath(path));
+    },
+    realPath(path) {
+        return getRealPath(path);
+    },
+    normalizePath(path) {
+        return (0, path_1.normalize)(path);
+    },
+    writeFile(path, data) {
+        writeFile(getRealPath(path), data);
+    },
+    deleteFile(path) {
+        deleteFile(getRealPath(path));
+    },
+    createDir(path) {
+        createDir(getRealPath(path));
+    },
+    updateTimes(path, atime, mtime) {
+        updateTimes(getRealPath(path), atime, mtime);
+    },
+    clearCache() {
+        existsCache.clear();
+        readStatsCache.clear();
+        readFileCache.clear();
+        readDirCache.clear();
+        realPathCache.clear();
+    },
+};
+// read methods
+function exists(path) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!existsCache.has(normalizedPath)) {
+        existsCache.set(normalizedPath, fs.existsSync(normalizedPath));
+    }
+    return !!existsCache.get(normalizedPath);
+}
+function readStats(path) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!readStatsCache.has(normalizedPath)) {
+        if (exists(normalizedPath)) {
+            readStatsCache.set(normalizedPath, fs.statSync(normalizedPath));
+        }
+    }
+    return readStatsCache.get(normalizedPath);
+}
+function readFile(path, encoding) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!readFileCache.has(normalizedPath)) {
+        const stats = readStats(normalizedPath);
+        if (stats && stats.isFile()) {
+            readFileCache.set(normalizedPath, fs.readFileSync(normalizedPath, { encoding: encoding }).toString());
+        }
+        else {
+            readFileCache.set(normalizedPath, undefined);
+        }
+    }
+    return readFileCache.get(normalizedPath);
+}
+function readDir(path) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!readDirCache.has(normalizedPath)) {
+        const stats = readStats(normalizedPath);
+        if (stats && stats.isDirectory()) {
+            readDirCache.set(normalizedPath, fs.readdirSync(normalizedPath, { withFileTypes: true }));
+        }
+        else {
+            readDirCache.set(normalizedPath, []);
+        }
+    }
+    return readDirCache.get(normalizedPath) || [];
+}
+function getRealPath(path) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!realPathCache.has(normalizedPath)) {
+        let base = normalizedPath;
+        let nested = '';
+        while (base !== (0, path_1.dirname)(base)) {
+            if (exists(base)) {
+                realPathCache.set(normalizedPath, (0, path_1.normalize)((0, path_1.join)(fs.realpathSync(base), nested)));
+                break;
+            }
+            nested = (0, path_1.join)((0, path_1.basename)(base), nested);
+            base = (0, path_1.dirname)(base);
+        }
+    }
+    return realPathCache.get(normalizedPath) || normalizedPath;
+}
+function createDir(path) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    fs.mkdirSync(normalizedPath, { recursive: true });
+    // update cache
+    existsCache.set(normalizedPath, true);
+    if (readDirCache.has((0, path_1.dirname)(normalizedPath))) {
+        readDirCache.delete((0, path_1.dirname)(normalizedPath));
+    }
+    if (readStatsCache.has(normalizedPath)) {
+        readStatsCache.delete(normalizedPath);
+    }
+}
+function writeFile(path, data) {
+    const normalizedPath = (0, path_1.normalize)(path);
+    if (!exists((0, path_1.dirname)(normalizedPath))) {
+        createDir((0, path_1.dirname)(normalizedPath));
+    }
+    fs.writeFileSync(normalizedPath, data);
+    // update cache
+    existsCache.set(normalizedPath, true);
+    if (readDirCache.has((0, path_1.dirname)(normalizedPath))) {
+        readDirCache.delete((0, path_1.dirname)(normalizedPath));
+    }
+    if (readStatsCache.has(normalizedPath)) {
+        readStatsCache.delete(normalizedPath);
+    }
+    if (readFileCache.has(normalizedPath)) {
+        readFileCache.delete(normalizedPath);
+    }
+}
+function deleteFile(path) {
+    if (exists(path)) {
+        const normalizedPath = (0, path_1.normalize)(path);
+        fs.unlinkSync(normalizedPath);
+        // update cache
+        existsCache.set(normalizedPath, false);
+        if (readDirCache.has((0, path_1.dirname)(normalizedPath))) {
+            readDirCache.delete((0, path_1.dirname)(normalizedPath));
+        }
+        if (readStatsCache.has(normalizedPath)) {
+            readStatsCache.delete(normalizedPath);
+        }
+        if (readFileCache.has(normalizedPath)) {
+            readFileCache.delete(normalizedPath);
+        }
+    }
+}
+function updateTimes(path, atime, mtime) {
+    if (exists(path)) {
+        const normalizedPath = (0, path_1.normalize)(path);
+        fs.utimesSync((0, path_1.normalize)(path), atime, mtime);
+        // update cache
+        if (readStatsCache.has(normalizedPath)) {
+            readStatsCache.delete(normalizedPath);
+        }
+    }
+}

package/lib/typescript/worker/lib/host/compiler-host.d.ts

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare function createCompilerHost(parsedConfig: ts.ParsedCommandLine): ts.CompilerHost;

package/lib/typescript/worker/lib/host/compiler-host.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerHost = void 0;
+const system_1 = require("../system");
+const typescript_1 = require("../typescript");
+function createCompilerHost(parsedConfig) {
+    const baseCompilerHost = typescript_1.typescript.createCompilerHost(parsedConfig.options);
+    return Object.assign(Object.assign({}, baseCompilerHost), { fileExists: system_1.system.fileExists, readFile: system_1.system.readFile, directoryExists: system_1.system.directoryExists, getDirectories: system_1.system.getDirectories, realpath: system_1.system.realpath });
+}
+exports.createCompilerHost = createCompilerHost;

package/lib/typescript/worker/lib/host/watch-compiler-host.d.ts

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare function createWatchCompilerHost<TProgram extends ts.BuilderProgram>(parsedConfig: ts.ParsedCommandLine, createProgram?: ts.CreateProgram<TProgram>, reportDiagnostic?: ts.DiagnosticReporter, reportWatchStatus?: ts.WatchStatusReporter, afterProgramCreate?: (program: TProgram) => void): ts.WatchCompilerHostOfFilesAndCompilerOptions<TProgram>;

package/lib/typescript/worker/lib/host/watch-compiler-host.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchCompilerHost = void 0;
+const system_1 = require("../system");
+const typescript_1 = require("../typescript");
+function createWatchCompilerHost(parsedConfig, createProgram, reportDiagnostic, reportWatchStatus, afterProgramCreate) {
+    const baseWatchCompilerHost = typescript_1.typescript.createWatchCompilerHost(parsedConfig.fileNames, parsedConfig.options, system_1.system, createProgram, reportDiagnostic, reportWatchStatus, parsedConfig.projectReferences);
+    return Object.assign(Object.assign({}, baseWatchCompilerHost), { createProgram(rootNames, options, compilerHost, oldProgram, configFileParsingDiagnostics, projectReferences) {
+            return baseWatchCompilerHost.createProgram(rootNames, options, compilerHost, oldProgram, configFileParsingDiagnostics, projectReferences);
+        },
+        afterProgramCreate(program) {
+            if (afterProgramCreate) {
+                afterProgramCreate(program);
+            }
+        },
+        onWatchStatusChange() {
+            // do nothing
+        }, watchFile: system_1.system.watchFile, watchDirectory: system_1.system.watchDirectory, setTimeout: system_1.system.setTimeout, clearTimeout: system_1.system.clearTimeout, fileExists: system_1.system.fileExists, readFile: system_1.system.readFile, directoryExists: system_1.system.directoryExists, getDirectories: system_1.system.getDirectories, realpath: system_1.system.realpath });
+}
+exports.createWatchCompilerHost = createWatchCompilerHost;

package/lib/typescript/worker/lib/host/watch-solution-builder-host.d.ts

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare function createWatchSolutionBuilderHost<TProgram extends ts.BuilderProgram>(parsedConfig: ts.ParsedCommandLine, createProgram?: ts.CreateProgram<TProgram>, reportDiagnostic?: ts.DiagnosticReporter, reportWatchStatus?: ts.WatchStatusReporter, reportSolutionBuilderStatus?: (diagnostic: ts.Diagnostic) => void, afterProgramCreate?: (program: TProgram) => void, afterProgramEmitAndDiagnostics?: (program: TProgram) => void): ts.SolutionBuilderWithWatchHost<TProgram>;

package/lib/typescript/worker/lib/host/watch-solution-builder-host.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchSolutionBuilderHost = void 0;
+const system_1 = require("../system");
+const typescript_1 = require("../typescript");
+const watch_compiler_host_1 = require("./watch-compiler-host");
+function createWatchSolutionBuilderHost(parsedConfig, createProgram, reportDiagnostic, reportWatchStatus, reportSolutionBuilderStatus, afterProgramCreate, afterProgramEmitAndDiagnostics) {
+    const controlledWatchCompilerHost = (0, watch_compiler_host_1.createWatchCompilerHost)(parsedConfig, createProgram, reportDiagnostic, reportWatchStatus, afterProgramCreate);
+    return Object.assign(Object.assign({}, controlledWatchCompilerHost), { reportDiagnostic(diagnostic) {
+            if (reportDiagnostic) {
+                reportDiagnostic(diagnostic);
+            }
+        },
+        reportSolutionBuilderStatus(diagnostic) {
+            if (reportSolutionBuilderStatus) {
+                reportSolutionBuilderStatus(diagnostic);
+            }
+        },
+        afterProgramEmitAndDiagnostics(program) {
+            if (afterProgramEmitAndDiagnostics) {
+                afterProgramEmitAndDiagnostics(program);
+            }
+        },
+        createDirectory(path) {
+            system_1.system.createDirectory(path);
+        },
+        writeFile(path, data) {
+            system_1.system.writeFile(path, data);
+        },
+        getModifiedTime(fileName) {
+            return system_1.system.getModifiedTime(fileName);
+        },
+        setModifiedTime(fileName, date) {
+            system_1.system.setModifiedTime(fileName, date);
+        },
+        deleteFile(fileName) {
+            system_1.system.deleteFile(fileName);
+        },
+        getParsedCommandLine(fileName) {
+            return typescript_1.typescript.getParsedCommandLineOfConfigFile(fileName, { skipLibCheck: true }, Object.assign(Object.assign({}, system_1.system), { onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+                    if (reportDiagnostic) {
+                        reportDiagnostic(diagnostic);
+                    }
+                } }));
+        } });
+}
+exports.createWatchSolutionBuilderHost = createWatchSolutionBuilderHost;

package/lib/typescript/worker/lib/performance.d.ts

@@ -0,0 +1,3 @@
+export declare function enablePerformanceIfNeeded(): void;
+export declare function disablePerformanceIfNeeded(): void;
+export declare function printPerformanceMeasuresIfNeeded(): void;

package/lib/typescript/worker/lib/performance.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printPerformanceMeasuresIfNeeded = exports.disablePerformanceIfNeeded = exports.enablePerformanceIfNeeded = void 0;
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const performance = typescript_1.typescript.performance;
+function enablePerformanceIfNeeded() {
+    var _a;
+    if (worker_config_1.config.profile) {
+        (_a = performance === null || performance === void 0 ? void 0 : performance.enable) === null || _a === void 0 ? void 0 : _a.call(performance);
+    }
+}
+exports.enablePerformanceIfNeeded = enablePerformanceIfNeeded;
+function disablePerformanceIfNeeded() {
+    var _a;
+    if (worker_config_1.config.profile) {
+        (_a = performance === null || performance === void 0 ? void 0 : performance.disable) === null || _a === void 0 ? void 0 : _a.call(performance);
+    }
+}
+exports.disablePerformanceIfNeeded = disablePerformanceIfNeeded;
+function printPerformanceMeasuresIfNeeded() {
+    var _a;
+    if (worker_config_1.config.profile) {
+        const measures = {};
+        (_a = performance === null || performance === void 0 ? void 0 : performance.forEachMeasure) === null || _a === void 0 ? void 0 : _a.call(performance, (measureName, duration) => {
+            measures[measureName] = duration;
+        });
+        console.table(measures);
+    }
+}
+exports.printPerformanceMeasuresIfNeeded = printPerformanceMeasuresIfNeeded;

package/lib/typescript/worker/lib/program/program.d.ts

@@ -0,0 +1,2 @@
+export declare function useProgram(): void;
+export declare function invalidateProgram(withHost?: boolean): void;

package/lib/typescript/worker/lib/program/program.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateProgram = exports.useProgram = void 0;
+const config_1 = require("../config");
+const diagnostics_1 = require("../diagnostics");
+const emit_1 = require("../emit");
+const compiler_host_1 = require("../host/compiler-host");
+const tracing_1 = require("../tracing");
+const typescript_1 = require("../typescript");
+let compilerHost;
+let program;
+function useProgram() {
+    const parsedConfig = (0, config_1.getParsedConfig)();
+    if (!compilerHost) {
+        compilerHost = (0, compiler_host_1.createCompilerHost)(parsedConfig);
+    }
+    if (!program) {
+        (0, tracing_1.startTracingIfNeeded)(parsedConfig.options);
+        program = typescript_1.typescript.createProgram({
+            rootNames: parsedConfig.fileNames,
+            options: parsedConfig.options,
+            projectReferences: parsedConfig.projectReferences,
+            host: compilerHost,
+        });
+    }
+    (0, diagnostics_1.updateDiagnostics)((0, config_1.getConfigFilePathFromProgram)(program), (0, diagnostics_1.getDiagnosticsOfProgram)(program));
+    (0, emit_1.emitDtsIfNeeded)(program);
+    (0, tracing_1.stopTracingIfNeeded)(program);
+}
+exports.useProgram = useProgram;
+function invalidateProgram(withHost = false) {
+    if (withHost) {
+        compilerHost = undefined;
+    }
+    program = undefined;
+}
+exports.invalidateProgram = invalidateProgram;

package/lib/typescript/worker/lib/program/solution-builder.d.ts

@@ -0,0 +1,2 @@
+export declare function useSolutionBuilder(): void;
+export declare function invalidateSolutionBuilder(withHost?: boolean): void;

package/lib/typescript/worker/lib/program/solution-builder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateSolutionBuilder = exports.useSolutionBuilder = void 0;
+const config_1 = require("../config");
+const diagnostics_1 = require("../diagnostics");
+const watch_solution_builder_host_1 = require("../host/watch-solution-builder-host");
+const tracing_1 = require("../tracing");
+const tsbuildinfo_1 = require("../tsbuildinfo");
+const typescript_1 = require("../typescript");
+const worker_config_1 = require("../worker-config");
+let solutionBuilderHost;
+let solutionBuilder;
+function useSolutionBuilder() {
+    if (!solutionBuilderHost) {
+        const parsedConfig = (0, config_1.getParsedConfig)();
+        solutionBuilderHost = (0, watch_solution_builder_host_1.createWatchSolutionBuilderHost)(parsedConfig, (rootNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+            if (compilerOptions) {
+                (0, tracing_1.startTracingIfNeeded)(compilerOptions);
+            }
+            return typescript_1.typescript.createSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences);
+        }, undefined, undefined, undefined, undefined, (builderProgram) => {
+            (0, diagnostics_1.updateDiagnostics)((0, config_1.getConfigFilePathFromBuilderProgram)(builderProgram), (0, diagnostics_1.getDiagnosticsOfProgram)(builderProgram));
+            (0, tsbuildinfo_1.emitTsBuildInfoIfNeeded)(builderProgram);
+            (0, tracing_1.stopTracingIfNeeded)(builderProgram);
+        });
+    }
+    if (!solutionBuilder) {
+        solutionBuilder = typescript_1.typescript.createSolutionBuilderWithWatch(solutionBuilderHost, [worker_config_1.config.configFile], { watch: true });
+        solutionBuilder.build();
+    }
+}
+exports.useSolutionBuilder = useSolutionBuilder;
+function invalidateSolutionBuilder(withHost = false) {
+    if (withHost) {
+        solutionBuilderHost = undefined;
+    }
+    solutionBuilder = undefined;
+}
+exports.invalidateSolutionBuilder = invalidateSolutionBuilder;

package/lib/typescript/worker/lib/program/watch-program.d.ts

@@ -0,0 +1,3 @@
+export declare function useWatchProgram(): void;
+export declare function invalidateWatchProgram(withHost?: boolean): void;
+export declare function invalidateWatchProgramRootFileNames(): void;

package/lib/typescript/worker/lib/program/watch-program.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateWatchProgramRootFileNames = exports.invalidateWatchProgram = exports.useWatchProgram = void 0;
+const config_1 = require("../config");
+const dependencies_1 = require("../dependencies");
+const diagnostics_1 = require("../diagnostics");
+const emit_1 = require("../emit");
+const watch_compiler_host_1 = require("../host/watch-compiler-host");
+const tracing_1 = require("../tracing");
+const tsbuildinfo_1 = require("../tsbuildinfo");
+const typescript_1 = require("../typescript");
+let watchCompilerHost;
+let watchProgram;
+let shouldUpdateRootFiles = false;
+function useWatchProgram() {
+    if (!watchCompilerHost) {
+        const parsedConfig = (0, config_1.getParsedConfig)();
+        watchCompilerHost = (0, watch_compiler_host_1.createWatchCompilerHost)(parsedConfig, (rootNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+            if (compilerOptions) {
+                (0, tracing_1.startTracingIfNeeded)(compilerOptions);
+            }
+            return typescript_1.typescript.createSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences);
+        }, undefined, undefined, (builderProgram) => {
+            (0, diagnostics_1.updateDiagnostics)((0, config_1.getConfigFilePathFromBuilderProgram)(builderProgram), (0, diagnostics_1.getDiagnosticsOfProgram)(builderProgram));
+            (0, emit_1.emitDtsIfNeeded)(builderProgram);
+            (0, tsbuildinfo_1.emitTsBuildInfoIfNeeded)(builderProgram);
+            (0, tracing_1.stopTracingIfNeeded)(builderProgram);
+        });
+        watchProgram = undefined;
+    }
+    if (!watchProgram) {
+        watchProgram = typescript_1.typescript.createWatchProgram(watchCompilerHost);
+    }
+    if (shouldUpdateRootFiles) {
+        // we have to update root files manually as don't use config file as a program input
+        watchProgram.updateRootFileNames((0, dependencies_1.getDependencies)().files);
+        shouldUpdateRootFiles = false;
+    }
+}
+exports.useWatchProgram = useWatchProgram;
+function invalidateWatchProgram(withHost = false) {
+    if (withHost) {
+        watchCompilerHost = undefined;
+    }
+    watchProgram = undefined;
+}
+exports.invalidateWatchProgram = invalidateWatchProgram;
+function invalidateWatchProgramRootFileNames() {
+    shouldUpdateRootFiles = true;
+}
+exports.invalidateWatchProgramRootFileNames = invalidateWatchProgramRootFileNames;

package/lib/typescript/worker/lib/system.d.ts

@@ -0,0 +1,19 @@
+import type * as ts from 'typescript';
+import type { FilesMatch } from '../../../files-match';
+export interface ControlledTypeScriptSystem extends ts.System {
+    invokeFileCreated(path: string): void;
+    invokeFileChanged(path: string): void;
+    invokeFileDeleted(path: string): void;
+    invalidateCache(): void;
+    getFileSize(path: string): number;
+    watchFile(path: string, callback: ts.FileWatcherCallback, pollingInterval?: number, options?: ts.WatchOptions): ts.FileWatcher;
+    watchDirectory(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean, options?: ts.WatchOptions): ts.FileWatcher;
+    getModifiedTime(path: string): Date | undefined;
+    setModifiedTime(path: string, time: Date): void;
+    deleteFile(path: string): void;
+    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
+    clearTimeout(timeoutId: any): void;
+    waitForQueued(): Promise<void>;
+    setArtifacts(artifacts: FilesMatch): void;
+}
+export declare const system: ControlledTypeScriptSystem;