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

package/lib/typescript/worker/lib/system.js

@@ -0,0 +1,232 @@
+"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.system = void 0;
+const path_1 = require("path");
+const forward_slash_1 = require("../../../utils/path/forward-slash");
+const mem_file_system_1 = require("./file-system/mem-file-system");
+const passive_file_system_1 = require("./file-system/passive-file-system");
+const real_file_system_1 = require("./file-system/real-file-system");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+const mode = worker_config_1.config.mode;
+let artifacts = {
+    files: [],
+    dirs: [],
+    excluded: [],
+    extensions: [],
+};
+let isInitialRun = true;
+// watchers
+const fileWatcherCallbacksMap = new Map();
+const directoryWatcherCallbacksMap = new Map();
+const recursiveDirectoryWatcherCallbacksMap = new Map();
+const deletedFiles = new Map();
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const timeoutCallbacks = new Set();
+// based on the ts.ignorePaths
+const ignoredPaths = ['/node_modules/.', '/.git', '/.#'];
+exports.system = Object.assign(Object.assign({}, typescript_1.typescript.sys), { useCaseSensitiveFileNames: true, realpath(path) {
+        return getReadFileSystem(path).realPath(path);
+    },
+    fileExists(path) {
+        const stats = getReadFileSystem(path).readStats(path);
+        return !!stats && stats.isFile();
+    },
+    readFile(path, encoding) {
+        return getReadFileSystem(path).readFile(path, encoding);
+    },
+    getFileSize(path) {
+        const stats = getReadFileSystem(path).readStats(path);
+        return stats ? stats.size : 0;
+    },
+    writeFile(path, data) {
+        getWriteFileSystem(path).writeFile(path, data);
+        exports.system.invokeFileChanged(path);
+    },
+    deleteFile(path) {
+        getWriteFileSystem(path).deleteFile(path);
+        exports.system.invokeFileDeleted(path);
+    },
+    directoryExists(path) {
+        var _a;
+        return Boolean((_a = getReadFileSystem(path).readStats(path)) === null || _a === void 0 ? void 0 : _a.isDirectory());
+    },
+    createDirectory(path) {
+        getWriteFileSystem(path).createDir(path);
+        invokeDirectoryWatchers(path);
+    },
+    getDirectories(path) {
+        const dirents = getReadFileSystem(path).readDir(path);
+        return dirents
+            .filter((dirent) => dirent.isDirectory() ||
+            (dirent.isSymbolicLink() && exports.system.directoryExists((0, path_1.join)(path, dirent.name))))
+            .map((dirent) => dirent.name);
+    },
+    getModifiedTime(path) {
+        const stats = getReadFileSystem(path).readStats(path);
+        if (stats) {
+            return stats.mtime;
+        }
+    },
+    setModifiedTime(path, date) {
+        getWriteFileSystem(path).updateTimes(path, date, date);
+        invokeDirectoryWatchers(path);
+        invokeFileWatchers(path, typescript_1.typescript.FileWatcherEventKind.Changed);
+    },
+    watchFile(path, callback) {
+        return createWatcher(fileWatcherCallbacksMap, path, callback);
+    },
+    watchDirectory(path, callback, recursive = false) {
+        return createWatcher(recursive ? recursiveDirectoryWatcherCallbacksMap : directoryWatcherCallbacksMap, path, callback);
+    }, 
+    // use immediate instead of timeout to avoid waiting 250ms for batching files changes
+    setTimeout: (callback, timeout, ...args) => {
+        const timeoutId = setImmediate(() => {
+            callback(...args);
+            timeoutCallbacks.delete(timeoutId);
+        });
+        timeoutCallbacks.add(timeoutId);
+        return timeoutId;
+    }, clearTimeout: (timeoutId) => {
+        clearImmediate(timeoutId);
+        timeoutCallbacks.delete(timeoutId);
+    }, waitForQueued() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (timeoutCallbacks.size > 0) {
+                yield new Promise((resolve) => setImmediate(resolve));
+            }
+            isInitialRun = false;
+        });
+    },
+    invokeFileCreated(path) {
+        const normalizedPath = normalizeAndResolvePath(path);
+        invokeFileWatchers(path, typescript_1.typescript.FileWatcherEventKind.Created);
+        invokeDirectoryWatchers(normalizedPath);
+        deletedFiles.set(normalizedPath, false);
+    },
+    invokeFileChanged(path) {
+        const normalizedPath = normalizeAndResolvePath(path);
+        if (deletedFiles.get(normalizedPath) || !fileWatcherCallbacksMap.has(normalizedPath)) {
+            invokeFileWatchers(path, typescript_1.typescript.FileWatcherEventKind.Created);
+            invokeDirectoryWatchers(normalizedPath);
+            deletedFiles.set(normalizedPath, false);
+        }
+        else {
+            invokeFileWatchers(path, typescript_1.typescript.FileWatcherEventKind.Changed);
+        }
+    },
+    invokeFileDeleted(path) {
+        const normalizedPath = normalizeAndResolvePath(path);
+        if (!deletedFiles.get(normalizedPath)) {
+            invokeFileWatchers(path, typescript_1.typescript.FileWatcherEventKind.Deleted);
+            invokeDirectoryWatchers(path);
+            deletedFiles.set(normalizedPath, true);
+        }
+    },
+    invalidateCache() {
+        real_file_system_1.realFileSystem.clearCache();
+        mem_file_system_1.memFileSystem.clearCache();
+        passive_file_system_1.passiveFileSystem.clearCache();
+    },
+    setArtifacts(nextArtifacts) {
+        artifacts = nextArtifacts;
+    } });
+function createWatcher(watchersMap, path, callback) {
+    const normalizedPath = normalizeAndResolvePath(path);
+    const watchers = watchersMap.get(normalizedPath) || [];
+    const nextWatchers = [...watchers, callback];
+    watchersMap.set(normalizedPath, nextWatchers);
+    return {
+        close: () => {
+            const watchers = watchersMap.get(normalizedPath) || [];
+            const nextWatchers = watchers.filter((watcher) => watcher !== callback);
+            if (nextWatchers.length > 0) {
+                watchersMap.set(normalizedPath, nextWatchers);
+            }
+            else {
+                watchersMap.delete(normalizedPath);
+            }
+        },
+    };
+}
+function invokeFileWatchers(path, event) {
+    const normalizedPath = normalizeAndResolvePath(path);
+    if (normalizedPath.endsWith('.js')) {
+        // trigger relevant .d.ts file watcher - handles the case, when we have webpack watcher
+        // that points to a symlinked package
+        invokeFileWatchers(normalizedPath.slice(0, -3) + '.d.ts', event);
+    }
+    const fileWatcherCallbacks = fileWatcherCallbacksMap.get(normalizedPath);
+    if (fileWatcherCallbacks) {
+        // typescript expects normalized paths with posix forward slash
+        fileWatcherCallbacks.forEach((fileWatcherCallback) => fileWatcherCallback((0, forward_slash_1.forwardSlash)(normalizedPath), event));
+    }
+}
+function invokeDirectoryWatchers(path) {
+    const normalizedPath = normalizeAndResolvePath(path);
+    const directory = (0, path_1.dirname)(normalizedPath);
+    if (ignoredPaths.some((ignoredPath) => (0, forward_slash_1.forwardSlash)(normalizedPath).includes(ignoredPath))) {
+        return;
+    }
+    const directoryWatcherCallbacks = directoryWatcherCallbacksMap.get(directory);
+    if (directoryWatcherCallbacks) {
+        directoryWatcherCallbacks.forEach((directoryWatcherCallback) => directoryWatcherCallback((0, forward_slash_1.forwardSlash)(normalizedPath)));
+    }
+    recursiveDirectoryWatcherCallbacksMap.forEach((recursiveDirectoryWatcherCallbacks, watchedDirectory) => {
+        if (watchedDirectory === directory ||
+            (directory.startsWith(watchedDirectory) &&
+                (0, forward_slash_1.forwardSlash)(directory)[watchedDirectory.length] === '/')) {
+            recursiveDirectoryWatcherCallbacks.forEach((recursiveDirectoryWatcherCallback) => recursiveDirectoryWatcherCallback((0, forward_slash_1.forwardSlash)(normalizedPath)));
+        }
+    });
+}
+function normalizeAndResolvePath(path) {
+    let normalizedPath = real_file_system_1.realFileSystem.normalizePath(path);
+    try {
+        normalizedPath = real_file_system_1.realFileSystem.realPath(normalizedPath);
+    }
+    catch (error) {
+        // ignore error - maybe file doesn't exist
+    }
+    return normalizedPath;
+}
+function isArtifact(path) {
+    return ((artifacts.dirs.some((dir) => path.includes(dir)) ||
+        artifacts.files.some((file) => path === file)) &&
+        artifacts.extensions.some((extension) => path.endsWith(extension)));
+}
+function getReadFileSystem(path) {
+    if ((mode === 'readonly' || mode === 'write-tsbuildinfo') && isArtifact(path)) {
+        if (isInitialRun && !mem_file_system_1.memFileSystem.exists(path) && passive_file_system_1.passiveFileSystem.exists(path)) {
+            // copy file to memory on initial run
+            const stats = passive_file_system_1.passiveFileSystem.readStats(path);
+            if (stats === null || stats === void 0 ? void 0 : stats.isFile()) {
+                const content = passive_file_system_1.passiveFileSystem.readFile(path);
+                if (content) {
+                    mem_file_system_1.memFileSystem.writeFile(path, content);
+                    mem_file_system_1.memFileSystem.updateTimes(path, stats.atime, stats.mtime);
+                }
+            }
+            return mem_file_system_1.memFileSystem;
+        }
+    }
+    return passive_file_system_1.passiveFileSystem;
+}
+function getWriteFileSystem(path) {
+    if (mode === 'write-references' ||
+        (mode === 'write-tsbuildinfo' && path.endsWith('.tsbuildinfo')) ||
+        (mode === 'write-dts' &&
+            ['.tsbuildinfo', '.d.ts', '.d.ts.map'].some((suffix) => path.endsWith(suffix)))) {
+        return real_file_system_1.realFileSystem;
+    }
+    return passive_file_system_1.passiveFileSystem;
+}

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

@@ -0,0 +1,4 @@
+import type * as ts from 'typescript';
+export declare function startTracingIfNeeded(compilerOptions: ts.CompilerOptions): void;
+export declare function stopTracingIfNeeded(program: ts.Program | ts.BuilderProgram): void;
+export declare function dumpTracingLegendIfNeeded(): void;

package/lib/typescript/worker/lib/tracing.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpTracingLegendIfNeeded = exports.stopTracingIfNeeded = exports.startTracingIfNeeded = void 0;
+const config_1 = require("./config");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traceableTypescript = typescript_1.typescript;
+function startTracingIfNeeded(compilerOptions) {
+    if (typeof compilerOptions.generateTrace === 'string' &&
+        typeof traceableTypescript.startTracing === 'function') {
+        traceableTypescript.startTracing(worker_config_1.config.build ? 'build' : 'project', compilerOptions.generateTrace, (0, config_1.getConfigFilePathFromCompilerOptions)(compilerOptions));
+    }
+}
+exports.startTracingIfNeeded = startTracingIfNeeded;
+function stopTracingIfNeeded(program) {
+    var _a;
+    const compilerOptions = program.getCompilerOptions();
+    if (typeof compilerOptions.generateTrace === 'string' &&
+        typeof ((_a = traceableTypescript.tracing) === null || _a === void 0 ? void 0 : _a.stopTracing) === 'function') {
+        traceableTypescript.tracing.stopTracing();
+    }
+}
+exports.stopTracingIfNeeded = stopTracingIfNeeded;
+function dumpTracingLegendIfNeeded() {
+    var _a;
+    (_a = traceableTypescript.tracing) === null || _a === void 0 ? void 0 : _a.dumpLegend();
+}
+exports.dumpTracingLegendIfNeeded = dumpTracingLegendIfNeeded;

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

@@ -0,0 +1,4 @@
+import type * as ts from 'typescript';
+export declare function invalidateTsBuildInfo(): void;
+export declare function emitTsBuildInfoIfNeeded(builderProgram: ts.BuilderProgram): void;
+export declare function getTsBuildInfoEmitPath(compilerOptions: ts.CompilerOptions): string | undefined;

package/lib/typescript/worker/lib/tsbuildinfo.js

@@ -0,0 +1,96 @@
+"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.getTsBuildInfoEmitPath = exports.emitTsBuildInfoIfNeeded = exports.invalidateTsBuildInfo = void 0;
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const system_1 = require("./system");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+function invalidateTsBuildInfo() {
+    const parsedConfig = (0, config_1.getParsedConfig)();
+    // try to remove outdated .tsbuildinfo file for incremental mode
+    if (typeof typescript_1.typescript.getTsBuildInfoEmitOutputFilePath === 'function' &&
+        worker_config_1.config.mode !== 'readonly' &&
+        parsedConfig.options.incremental) {
+        const tsBuildInfoPath = typescript_1.typescript.getTsBuildInfoEmitOutputFilePath(parsedConfig.options);
+        if (tsBuildInfoPath) {
+            try {
+                system_1.system.deleteFile(tsBuildInfoPath);
+            }
+            catch (error) {
+                // silent
+            }
+        }
+    }
+}
+exports.invalidateTsBuildInfo = invalidateTsBuildInfo;
+function emitTsBuildInfoIfNeeded(builderProgram) {
+    const parsedConfig = (0, config_1.getParsedConfig)();
+    if (worker_config_1.config.mode !== 'readonly' && parsedConfig && isIncrementalEnabled(parsedConfig.options)) {
+        const program = builderProgram.getProgram();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (typeof program.emitBuildInfo === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            program.emitBuildInfo();
+        }
+    }
+}
+exports.emitTsBuildInfoIfNeeded = emitTsBuildInfoIfNeeded;
+function getTsBuildInfoEmitPath(compilerOptions) {
+    if (typeof typescript_1.typescript.getTsBuildInfoEmitOutputFilePath === 'function') {
+        return typescript_1.typescript.getTsBuildInfoEmitOutputFilePath(compilerOptions);
+    }
+    const removeJsonExtension = (filePath) => filePath.endsWith('.json') ? filePath.slice(0, -'.json'.length) : filePath;
+    // based on the implementation from typescript
+    const configFile = compilerOptions.configFilePath;
+    if (!isIncrementalEnabled(compilerOptions)) {
+        return undefined;
+    }
+    if (compilerOptions.tsBuildInfoFile) {
+        return compilerOptions.tsBuildInfoFile;
+    }
+    const outPath = compilerOptions.outFile || compilerOptions.out;
+    let buildInfoExtensionLess;
+    if (outPath) {
+        buildInfoExtensionLess = removeJsonExtension(outPath);
+    }
+    else {
+        if (!configFile) {
+            return undefined;
+        }
+        const configFileExtensionLess = removeJsonExtension(configFile);
+        buildInfoExtensionLess = compilerOptions.outDir
+            ? compilerOptions.rootDir
+                ? path.resolve(compilerOptions.outDir, path.relative(compilerOptions.rootDir, configFileExtensionLess))
+                : path.resolve(compilerOptions.outDir, path.basename(configFileExtensionLess))
+            : configFileExtensionLess;
+    }
+    return buildInfoExtensionLess + '.tsbuildinfo';
+}
+exports.getTsBuildInfoEmitPath = getTsBuildInfoEmitPath;
+function isIncrementalEnabled(compilerOptions) {
+    return Boolean((compilerOptions.incremental || compilerOptions.composite) && !compilerOptions.outFile);
+}

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

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare const typescript: typeof ts;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescript = void 0;
+const worker_config_1 = require("./worker-config");
+// eslint-disable-next-line
+exports.typescript = require(worker_config_1.config.typescriptPath);

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

@@ -0,0 +1,2 @@
+import type { TypeScriptWorkerConfig } from '../../type-script-worker-config';
+export declare const config: TypeScriptWorkerConfig;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const rpc_1 = require("../../../rpc");
+exports.config = (0, rpc_1.getRpcWorkerData)();

package/lib/utils/async/abort-error.d.ts

@@ -0,0 +1,6 @@
+import type { AbortSignal } from 'node-abort-controller';
+declare class AbortError extends Error {
+    constructor(message?: string);
+    static throwIfAborted(signal: AbortSignal | undefined): void;
+}
+export { AbortError };

package/lib/utils/async/abort-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortError = void 0;
+class AbortError extends Error {
+    constructor(message = 'Task aborted.') {
+        super(message);
+        this.name = 'AbortError';
+    }
+    static throwIfAborted(signal) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new AbortError();
+        }
+    }
+}
+exports.AbortError = AbortError;

package/lib/utils/async/controlled-promise.d.ts

@@ -0,0 +1,6 @@
+declare function createControlledPromise<T = unknown>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+};
+export { createControlledPromise };

package/lib/utils/async/controlled-promise.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createControlledPromise = void 0;
+function createControlledPromise() {
+    let resolve = () => undefined;
+    let reject = () => undefined;
+    const promise = new Promise((aResolve, aReject) => {
+        resolve = aResolve;
+        reject = aReject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+exports.createControlledPromise = createControlledPromise;

package/lib/utils/async/is-pending.d.ts

@@ -0,0 +1,2 @@
+declare function isPending(promise: Promise<unknown>, timeout?: number): Promise<unknown>;
+export { isPending };

package/lib/utils/async/is-pending.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPending = void 0;
+function isPending(promise, timeout = 100) {
+    return Promise.race([
+        promise.then(() => false).catch(() => false),
+        new Promise((resolve) => setTimeout(() => resolve(true), timeout)),
+    ]);
+}
+exports.isPending = isPending;

package/lib/utils/async/pool.d.ts

@@ -0,0 +1,10 @@
+import type { AbortSignal } from 'node-abort-controller';
+type Task<T> = (signal?: AbortSignal) => Promise<T>;
+interface Pool {
+    submit<T>(task: Task<T>, signal?: AbortSignal): Promise<T>;
+    size: number;
+    readonly pending: number;
+    readonly drained: Promise<void>;
+}
+declare function createPool(size: number): Pool;
+export { Pool, createPool };

package/lib/utils/async/pool.js

@@ -0,0 +1,47 @@
+"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.createPool = void 0;
+const abort_error_1 = require("./abort-error");
+function createPool(size) {
+    let pendingPromises = [];
+    const pool = {
+        submit(task, signal) {
+            return __awaiter(this, void 0, void 0, function* () {
+                while (pendingPromises.length >= pool.size) {
+                    abort_error_1.AbortError.throwIfAborted(signal);
+                    yield Promise.race(pendingPromises).catch(() => undefined);
+                }
+                abort_error_1.AbortError.throwIfAborted(signal);
+                const taskPromise = task(signal).finally(() => {
+                    pendingPromises = pendingPromises.filter((pendingPromise) => pendingPromise !== taskPromise);
+                });
+                pendingPromises.push(taskPromise);
+                return taskPromise;
+            });
+        },
+        size,
+        get pending() {
+            return pendingPromises.length;
+        },
+        get drained() {
+            // eslint-disable-next-line no-async-promise-executor
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                while (pendingPromises.length > 0) {
+                    yield Promise.race(pendingPromises).catch(() => undefined);
+                }
+                resolve(undefined);
+            }));
+        },
+    };
+    return pool;
+}
+exports.createPool = createPool;

package/lib/utils/async/wait.d.ts

@@ -0,0 +1,2 @@
+declare function wait(timeout: number): Promise<unknown>;
+export { wait };

package/lib/utils/async/wait.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+function wait(timeout) {
+    return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+exports.wait = wait;

package/lib/utils/path/forward-slash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Replaces backslashes with one forward slash
+ * @param input
+ */
+declare function forwardSlash(input: string): string;
+export { forwardSlash };

package/lib/utils/path/forward-slash.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardSlash = void 0;
+const path_1 = __importDefault(require("path"));
+/**
+ * Replaces backslashes with one forward slash
+ * @param input
+ */
+function forwardSlash(input) {
+    return path_1.default.normalize(input).replace(/\\+/g, '/');
+}
+exports.forwardSlash = forwardSlash;

package/lib/utils/path/is-inside-another-path.d.ts

@@ -0,0 +1,2 @@
+declare function isInsideAnotherPath(parent: string, directory: string): boolean;
+export { isInsideAnotherPath };

package/lib/utils/path/is-inside-another-path.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInsideAnotherPath = void 0;
+const path_1 = require("path");
+function isInsideAnotherPath(parent, directory) {
+    const relativePart = (0, path_1.relative)(parent, directory);
+    // Tested folder is above parent.
+    if (relativePart.startsWith('..')) {
+        return false;
+    }
+    // Tested folder is the same as parent.
+    if (relativePart.length === 0) {
+        return false;
+    }
+    // Tested directory has nothing in common with parent.
+    if ((0, path_1.isAbsolute)(relativePart)) {
+        return false;
+    }
+    // Last option, must be subfolder.
+    return true;
+}
+exports.isInsideAnotherPath = isInsideAnotherPath;

package/lib/utils/path/relative-to-context.d.ts

@@ -0,0 +1,2 @@
+declare function relativeToContext(file: string, context: string): string;
+export { relativeToContext };

package/lib/utils/path/relative-to-context.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeToContext = void 0;
+const path_1 = __importDefault(require("path"));
+const forward_slash_1 = require("./forward-slash");
+function relativeToContext(file, context) {
+    let fileInContext = (0, forward_slash_1.forwardSlash)(path_1.default.relative(context, file));
+    if (!fileInContext.startsWith('../')) {
+        fileInContext = './' + fileInContext;
+    }
+    return fileInContext;
+}
+exports.relativeToContext = relativeToContext;

package/lib/watch/inclusive-node-watch-file-system.d.ts

@@ -0,0 +1,15 @@
+import type { Compiler } from 'webpack';
+import type { ForkTsCheckerWebpackPluginState } from '../plugin-state';
+import type { WatchFileSystem } from './watch-file-system';
+declare class InclusiveNodeWatchFileSystem implements WatchFileSystem {
+    private watchFileSystem;
+    private compiler;
+    private pluginState;
+    get watcher(): import("./watch-file-system").Watchpack | undefined;
+    private readonly dirsWatchers;
+    private paused;
+    private deletedFiles;
+    constructor(watchFileSystem: WatchFileSystem, compiler: Compiler, pluginState: ForkTsCheckerWebpackPluginState);
+    watch: WatchFileSystem['watch'];
+}
+export { InclusiveNodeWatchFileSystem };