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

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

@@ -0,0 +1,135 @@
+"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.didRootFilesChanged = exports.didDependenciesProbablyChanged = exports.didConfigFileChanged = exports.getConfigFilePathFromBuilderProgram = exports.getConfigFilePathFromProgram = exports.getConfigFilePathFromCompilerOptions = exports.invalidateConfig = exports.parseNextConfig = exports.getParsedConfig = exports.getParseConfigIssues = exports.parseConfig = void 0;
+const path = __importStar(require("path"));
+const forward_slash_1 = require("../../../utils/path/forward-slash");
+const diagnostics_1 = require("./diagnostics");
+const system_1 = require("./system");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+let parsedConfig;
+let parseConfigDiagnostics = [];
+// initialize ParseConfigFileHost
+const parseConfigFileHost = Object.assign(Object.assign({}, system_1.system), { onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+        parseConfigDiagnostics.push(diagnostic);
+    } });
+function getUserProvidedConfigOverwrite() {
+    return worker_config_1.config.configOverwrite || {};
+}
+function getImplicitConfigOverwrite() {
+    const baseCompilerOptionsOverwrite = {
+        skipLibCheck: true,
+        sourceMap: false,
+        inlineSourceMap: false,
+    };
+    switch (worker_config_1.config.mode) {
+        case 'write-dts':
+            return {
+                compilerOptions: Object.assign(Object.assign({}, baseCompilerOptionsOverwrite), { declaration: true, emitDeclarationOnly: true, noEmit: false }),
+            };
+        case 'write-tsbuildinfo':
+        case 'write-references':
+            return {
+                compilerOptions: Object.assign(Object.assign({}, baseCompilerOptionsOverwrite), { declaration: true, emitDeclarationOnly: false, noEmit: false }),
+            };
+    }
+    return {
+        compilerOptions: baseCompilerOptionsOverwrite,
+    };
+}
+function applyConfigOverwrite(baseConfig, ...overwriteConfigs) {
+    let config = baseConfig;
+    for (const overwriteConfig of overwriteConfigs) {
+        config = Object.assign(Object.assign(Object.assign({}, (config || {})), (overwriteConfig || {})), { compilerOptions: Object.assign(Object.assign({}, ((config === null || config === void 0 ? void 0 : config.compilerOptions) || {})), ((overwriteConfig === null || overwriteConfig === void 0 ? void 0 : overwriteConfig.compilerOptions) || {})) });
+    }
+    return config;
+}
+function parseConfig(configFileName, configFileContext) {
+    const configFilePath = (0, forward_slash_1.forwardSlash)(configFileName);
+    const { config: baseConfig, error: readConfigError } = typescript_1.typescript.readConfigFile(configFilePath, parseConfigFileHost.readFile);
+    const overwrittenConfig = applyConfigOverwrite(baseConfig || {}, getImplicitConfigOverwrite(), getUserProvidedConfigOverwrite());
+    const parsedConfigFile = typescript_1.typescript.parseJsonConfigFileContent(overwrittenConfig, parseConfigFileHost, configFileContext);
+    return Object.assign(Object.assign({}, parsedConfigFile), { options: Object.assign(Object.assign({}, parsedConfigFile.options), { configFilePath: configFilePath }), errors: readConfigError ? [readConfigError] : parsedConfigFile.errors });
+}
+exports.parseConfig = parseConfig;
+function getParseConfigIssues() {
+    const issues = (0, diagnostics_1.createIssuesFromDiagnostics)(parseConfigDiagnostics);
+    issues.forEach((issue) => {
+        if (!issue.file) {
+            issue.file = worker_config_1.config.configFile;
+        }
+    });
+    return issues;
+}
+exports.getParseConfigIssues = getParseConfigIssues;
+function getParsedConfig(force = false) {
+    if (!parsedConfig || force) {
+        parsedConfig = parseConfig(worker_config_1.config.configFile, worker_config_1.config.context);
+        parseConfigDiagnostics = parsedConfig.errors || [];
+    }
+    return parsedConfig;
+}
+exports.getParsedConfig = getParsedConfig;
+function parseNextConfig() {
+    const prevParsedConfig = parsedConfig;
+    const nextParsedConfig = getParsedConfig(true);
+    return [prevParsedConfig, nextParsedConfig];
+}
+exports.parseNextConfig = parseNextConfig;
+function invalidateConfig() {
+    parsedConfig = undefined;
+    parseConfigDiagnostics = [];
+}
+exports.invalidateConfig = invalidateConfig;
+function getConfigFilePathFromCompilerOptions(compilerOptions) {
+    return compilerOptions.configFilePath;
+}
+exports.getConfigFilePathFromCompilerOptions = getConfigFilePathFromCompilerOptions;
+function getConfigFilePathFromProgram(program) {
+    return getConfigFilePathFromCompilerOptions(program.getCompilerOptions());
+}
+exports.getConfigFilePathFromProgram = getConfigFilePathFromProgram;
+function getConfigFilePathFromBuilderProgram(builderProgram) {
+    return getConfigFilePathFromCompilerOptions(builderProgram.getProgram().getCompilerOptions());
+}
+exports.getConfigFilePathFromBuilderProgram = getConfigFilePathFromBuilderProgram;
+function didConfigFileChanged({ changedFiles = [], deletedFiles = [] }) {
+    return [...changedFiles, ...deletedFiles]
+        .map((file) => path.normalize(file))
+        .includes(path.normalize(worker_config_1.config.configFile));
+}
+exports.didConfigFileChanged = didConfigFileChanged;
+function didDependenciesProbablyChanged(dependencies, { changedFiles = [], deletedFiles = [] }) {
+    const didSomeDependencyHasBeenAdded = changedFiles.some((changeFile) => !dependencies.files.includes(changeFile));
+    const didSomeDependencyHasBeenDeleted = deletedFiles.some((deletedFile) => dependencies.files.includes(deletedFile));
+    return didSomeDependencyHasBeenAdded || didSomeDependencyHasBeenDeleted;
+}
+exports.didDependenciesProbablyChanged = didDependenciesProbablyChanged;
+function didRootFilesChanged() {
+    const [prevConfig, nextConfig] = parseNextConfig();
+    return (prevConfig && JSON.stringify(prevConfig.fileNames) !== JSON.stringify(nextConfig.fileNames));
+}
+exports.didRootFilesChanged = didRootFilesChanged;

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

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

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

@@ -0,0 +1,85 @@
+"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.invalidateDependencies = exports.getDependencies = void 0;
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+let dependencies;
+function getDependencies(force = false) {
+    if (!dependencies || force) {
+        const parsedConfig = (0, config_1.getParsedConfig)();
+        dependencies = getDependenciesWorker(parsedConfig, worker_config_1.config.context);
+    }
+    return dependencies;
+}
+exports.getDependencies = getDependencies;
+function invalidateDependencies() {
+    dependencies = undefined;
+}
+exports.invalidateDependencies = invalidateDependencies;
+function getDependenciesWorker(parsedConfig, configFileContext, processedConfigFiles = []) {
+    var _a;
+    const files = new Set(parsedConfig.fileNames);
+    const configFilePath = parsedConfig.options.configFilePath;
+    if (typeof configFilePath === 'string') {
+        files.add(configFilePath);
+    }
+    const dirs = new Set(Object.keys(parsedConfig.wildcardDirectories || {}));
+    const excluded = new Set((((_a = parsedConfig.raw) === null || _a === void 0 ? void 0 : _a.exclude) || []).map((filePath) => path.resolve(configFileContext, filePath)));
+    for (const projectReference of parsedConfig.projectReferences || []) {
+        const childConfigFilePath = typescript_1.typescript.resolveProjectReferencePath(projectReference);
+        const childConfigContext = path.dirname(childConfigFilePath);
+        if (processedConfigFiles.includes(childConfigFilePath)) {
+            // handle circular dependencies
+            continue;
+        }
+        const childParsedConfig = (0, config_1.parseConfig)(childConfigFilePath, childConfigContext);
+        const childDependencies = getDependenciesWorker(childParsedConfig, childConfigContext, [
+            ...processedConfigFiles,
+            childConfigFilePath,
+        ]);
+        childDependencies.files.forEach((file) => {
+            files.add(file);
+        });
+        childDependencies.dirs.forEach((dir) => {
+            dirs.add(dir);
+        });
+    }
+    const extensions = [
+        typescript_1.typescript.Extension.Ts,
+        typescript_1.typescript.Extension.Tsx,
+        typescript_1.typescript.Extension.Js,
+        typescript_1.typescript.Extension.Jsx,
+        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: Array.from(excluded).map((aPath) => path.normalize(aPath)),
+        extensions: extensions,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type * as ts from 'typescript';
+import type { Issue } from '../../../issue';
+export declare function updateDiagnostics(configFile: string, diagnostics: ts.Diagnostic[]): void;
+export declare function getIssues(): Issue[];
+export declare function invalidateDiagnostics(): void;
+export declare function getDiagnosticsOfProgram(program: ts.Program | ts.BuilderProgram): ts.Diagnostic[];
+export declare function createIssuesFromDiagnostics(diagnostics: ts.Diagnostic[]): Issue[];

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

@@ -0,0 +1,112 @@
+"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.createIssuesFromDiagnostics = exports.getDiagnosticsOfProgram = exports.invalidateDiagnostics = exports.getIssues = exports.updateDiagnostics = void 0;
+const os = __importStar(require("os"));
+const issue_1 = require("../../../issue");
+const typescript_1 = require("./typescript");
+const worker_config_1 = require("./worker-config");
+const diagnosticsPerConfigFile = new Map();
+function updateDiagnostics(configFile, diagnostics) {
+    diagnosticsPerConfigFile.set(configFile, diagnostics);
+}
+exports.updateDiagnostics = updateDiagnostics;
+function getIssues() {
+    const allDiagnostics = [];
+    diagnosticsPerConfigFile.forEach((diagnostics) => {
+        allDiagnostics.push(...diagnostics);
+    });
+    return createIssuesFromDiagnostics(allDiagnostics);
+}
+exports.getIssues = getIssues;
+function invalidateDiagnostics() {
+    diagnosticsPerConfigFile.clear();
+}
+exports.invalidateDiagnostics = invalidateDiagnostics;
+function getDiagnosticsOfProgram(program) {
+    const programDiagnostics = [];
+    try {
+        if (worker_config_1.config.diagnosticOptions.syntactic) {
+            programDiagnostics.push(...program.getSyntacticDiagnostics());
+        }
+        if (worker_config_1.config.diagnosticOptions.global) {
+            programDiagnostics.push(...program.getGlobalDiagnostics());
+        }
+        if (worker_config_1.config.diagnosticOptions.semantic) {
+            programDiagnostics.push(...program.getSemanticDiagnostics());
+        }
+        if (worker_config_1.config.diagnosticOptions.declaration) {
+            programDiagnostics.push(...program.getDeclarationDiagnostics());
+        }
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            programDiagnostics.push({
+                code: 1,
+                category: 1,
+                messageText: `TSC compiler crashed: ${e.message}
+${e.stack}`,
+                file: undefined,
+                start: undefined,
+                length: undefined,
+            });
+        }
+    }
+    return programDiagnostics;
+}
+exports.getDiagnosticsOfProgram = getDiagnosticsOfProgram;
+function createIssueFromDiagnostic(diagnostic) {
+    let file;
+    let location;
+    if (diagnostic.file) {
+        file = diagnostic.file.fileName;
+        if (diagnostic.start && diagnostic.length) {
+            const { line: startLine, character: startCharacter } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+            const { line: endLine, character: endCharacter } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+            location = {
+                start: {
+                    line: startLine + 1,
+                    column: startCharacter + 1,
+                },
+                end: {
+                    line: endLine + 1,
+                    column: endCharacter + 1,
+                },
+            };
+        }
+    }
+    return {
+        code: 'TS' + String(diagnostic.code),
+        // we don't handle Suggestion and Message diagnostics
+        severity: diagnostic.category === 0 ? 'warning' : 'error',
+        message: typescript_1.typescript.flattenDiagnosticMessageText(diagnostic.messageText, os.EOL),
+        file,
+        location,
+    };
+}
+function createIssuesFromDiagnostics(diagnostics) {
+    return (0, issue_1.deduplicateAndSortIssues)(diagnostics.map((diagnostic) => createIssueFromDiagnostic(diagnostic)));
+}
+exports.createIssuesFromDiagnostics = createIssuesFromDiagnostics;

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

@@ -0,0 +1,2 @@
+import type * as ts from 'typescript';
+export declare function emitDtsIfNeeded(program: ts.Program | ts.BuilderProgram): void;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitDtsIfNeeded = void 0;
+const config_1 = require("./config");
+const worker_config_1 = require("./worker-config");
+function emitDtsIfNeeded(program) {
+    const parsedConfig = (0, config_1.getParsedConfig)();
+    if (worker_config_1.config.mode === 'write-dts' && parsedConfig.options.declaration) {
+        // emit .d.ts files only
+        program.emit(undefined, undefined, undefined, true);
+    }
+}
+exports.emitDtsIfNeeded = emitDtsIfNeeded;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import type { Dirent, Stats } from 'fs';
+/**
+ * Interface to abstract file system implementation details.
+ */
+export interface FileSystem {
+    exists(path: string): boolean;
+    readFile(path: string, encoding?: string): string | undefined;
+    readDir(path: string): Dirent[];
+    readStats(path: string): Stats | undefined;
+    realPath(path: string): string;
+    normalizePath(path: string): string;
+    writeFile(path: string, data: string): void;
+    deleteFile(path: string): void;
+    createDir(path: string): void;
+    updateTimes(path: string, atime: Date, mtime: Date): void;
+    clearCache(): void;
+}

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

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

package/lib/typescript/worker/lib/file-system/mem-file-system.d.ts

@@ -0,0 +1,5 @@
+import type { FileSystem } from './file-system';
+/**
+ * It's an implementation of FileSystem interface which reads and writes to the in-memory file system.
+ */
+export declare const memFileSystem: FileSystem;

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memFileSystem = void 0;
+const path_1 = require("path");
+const memfs_1 = require("memfs");
+const real_file_system_1 = require("./real-file-system");
+/**
+ * It's an implementation of FileSystem interface which reads and writes to the in-memory file system.
+ */
+exports.memFileSystem = Object.assign(Object.assign({}, real_file_system_1.realFileSystem), { exists(path) {
+        return exists(real_file_system_1.realFileSystem.realPath(path));
+    },
+    readFile(path, encoding) {
+        return readFile(real_file_system_1.realFileSystem.realPath(path), encoding);
+    },
+    readDir(path) {
+        return readDir(real_file_system_1.realFileSystem.realPath(path));
+    },
+    readStats(path) {
+        return readStats(real_file_system_1.realFileSystem.realPath(path));
+    },
+    writeFile(path, data) {
+        writeFile(real_file_system_1.realFileSystem.realPath(path), data);
+    },
+    deleteFile(path) {
+        deleteFile(real_file_system_1.realFileSystem.realPath(path));
+    },
+    createDir(path) {
+        createDir(real_file_system_1.realFileSystem.realPath(path));
+    },
+    updateTimes(path, atime, mtime) {
+        updateTimes(real_file_system_1.realFileSystem.realPath(path), atime, mtime);
+    },
+    clearCache() {
+        real_file_system_1.realFileSystem.clearCache();
+    } });
+function exists(path) {
+    return memfs_1.fs.existsSync(real_file_system_1.realFileSystem.normalizePath(path));
+}
+function readStats(path) {
+    return exists(path) ? memfs_1.fs.statSync(real_file_system_1.realFileSystem.normalizePath(path)) : undefined;
+}
+function readFile(path, encoding) {
+    const stats = readStats(path);
+    if (stats && stats.isFile()) {
+        return memfs_1.fs
+            .readFileSync(real_file_system_1.realFileSystem.normalizePath(path), { encoding: encoding })
+            .toString();
+    }
+}
+function readDir(path) {
+    const stats = readStats(path);
+    if (stats && stats.isDirectory()) {
+        return memfs_1.fs.readdirSync(real_file_system_1.realFileSystem.normalizePath(path), {
+            withFileTypes: true,
+        });
+    }
+    return [];
+}
+function createDir(path) {
+    memfs_1.fs.mkdirSync(real_file_system_1.realFileSystem.normalizePath(path), { recursive: true });
+}
+function writeFile(path, data) {
+    if (!exists((0, path_1.dirname)(path))) {
+        createDir((0, path_1.dirname)(path));
+    }
+    memfs_1.fs.writeFileSync(real_file_system_1.realFileSystem.normalizePath(path), data);
+}
+function deleteFile(path) {
+    if (exists(path)) {
+        memfs_1.fs.unlinkSync(real_file_system_1.realFileSystem.normalizePath(path));
+    }
+}
+function updateTimes(path, atime, mtime) {
+    if (exists(path)) {
+        memfs_1.fs.utimesSync(real_file_system_1.realFileSystem.normalizePath(path), atime, mtime);
+    }
+}

package/lib/typescript/worker/lib/file-system/passive-file-system.d.ts

@@ -0,0 +1,5 @@
+import type { FileSystem } from './file-system';
+/**
+ * It's an implementation of FileSystem interface which reads from the real file system, but write to the in-memory file system.
+ */
+export declare const passiveFileSystem: FileSystem;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passiveFileSystem = void 0;
+const mem_file_system_1 = require("./mem-file-system");
+const real_file_system_1 = require("./real-file-system");
+/**
+ * It's an implementation of FileSystem interface which reads from the real file system, but write to the in-memory file system.
+ */
+exports.passiveFileSystem = Object.assign(Object.assign({}, mem_file_system_1.memFileSystem), { exists(path) {
+        return exists(real_file_system_1.realFileSystem.realPath(path));
+    },
+    readFile(path, encoding) {
+        return readFile(real_file_system_1.realFileSystem.realPath(path), encoding);
+    },
+    readDir(path) {
+        return readDir(real_file_system_1.realFileSystem.realPath(path));
+    },
+    readStats(path) {
+        return readStats(real_file_system_1.realFileSystem.realPath(path));
+    },
+    realPath(path) {
+        return real_file_system_1.realFileSystem.realPath(path);
+    },
+    clearCache() {
+        real_file_system_1.realFileSystem.clearCache();
+    } });
+function exists(path) {
+    return real_file_system_1.realFileSystem.exists(path) || mem_file_system_1.memFileSystem.exists(path);
+}
+function readFile(path, encoding) {
+    const fsStats = real_file_system_1.realFileSystem.readStats(path);
+    const memStats = mem_file_system_1.memFileSystem.readStats(path);
+    if (fsStats && memStats) {
+        return fsStats.mtimeMs > memStats.mtimeMs
+            ? real_file_system_1.realFileSystem.readFile(path, encoding)
+            : mem_file_system_1.memFileSystem.readFile(path, encoding);
+    }
+    else if (fsStats) {
+        return real_file_system_1.realFileSystem.readFile(path, encoding);
+    }
+    else if (memStats) {
+        return mem_file_system_1.memFileSystem.readFile(path, encoding);
+    }
+}
+function readDir(path) {
+    const fsDirents = real_file_system_1.realFileSystem.readDir(path);
+    const memDirents = mem_file_system_1.memFileSystem.readDir(path);
+    // merge list of dirents from fs and mem
+    return fsDirents
+        .filter((fsDirent) => !memDirents.some((memDirent) => memDirent.name === fsDirent.name))
+        .concat(memDirents);
+}
+function readStats(path) {
+    const fsStats = real_file_system_1.realFileSystem.readStats(path);
+    const memStats = mem_file_system_1.memFileSystem.readStats(path);
+    if (fsStats && memStats) {
+        return fsStats.mtimeMs > memStats.mtimeMs ? fsStats : memStats;
+    }
+    else if (fsStats) {
+        return fsStats;
+    }
+    else if (memStats) {
+        return memStats;
+    }
+}

package/lib/typescript/worker/lib/file-system/real-file-system.d.ts

@@ -0,0 +1,5 @@
+import type { FileSystem } from './file-system';
+/**
+ * It's an implementation of the FileSystem interface which reads and writes directly to the real file system.
+ */
+export declare const realFileSystem: FileSystem;