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

package/lib/rpc/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcExitError = exports.getRpcWorkerData = exports.createRpcWorker = exports.wrapRpc = exports.exposeRpc = void 0;
+var expose_rpc_1 = require("./expose-rpc");
+Object.defineProperty(exports, "exposeRpc", { enumerable: true, get: function () { return expose_rpc_1.exposeRpc; } });
+var wrap_rpc_1 = require("./wrap-rpc");
+Object.defineProperty(exports, "wrapRpc", { enumerable: true, get: function () { return wrap_rpc_1.wrapRpc; } });
+var rpc_worker_1 = require("./rpc-worker");
+Object.defineProperty(exports, "createRpcWorker", { enumerable: true, get: function () { return rpc_worker_1.createRpcWorker; } });
+Object.defineProperty(exports, "getRpcWorkerData", { enumerable: true, get: function () { return rpc_worker_1.getRpcWorkerData; } });
+var rpc_error_1 = require("./rpc-error");
+Object.defineProperty(exports, "RpcExitError", { enumerable: true, get: function () { return rpc_error_1.RpcExitError; } });

package/lib/rpc/rpc-error.d.ts

@@ -0,0 +1,6 @@
+declare class RpcExitError extends Error {
+    readonly code?: string | number | null | undefined;
+    readonly signal?: string | null | undefined;
+    constructor(message: string, code?: string | number | null | undefined, signal?: string | null | undefined);
+}
+export { RpcExitError };

package/lib/rpc/rpc-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcExitError = void 0;
+class RpcExitError extends Error {
+    constructor(message, code, signal) {
+        super(message);
+        this.code = code;
+        this.signal = signal;
+        this.name = 'RpcExitError';
+    }
+}
+exports.RpcExitError = RpcExitError;

package/lib/rpc/rpc-worker.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'child_process';
+import type { RpcMethod, RpcRemoteMethod } from './types';
+interface RpcWorkerBase {
+    connect(): void;
+    terminate(): void;
+    readonly connected: boolean;
+    readonly process: ChildProcess | undefined;
+}
+type RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorkerBase & RpcRemoteMethod<T>;
+declare function createRpcWorker<T extends RpcMethod>(modulePath: string, data: unknown, memoryLimit?: number): RpcWorker<T>;
+declare function getRpcWorkerData(): unknown;
+export { createRpcWorker, getRpcWorkerData, RpcWorker };

package/lib/rpc/rpc-worker.js

@@ -0,0 +1,83 @@
+"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.getRpcWorkerData = exports.createRpcWorker = void 0;
+const child_process = __importStar(require("child_process"));
+const process = __importStar(require("process"));
+const wrap_rpc_1 = require("./wrap-rpc");
+const WORKER_DATA_ENV_KEY = 'WORKER_DATA';
+function createRpcWorker(modulePath, data, memoryLimit) {
+    const options = {
+        env: Object.assign(Object.assign({}, process.env), { [WORKER_DATA_ENV_KEY]: JSON.stringify(data || {}) }),
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        serialization: 'advanced',
+    };
+    if (memoryLimit) {
+        options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+    }
+    let childProcess;
+    let remoteMethod;
+    const worker = {
+        connect() {
+            if (childProcess && !childProcess.connected) {
+                childProcess.kill('SIGTERM');
+                childProcess = undefined;
+                remoteMethod = undefined;
+            }
+            if (!(childProcess === null || childProcess === void 0 ? void 0 : childProcess.connected)) {
+                childProcess = child_process.fork(modulePath, options);
+                remoteMethod = (0, wrap_rpc_1.wrapRpc)(childProcess);
+            }
+        },
+        terminate() {
+            if (childProcess) {
+                childProcess.kill('SIGTERM');
+                childProcess = undefined;
+                remoteMethod = undefined;
+            }
+        },
+        get connected() {
+            return Boolean(childProcess === null || childProcess === void 0 ? void 0 : childProcess.connected);
+        },
+        get process() {
+            return childProcess;
+        },
+    };
+    return Object.assign((...args) => {
+        if (!worker.connected) {
+            // try to auto-connect
+            worker.connect();
+        }
+        if (!remoteMethod) {
+            return Promise.reject('Worker is not connected - cannot perform RPC.');
+        }
+        return remoteMethod(...args);
+    }, worker);
+}
+exports.createRpcWorker = createRpcWorker;
+function getRpcWorkerData() {
+    return JSON.parse(process.env[WORKER_DATA_ENV_KEY] || '{}');
+}
+exports.getRpcWorkerData = getRpcWorkerData;

package/lib/rpc/types.d.ts

@@ -0,0 +1,19 @@
+interface RpcCallMessage {
+    type: 'call';
+    id: string;
+    args: unknown[];
+}
+interface RpcResolveMessage {
+    type: 'resolve';
+    id: string;
+    value: unknown;
+}
+interface RpcRejectMessage {
+    type: 'reject';
+    id: string;
+    error: unknown;
+}
+type RpcMessage = RpcCallMessage | RpcResolveMessage | RpcRejectMessage;
+type RpcMethod = (...args: any[]) => any;
+type RpcRemoteMethod<T extends RpcMethod> = T extends (...args: infer A) => infer R ? R extends Promise<any> ? (...args: A) => R : (...args: A) => Promise<R> : (...args: unknown[]) => Promise<unknown>;
+export { RpcCallMessage, RpcResolveMessage, RpcRejectMessage, RpcMessage, RpcMethod, RpcRemoteMethod, };

package/lib/rpc/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/rpc/wrap-rpc.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'child_process';
+import type { RpcRemoteMethod } from './types';
+export declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess): RpcRemoteMethod<T>;

package/lib/rpc/wrap-rpc.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapRpc = void 0;
+const controlled_promise_1 = require("../utils/async/controlled-promise");
+const rpc_error_1 = require("./rpc-error");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapRpc(childProcess) {
+    return ((...args) => __awaiter(this, void 0, void 0, function* () {
+        if (!childProcess.send) {
+            throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+        }
+        else if (!childProcess.connected) {
+            throw new Error(`Process ${childProcess.pid} doesn't have open IPC channels`);
+        }
+        const id = uuid();
+        // create promises
+        const { promise: resultPromise, resolve: resolveResult, reject: rejectResult, } = (0, controlled_promise_1.createControlledPromise)();
+        const { promise: sendPromise, resolve: resolveSend, reject: rejectSend, } = (0, controlled_promise_1.createControlledPromise)();
+        const handleMessage = (message) => {
+            if ((message === null || message === void 0 ? void 0 : message.id) === id) {
+                if (message.type === 'resolve') {
+                    // assume the contract is respected
+                    resolveResult(message.value);
+                    removeHandlers();
+                }
+                else if (message.type === 'reject') {
+                    rejectResult(message.error);
+                    removeHandlers();
+                }
+            }
+        };
+        const handleClose = (code, signal) => {
+            rejectResult(new rpc_error_1.RpcExitError(code
+                ? `Process ${childProcess.pid} exited with code ${code}` +
+                    (signal ? ` [${signal}]` : '')
+                : `Process ${childProcess.pid} exited` + (signal ? ` [${signal}]` : ''), code, signal));
+            removeHandlers();
+        };
+        // to prevent event handler leaks
+        const removeHandlers = () => {
+            childProcess.off('message', handleMessage);
+            childProcess.off('close', handleClose);
+        };
+        // add event listeners
+        childProcess.on('message', handleMessage);
+        childProcess.on('close', handleClose);
+        // send call message
+        childProcess.send({
+            type: 'call',
+            id,
+            args,
+        }, (error) => {
+            if (error) {
+                rejectSend(error);
+                removeHandlers();
+            }
+            else {
+                resolveSend(undefined);
+            }
+        });
+        return sendPromise.then(() => resultPromise);
+    }));
+}
+exports.wrapRpc = wrapRpc;
+function uuid() {
+    return new Array(4)
+        .fill(0)
+        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+        .join('-');
+}

package/lib/typescript/type-script-config-overwrite.d.ts

@@ -0,0 +1,12 @@
+interface TypeScriptConfigOverwrite {
+    extends?: string;
+    compilerOptions?: any;
+    include?: string[];
+    exclude?: string[];
+    files?: string[];
+    references?: {
+        path: string;
+        prepend?: boolean;
+    }[];
+}
+export { TypeScriptConfigOverwrite };

package/lib/typescript/type-script-config-overwrite.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typescript/type-script-diagnostics-options.d.ts

@@ -0,0 +1,7 @@
+interface TypeScriptDiagnosticsOptions {
+    syntactic: boolean;
+    semantic: boolean;
+    declaration: boolean;
+    global: boolean;
+}
+export { TypeScriptDiagnosticsOptions };

package/lib/typescript/type-script-diagnostics-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typescript/type-script-support.d.ts

@@ -0,0 +1,3 @@
+import type { TypeScriptWorkerConfig } from './type-script-worker-config';
+declare function assertTypeScriptSupport(config: TypeScriptWorkerConfig): void;
+export { assertTypeScriptSupport };

package/lib/typescript/type-script-support.js

@@ -0,0 +1,67 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertTypeScriptSupport = void 0;
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const semver = __importStar(require("semver"));
+function assertTypeScriptSupport(config) {
+    let typescriptVersion;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        typescriptVersion = require(config.typescriptPath).version;
+    }
+    catch (error) {
+        // silent catch
+    }
+    if (!typescriptVersion) {
+        throw new Error('When you use ForkTsCheckerWebpackPlugin with typescript reporter enabled, you must install `typescript` package.');
+    }
+    if (semver.lt(typescriptVersion, '3.6.0')) {
+        throw new Error([
+            `ForkTsCheckerWebpackPlugin cannot use the current typescript version of ${typescriptVersion}.`,
+            'The minimum required version is 3.6.0.',
+        ].join(os_1.default.EOL));
+    }
+    if (config.build && semver.lt(typescriptVersion, '3.8.0')) {
+        throw new Error([
+            `ForkTsCheckerWebpackPlugin doesn't support build option for the current typescript version of ${typescriptVersion}.`,
+            'The minimum required version is 3.8.0.',
+        ].join(os_1.default.EOL));
+    }
+    if (!fs_extra_1.default.existsSync(config.configFile)) {
+        throw new Error([
+            `Cannot find the "${config.configFile}" file.`,
+            `Please check webpack and ForkTsCheckerWebpackPlugin configuration.`,
+            `Possible errors:`,
+            '  - wrong `context` directory in webpack configuration (if `configFile` is not set or is a relative path in the fork plugin configuration)',
+            '  - wrong `typescript.configFile` path in the plugin configuration (should be a relative or absolute path)',
+        ].join(os_1.default.EOL));
+    }
+}
+exports.assertTypeScriptSupport = assertTypeScriptSupport;

package/lib/typescript/type-script-worker-config.d.ts

@@ -0,0 +1,17 @@
+import type * as webpack from 'webpack';
+import type { TypeScriptConfigOverwrite } from './type-script-config-overwrite';
+import type { TypeScriptDiagnosticsOptions } from './type-script-diagnostics-options';
+import type { TypeScriptWorkerOptions } from './type-script-worker-options';
+interface TypeScriptWorkerConfig {
+    memoryLimit: number;
+    configFile: string;
+    configOverwrite: TypeScriptConfigOverwrite;
+    build: boolean;
+    context: string;
+    mode: 'readonly' | 'write-dts' | 'write-tsbuildinfo' | 'write-references';
+    diagnosticOptions: TypeScriptDiagnosticsOptions;
+    profile: boolean;
+    typescriptPath: string;
+}
+declare function createTypeScriptWorkerConfig(compiler: webpack.Compiler, options: TypeScriptWorkerOptions | undefined): TypeScriptWorkerConfig;
+export { createTypeScriptWorkerConfig, TypeScriptWorkerConfig };

package/lib/typescript/type-script-worker-config.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeScriptWorkerConfig = void 0;
+const path_1 = __importDefault(require("path"));
+function createTypeScriptWorkerConfig(compiler, options) {
+    let configFile = (options === null || options === void 0 ? void 0 : options.configFile) || 'tsconfig.json';
+    // ensure that `configFile` is an absolute normalized path
+    configFile = path_1.default.normalize(path_1.default.isAbsolute(configFile)
+        ? configFile
+        : path_1.default.resolve(compiler.options.context || process.cwd(), configFile));
+    const optionsAsObject = typeof options === 'object' ? options : {};
+    const typescriptPath = optionsAsObject.typescriptPath || require.resolve('typescript');
+    return Object.assign(Object.assign({ memoryLimit: 2048, build: false, mode: optionsAsObject.build ? 'write-tsbuildinfo' : 'readonly', profile: false }, optionsAsObject), { configFile: configFile, configOverwrite: optionsAsObject.configOverwrite || {}, context: optionsAsObject.context || path_1.default.dirname(configFile), diagnosticOptions: Object.assign({ syntactic: false, semantic: true, declaration: false, global: false }, (optionsAsObject.diagnosticOptions || {})), typescriptPath: typescriptPath });
+}
+exports.createTypeScriptWorkerConfig = createTypeScriptWorkerConfig;

package/lib/typescript/type-script-worker-options.d.ts

@@ -0,0 +1,14 @@
+import type { TypeScriptConfigOverwrite } from './type-script-config-overwrite';
+import type { TypeScriptDiagnosticsOptions } from './type-script-diagnostics-options';
+type TypeScriptWorkerOptions = {
+    memoryLimit?: number;
+    configFile?: string;
+    configOverwrite?: TypeScriptConfigOverwrite;
+    context?: string;
+    build?: boolean;
+    mode?: 'readonly' | 'write-tsbuildinfo' | 'write-dts' | 'write-references';
+    diagnosticOptions?: Partial<TypeScriptDiagnosticsOptions>;
+    profile?: boolean;
+    typescriptPath?: string;
+};
+export { TypeScriptWorkerOptions };

package/lib/typescript/type-script-worker-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/typescript/worker/get-dependencies-worker.d.ts

@@ -0,0 +1,5 @@
+import type { FilesChange } from '../../files-change';
+import type { FilesMatch } from '../../files-match';
+declare const getDependenciesWorker: (change: FilesChange) => FilesMatch;
+export type GetDependenciesWorker = typeof getDependenciesWorker;
+export {};

package/lib/typescript/worker/get-dependencies-worker.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpc_1 = require("../../rpc");
+const config_1 = require("./lib/config");
+const dependencies_1 = require("./lib/dependencies");
+const system_1 = require("./lib/system");
+const getDependenciesWorker = (change) => {
+    system_1.system.invalidateCache();
+    if ((0, config_1.didConfigFileChanged)(change) || (0, config_1.didDependenciesProbablyChanged)((0, dependencies_1.getDependencies)(), change)) {
+        (0, config_1.invalidateConfig)();
+        (0, dependencies_1.invalidateDependencies)();
+    }
+    return (0, dependencies_1.getDependencies)();
+};
+(0, rpc_1.exposeRpc)(getDependenciesWorker);

package/lib/typescript/worker/get-issues-worker.d.ts

@@ -0,0 +1,5 @@
+import type { FilesChange } from '../../files-change';
+import type { Issue } from '../../issue';
+declare const getIssuesWorker: (change: FilesChange, watching: boolean) => Promise<Issue[]>;
+export type GetIssuesWorker = typeof getIssuesWorker;
+export {};

package/lib/typescript/worker/get-issues-worker.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpc_1 = require("../../rpc");
+const artifacts_1 = require("./lib/artifacts");
+const config_1 = require("./lib/config");
+const dependencies_1 = require("./lib/dependencies");
+const diagnostics_1 = require("./lib/diagnostics");
+const performance_1 = require("./lib/performance");
+const program_1 = require("./lib/program/program");
+const solution_builder_1 = require("./lib/program/solution-builder");
+const watch_program_1 = require("./lib/program/watch-program");
+const system_1 = require("./lib/system");
+const tracing_1 = require("./lib/tracing");
+const tsbuildinfo_1 = require("./lib/tsbuildinfo");
+const worker_config_1 = require("./lib/worker-config");
+const getIssuesWorker = (change, watching) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    system_1.system.invalidateCache();
+    if ((0, config_1.didConfigFileChanged)(change)) {
+        (0, config_1.invalidateConfig)();
+        (0, dependencies_1.invalidateDependencies)();
+        (0, artifacts_1.invalidateArtifacts)();
+        (0, diagnostics_1.invalidateDiagnostics)();
+        (0, program_1.invalidateProgram)(true);
+        (0, watch_program_1.invalidateWatchProgram)(true);
+        (0, solution_builder_1.invalidateSolutionBuilder)(true);
+        (0, tsbuildinfo_1.invalidateTsBuildInfo)();
+    }
+    else if ((0, config_1.didDependenciesProbablyChanged)((0, dependencies_1.getDependencies)(), change)) {
+        (0, config_1.invalidateConfig)();
+        (0, dependencies_1.invalidateDependencies)();
+        (0, artifacts_1.invalidateArtifacts)();
+        if ((0, config_1.didRootFilesChanged)()) {
+            (0, watch_program_1.invalidateWatchProgramRootFileNames)();
+            (0, solution_builder_1.invalidateSolutionBuilder)();
+        }
+    }
+    (0, artifacts_1.registerArtifacts)();
+    (0, performance_1.enablePerformanceIfNeeded)();
+    const parseConfigIssues = (0, config_1.getParseConfigIssues)();
+    if (parseConfigIssues.length) {
+        // report config parse issues and exit
+        return parseConfigIssues;
+    }
+    // use proper implementation based on the config
+    if (worker_config_1.config.build) {
+        (0, solution_builder_1.useSolutionBuilder)();
+    }
+    else if (watching) {
+        (0, watch_program_1.useWatchProgram)();
+    }
+    else {
+        (0, program_1.useProgram)();
+    }
+    // simulate file system events
+    (_a = change.changedFiles) === null || _a === void 0 ? void 0 : _a.forEach((changedFile) => {
+        system_1.system === null || system_1.system === void 0 ? void 0 : system_1.system.invokeFileChanged(changedFile);
+    });
+    (_b = change.deletedFiles) === null || _b === void 0 ? void 0 : _b.forEach((deletedFile) => {
+        system_1.system === null || system_1.system === void 0 ? void 0 : system_1.system.invokeFileDeleted(deletedFile);
+    });
+    // wait for all queued events to be processed
+    yield system_1.system.waitForQueued();
+    // retrieve all collected diagnostics as normalized issues
+    const issues = (0, diagnostics_1.getIssues)();
+    (0, tracing_1.dumpTracingLegendIfNeeded)();
+    (0, performance_1.printPerformanceMeasuresIfNeeded)();
+    (0, performance_1.disablePerformanceIfNeeded)();
+    return issues;
+});
+(0, rpc_1.exposeRpc)(getIssuesWorker);

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

@@ -0,0 +1,4 @@
+import type { FilesMatch } from '../../../files-match';
+export declare function getArtifacts(force?: boolean): FilesMatch;
+export declare function invalidateArtifacts(): void;
+export declare function registerArtifacts(): void;

package/lib/typescript/worker/lib/artifacts.js

@@ -0,0 +1,94 @@
+"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.registerArtifacts = exports.invalidateArtifacts = exports.getArtifacts = void 0;
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const system_1 = require("./system");
+const tsbuildinfo_1 = require("./tsbuildinfo");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+let artifacts;
+function getArtifacts(force = false) {
+    if (!artifacts || force) {
+        const parsedConfig = (0, config_1.getParsedConfig)();
+        artifacts = getArtifactsWorker(parsedConfig, worker_config_1.config.context);
+    }
+    return artifacts;
+}
+exports.getArtifacts = getArtifacts;
+function invalidateArtifacts() {
+    artifacts = undefined;
+}
+exports.invalidateArtifacts = invalidateArtifacts;
+function registerArtifacts() {
+    system_1.system.setArtifacts(getArtifacts());
+}
+exports.registerArtifacts = registerArtifacts;
+function getArtifactsWorker(parsedConfig, configFileContext, processedConfigFiles = []) {
+    const files = new Set();
+    const dirs = new Set();
+    if (parsedConfig.fileNames.length > 0) {
+        if (parsedConfig.options.outFile) {
+            files.add(path.resolve(configFileContext, parsedConfig.options.outFile));
+        }
+        const tsBuildInfoPath = (0, tsbuildinfo_1.getTsBuildInfoEmitPath)(parsedConfig.options);
+        if (tsBuildInfoPath) {
+            files.add(path.resolve(configFileContext, tsBuildInfoPath));
+        }
+        if (parsedConfig.options.outDir) {
+            dirs.add(path.resolve(configFileContext, parsedConfig.options.outDir));
+        }
+    }
+    for (const projectReference of parsedConfig.projectReferences || []) {
+        const configFile = typescript_1.typescript.resolveProjectReferencePath(projectReference);
+        if (processedConfigFiles.includes(configFile)) {
+            // handle circular dependencies
+            continue;
+        }
+        const parsedConfig = (0, config_1.parseConfig)(configFile, path.dirname(configFile));
+        const childArtifacts = getArtifactsWorker(parsedConfig, configFileContext, [
+            ...processedConfigFiles,
+            configFile,
+        ]);
+        childArtifacts.files.forEach((file) => {
+            files.add(file);
+        });
+        childArtifacts.dirs.forEach((dir) => {
+            dirs.add(dir);
+        });
+    }
+    const extensions = [
+        typescript_1.typescript.Extension.Dts,
+        typescript_1.typescript.Extension.Js,
+        typescript_1.typescript.Extension.TsBuildInfo,
+    ];
+    return {
+        files: Array.from(files).map((file) => path.normalize(file)),
+        dirs: Array.from(dirs).map((dir) => path.normalize(dir)),
+        excluded: [],
+        extensions,
+    };
+}

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

@@ -0,0 +1,15 @@
+import type * as ts from 'typescript';
+import type { FilesChange } from '../../../files-change';
+import type { FilesMatch } from '../../../files-match';
+import type { Issue } from '../../../issue';
+export declare function parseConfig(configFileName: string, configFileContext: string): ts.ParsedCommandLine;
+export declare function getParseConfigIssues(): Issue[];
+export declare function getParsedConfig(force?: boolean): ts.ParsedCommandLine;
+export declare function parseNextConfig(): readonly [ts.ParsedCommandLine | undefined, ts.ParsedCommandLine];
+export declare function invalidateConfig(): void;
+export declare function getConfigFilePathFromCompilerOptions(compilerOptions: ts.CompilerOptions): string;
+export declare function getConfigFilePathFromProgram(program: ts.Program): string;
+export declare function getConfigFilePathFromBuilderProgram(builderProgram: ts.BuilderProgram): string;
+export declare function didConfigFileChanged({ changedFiles, deletedFiles }: FilesChange): boolean;
+export declare function didDependenciesProbablyChanged(dependencies: FilesMatch, { changedFiles, deletedFiles }: FilesChange): boolean;
+export declare function didRootFilesChanged(): boolean | undefined;