@atlaspack/fs 2.15.26 → 2.15.27

package/dist/OverlayFS.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayFS = void 0;
+const build_cache_1 = require("@atlaspack/build-cache");
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const package_json_1 = __importDefault(require("../package.json"));
+const find_1 = require("./find");
+const MemoryFS_1 = require("./MemoryFS");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+class OverlayFS {
+    constructor(workerFarmOrFS, readable) {
+        this.deleted = new Set();
+        if (workerFarmOrFS instanceof workers_1.default) {
+            this.writable = new MemoryFS_1.MemoryFS(workerFarmOrFS);
+        }
+        else {
+            this.writable = workerFarmOrFS;
+        }
+        this.readable = readable;
+        this._cwd = readable.cwd();
+    }
+    static deserialize(opts) {
+        let fs = new OverlayFS(opts.writable, opts.readable);
+        if (opts.deleted != null)
+            fs.deleted = opts.deleted;
+        return fs;
+    }
+    serialize() {
+        return {
+            $$raw: false,
+            writable: this.writable,
+            readable: this.readable,
+            deleted: this.deleted,
+        };
+    }
+    _deletedThrows(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.deleted.has(filePath)) {
+            throw new FSError('ENOENT', filePath, 'does not exist');
+        }
+        return filePath;
+    }
+    _checkExists(filePath) {
+        filePath = this._deletedThrows(filePath);
+        if (!this.existsSync(filePath)) {
+            throw new FSError('ENOENT', filePath, 'does not exist');
+        }
+        return filePath;
+    }
+    _isSymlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        // Check the parts of the path to see if any are symlinks.
+        let { root, dir, base } = path_1.default.parse(filePath);
+        let segments = dir.slice(root.length).split(path_1.default.sep).concat(base);
+        while (segments.length) {
+            filePath = path_1.default.join(root, ...segments);
+            let name = segments.pop();
+            if (this.deleted.has(filePath)) {
+                return false;
+            }
+            else if (this.writable instanceof MemoryFS_1.MemoryFS &&
+                this.writable.symlinks.has(filePath)) {
+                return true;
+            }
+            else {
+                // HACK: Atlaspack fs does not provide `lstatSync`,
+                // so we use `readdirSync` to check if the path is a symlink.
+                let parent = path_1.default.resolve(filePath, '..');
+                if (parent === filePath) {
+                    return false;
+                }
+                try {
+                    for (let dirent of this.readdirSync(parent, { withFileTypes: true })) {
+                        if (typeof dirent === 'string') {
+                            break; // {withFileTypes: true} not supported
+                        }
+                        else if (dirent.name === name) {
+                            if (dirent.isSymbolicLink()) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e.code === 'ENOENT') {
+                        return false;
+                    }
+                    throw e;
+                }
+            }
+        }
+        return false;
+    }
+    async _copyPathForWrite(filePath) {
+        filePath = await this._normalizePath(filePath);
+        let dirPath = path_1.default.dirname(filePath);
+        if (this.existsSync(dirPath) && !this.writable.existsSync(dirPath)) {
+            await this.writable.mkdirp(dirPath);
+        }
+        return filePath;
+    }
+    _normalizePath(filePath) {
+        return path_1.default.resolve(this.cwd(), filePath);
+    }
+    // eslint-disable-next-line require-await
+    async readFile(filePath, encoding) {
+        return this.readFileSync(filePath, encoding);
+    }
+    async writeFile(filePath, contents, options) {
+        filePath = await this._copyPathForWrite(filePath);
+        await this.writable.writeFile(filePath, contents, options);
+        this.deleted.delete(filePath);
+    }
+    async copyFile(source, destination) {
+        source = this._normalizePath(source);
+        destination = await this._copyPathForWrite(destination);
+        if (await this.writable.exists(source)) {
+            await this.writable.writeFile(destination, await this.writable.readFile(source));
+        }
+        else {
+            await this.writable.writeFile(destination, await this.readable.readFile(source));
+        }
+        this.deleted.delete(destination);
+    }
+    // eslint-disable-next-line require-await
+    async stat(filePath) {
+        return this.statSync(filePath);
+    }
+    async symlink(target, filePath) {
+        target = this._normalizePath(target);
+        filePath = this._normalizePath(filePath);
+        await this.writable.symlink(target, filePath);
+        this.deleted.delete(filePath);
+    }
+    async unlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        let toDelete = [filePath];
+        if (this.writable instanceof MemoryFS_1.MemoryFS && this._isSymlink(filePath)) {
+            this.writable.symlinks.delete(filePath);
+        }
+        else if (this.statSync(filePath).isDirectory()) {
+            let stack = [filePath];
+            // Recursively add every descendant path to deleted.
+            while (stack.length) {
+                let root = (0, nullthrows_1.default)(stack.pop());
+                for (let ent of this.readdirSync(root, { withFileTypes: true })) {
+                    if (typeof ent === 'string') {
+                        let childPath = path_1.default.join(root, ent);
+                        toDelete.push(childPath);
+                        if (this.statSync(childPath).isDirectory()) {
+                            stack.push(childPath);
+                        }
+                    }
+                    else {
+                        let childPath = path_1.default.join(root, ent.name);
+                        toDelete.push(childPath);
+                        if (ent.isDirectory()) {
+                            stack.push(childPath);
+                        }
+                    }
+                }
+            }
+        }
+        try {
+            await this.writable.unlink(filePath);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' && !this.readable.existsSync(filePath)) {
+                throw e;
+            }
+        }
+        for (let pathToDelete of toDelete) {
+            this.deleted.add(pathToDelete);
+        }
+    }
+    async mkdirp(dir) {
+        dir = this._normalizePath(dir);
+        await this.writable.mkdirp(dir);
+        if (this.deleted != null) {
+            let root = path_1.default.parse(dir).root;
+            while (dir !== root) {
+                this.deleted.delete(dir);
+                dir = path_1.default.dirname(dir);
+            }
+        }
+    }
+    async rimraf(filePath) {
+        try {
+            await this.unlink(filePath);
+        }
+        catch (e) {
+            // noop
+        }
+    }
+    // eslint-disable-next-line require-await
+    async ncp(source, destination) {
+        // TODO: Implement this correctly.
+        return this.writable.ncp(source, destination);
+    }
+    createReadStream(filePath, opts) {
+        filePath = this._deletedThrows(filePath);
+        if (this.writable.existsSync(filePath)) {
+            return this.writable.createReadStream(filePath, opts);
+        }
+        return this.readable.createReadStream(filePath, opts);
+    }
+    createWriteStream(path, opts) {
+        path = this._normalizePath(path);
+        this.deleted.delete(path);
+        return this.writable.createWriteStream(path, opts);
+    }
+    cwd() {
+        return this._cwd;
+    }
+    chdir(path) {
+        this._cwd = this._checkExists(path);
+    }
+    // eslint-disable-next-line require-await
+    async realpath(filePath) {
+        return this.realpathSync(filePath);
+    }
+    readFileSync(filePath, encoding) {
+        filePath = this.realpathSync(filePath);
+        try {
+            // @ts-expect-error TS2345
+            return this.writable.readFileSync(filePath, encoding);
+        }
+        catch (err) {
+            // @ts-expect-error TS2345
+            return this.readable.readFileSync(filePath, encoding);
+        }
+    }
+    statSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        try {
+            return this.writable.statSync(filePath);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' && this.existsSync(filePath)) {
+                return this.readable.statSync(filePath);
+            }
+            throw e;
+        }
+    }
+    realpathSync(filePath) {
+        filePath = this._deletedThrows(filePath);
+        filePath = this._deletedThrows(this.writable.realpathSync(filePath));
+        if (!this.writable.existsSync(filePath)) {
+            return this.readable.realpathSync(filePath);
+        }
+        return filePath;
+    }
+    // eslint-disable-next-line require-await
+    async exists(filePath) {
+        return this.existsSync(filePath);
+    }
+    existsSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.deleted.has(filePath))
+            return false;
+        try {
+            filePath = this.realpathSync(filePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        if (this.deleted.has(filePath))
+            return false;
+        return (this.writable.existsSync(filePath) || this.readable.existsSync(filePath));
+    }
+    // eslint-disable-next-line require-await
+    async readdir(path, opts) {
+        return this.readdirSync(path, opts);
+    }
+    readdirSync(dir, opts) {
+        dir = this.realpathSync(dir);
+        // Read from both filesystems and merge the results
+        let entries = new Map();
+        try {
+            // @ts-expect-error TS2769
+            for (let entry of this.writable.readdirSync(dir, opts)) {
+                let filePath = path_1.default.join(dir, entry.name ?? entry);
+                if (this.deleted.has(filePath))
+                    continue;
+                entries.set(filePath, entry);
+            }
+        }
+        catch {
+            // noop
+        }
+        try {
+            // @ts-expect-error TS2769
+            for (let entry of this.readable.readdirSync(dir, opts)) {
+                let filePath = path_1.default.join(dir, entry.name ?? entry);
+                if (this.deleted.has(filePath))
+                    continue;
+                if (entries.has(filePath))
+                    continue;
+                entries.set(filePath, entry);
+            }
+        }
+        catch {
+            // noop
+        }
+        return Array.from(entries.values());
+    }
+    async watch(dir, fn, opts) {
+        let writableSubscription = await this.writable.watch(dir, fn, opts);
+        let readableSubscription = await this.readable.watch(dir, fn, opts);
+        return {
+            unsubscribe: async () => {
+                await writableSubscription.unsubscribe();
+                await readableSubscription.unsubscribe();
+            },
+        };
+    }
+    async getEventsSince(dir, snapshot, opts) {
+        let writableEvents = await this.writable.getEventsSince(dir, snapshot, opts);
+        let readableEvents = await this.readable.getEventsSince(dir, snapshot, opts);
+        return [...writableEvents, ...readableEvents];
+    }
+    async writeSnapshot(dir, snapshot, opts) {
+        await this.writable.writeSnapshot(dir, snapshot, opts);
+    }
+    findAncestorFile(fileNames, fromDir, root) {
+        return (0, find_1.findAncestorFile)(this, fileNames, fromDir, root);
+    }
+    findNodeModule(moduleName, fromDir) {
+        return (0, find_1.findNodeModule)(this, moduleName, fromDir);
+    }
+    findFirstFile(filePaths) {
+        return (0, find_1.findFirstFile)(this, filePaths);
+    }
+}
+exports.OverlayFS = OverlayFS;
+class FSError extends Error {
+    constructor(code, path, message) {
+        super(`${code}: ${path} ${message}`);
+        this.name = 'FSError';
+        this.code = code;
+        this.path = path;
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:OverlayFS`, OverlayFS);

package/dist/find.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodeModule = findNodeModule;
+exports.findAncestorFile = findAncestorFile;
+exports.findFirstFile = findFirstFile;
+const path_1 = __importDefault(require("path"));
+function findNodeModule(fs, moduleName, dir) {
+    let { root } = path_1.default.parse(dir);
+    while (dir !== root) {
+        // Skip node_modules directories
+        if (path_1.default.basename(dir) === 'node_modules') {
+            dir = path_1.default.dirname(dir);
+        }
+        try {
+            let moduleDir = path_1.default.join(dir, 'node_modules', moduleName);
+            let stats = fs.statSync(moduleDir);
+            if (stats.isDirectory()) {
+                return moduleDir;
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+        // Move up a directory
+        dir = path_1.default.dirname(dir);
+    }
+    return null;
+}
+function findAncestorFile(fs, fileNames, dir, root) {
+    let { root: pathRoot } = path_1.default.parse(dir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (path_1.default.basename(dir) === 'node_modules') {
+            return null;
+        }
+        for (const fileName of fileNames) {
+            let filePath = path_1.default.join(dir, fileName);
+            try {
+                if (fs.statSync(filePath).isFile()) {
+                    return filePath;
+                }
+            }
+            catch (err) {
+                // ignore
+            }
+        }
+        if (dir === root || dir === pathRoot) {
+            break;
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    return null;
+}
+function findFirstFile(fs, filePaths) {
+    for (let filePath of filePaths) {
+        try {
+            if (fs.statSync(filePath).isFile()) {
+                return filePath;
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ncp = ncp;
+const path_1 = __importDefault(require("path"));
+const stream_1 = __importDefault(require("stream"));
+const util_1 = require("util");
+__exportStar(require("./NodeFS"), exports);
+__exportStar(require("./MemoryFS"), exports);
+__exportStar(require("./OverlayFS"), exports);
+__exportStar(require("./NodeVCSAwareFS"), exports);
+const pipeline = (0, util_1.promisify)(stream_1.default.pipeline);
+// Recursively copies a directory from the sourceFS to the destinationFS
+async function ncp(sourceFS, source, destinationFS, destination, filter) {
+    await destinationFS.mkdirp(destination);
+    let files = await sourceFS.readdir(source);
+    for (let file of files) {
+        if (filter && !filter(file)) {
+            continue;
+        }
+        let sourcePath = path_1.default.join(source, file);
+        let destPath = path_1.default.join(destination, file);
+        let stats = await sourceFS.stat(sourcePath);
+        if (stats.isFile()) {
+            await pipeline(sourceFS.createReadStream(sourcePath), destinationFS.createWriteStream(destPath));
+        }
+        else if (stats.isDirectory()) {
+            await ncp(sourceFS, sourcePath, destinationFS, destPath, filter);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/fs",
-  "version": "2.15.26",
+  "version": "2.15.27",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -46,18 +46,17 @@
     }
   },
   "scripts": {
-    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/feature-flags": "2.25.1",
-    "@atlaspack/logger": "2.14.23",
-    "@atlaspack/rust": "3.8.1",
-    "@atlaspack/types-internal": "2.20.1",
+    "@atlaspack/feature-flags": "2.25.2",
+    "@atlaspack/logger": "2.14.24",
+    "@atlaspack/rust": "3.8.2",
+    "@atlaspack/types-internal": "2.20.2",
     "@parcel/watcher": "^2.0.7",
-    "@atlaspack/workers": "2.14.31",
-    "@atlaspack/watcher-watchman-js": "2.14.31",
+    "@atlaspack/workers": "2.14.32",
+    "@atlaspack/watcher-watchman-js": "2.14.32",
     "graceful-fs": "^4.2.4",
     "ncp": "^2.0.0",
     "nullthrows": "^1.1.1",

package/tsconfig.json

@@ -1,4 +1,30 @@
 {
-  "extends": "../../../tsconfig.json",
-  "include": ["src"]
+  "extends": "../../../tsconfig.base.json",
+  "include": ["./src/", "./package.json"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../utils/atlaspack-watcher-watchman-js/tsconfig.json"
+    },
+    {
+      "path": "../build-cache/tsconfig.json"
+    },
+    {
+      "path": "../feature-flags/tsconfig.json"
+    },
+    {
+      "path": "../logger/tsconfig.json"
+    },
+    {
+      "path": "../rust/tsconfig.json"
+    },
+    {
+      "path": "../types-internal/tsconfig.json"
+    },
+    {
+      "path": "../workers/tsconfig.json"
+    }
+  ]
 }