@atlaspack/fs 2.15.26 → 2.15.27-dev-ts-project-refs-d30e9754f.0

package/dist/NodeFS.browser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFS = void 0;
+// @ts-expect-error TS2420
+class NodeFS {
+    constructor() {
+        throw new Error("NodeFS isn't available in the browser");
+    }
+}
+exports.NodeFS = NodeFS;

package/dist/NodeFS.js

@@ -0,0 +1,251 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.NodeFS = void 0;
+// @ts-expect-error TS7016
+const graceful_fs_1 = __importDefault(require("graceful-fs"));
+const fs_1 = __importDefault(require("fs"));
+// @ts-expect-error TS7016
+const ncp_1 = __importDefault(require("ncp"));
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+const util_1 = require("util");
+const build_cache_1 = require("@atlaspack/build-cache");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const watcher_1 = __importDefault(require("@parcel/watcher"));
+const package_json_1 = __importDefault(require("../package.json"));
+const searchNative = __importStar(require("@atlaspack/rust"));
+const searchJS = __importStar(require("./find"));
+// Most of this can go away once we only support Node 10+, which includes
+// require('fs').promises
+const realpath = (0, util_1.promisify)(process.platform === 'win32' ? graceful_fs_1.default.realpath : graceful_fs_1.default.realpath.native);
+const isPnP = process.versions.pnp != null;
+function getWatchmanWatcher() {
+    // This is here to trick atlaspack into ignoring this require...
+    const packageName = ['@atlaspack', 'watcher-watchman-js'].join('/');
+    return require(packageName);
+}
+class NodeFS {
+    constructor() {
+        this.readFile = (0, util_1.promisify)(graceful_fs_1.default.readFile);
+        this.copyFile = (0, util_1.promisify)(graceful_fs_1.default.copyFile);
+        this.stat = (0, util_1.promisify)(graceful_fs_1.default.stat);
+        this.readdir = (0, util_1.promisify)(graceful_fs_1.default.readdir);
+        this.symlink = (0, util_1.promisify)(graceful_fs_1.default.symlink);
+        this.unlink = (0, util_1.promisify)(graceful_fs_1.default.unlink);
+        this.utimes = (0, util_1.promisify)(graceful_fs_1.default.utimes);
+        this.ncp = (0, util_1.promisify)(ncp_1.default);
+        this.createReadStream = graceful_fs_1.default.createReadStream;
+        this.cwd = () => process.cwd();
+        this.chdir = (directory) => process.chdir(directory);
+        this.statSync = (path) => graceful_fs_1.default.statSync(path);
+        this.realpathSync = process.platform === 'win32' ? graceful_fs_1.default.realpathSync : graceful_fs_1.default.realpathSync.native;
+        this.existsSync = graceful_fs_1.default.existsSync;
+        this.readdirSync = graceful_fs_1.default.readdirSync;
+        this.findAncestorFile = isPnP
+            ? // @ts-expect-error TS7019
+                (...args) => searchJS.findAncestorFile(this, ...args)
+            : searchNative.findAncestorFile;
+        this.findNodeModule = isPnP
+            ? // @ts-expect-error TS7019
+                (...args) => searchJS.findNodeModule(this, ...args)
+            : searchNative.findNodeModule;
+        this.findFirstFile = isPnP
+            ? // @ts-expect-error TS7019
+                (...args) => searchJS.findFirstFile(this, ...args)
+            : searchNative.findFirstFile;
+    }
+    watcher() {
+        return (0, feature_flags_1.getFeatureFlag)('useWatchmanWatcher')
+            ? getWatchmanWatcher()
+            : watcher_1.default;
+    }
+    createWriteStream(filePath, options) {
+        // Make createWriteStream atomic
+        let tmpFilePath = getTempFilePath(filePath);
+        let failed = false;
+        const move = async () => {
+            if (!failed) {
+                await graceful_fs_1.default.promises.rename(tmpFilePath, filePath);
+            }
+        };
+        let writeStream = graceful_fs_1.default.createWriteStream(tmpFilePath, {
+            ...options,
+            fs: {
+                ...graceful_fs_1.default,
+                // @ts-expect-error TS7006
+                close: (fd, cb) => {
+                    // @ts-expect-error TS7006
+                    graceful_fs_1.default.close(fd, (err) => {
+                        if (err) {
+                            cb(err);
+                        }
+                        else {
+                            move().then(() => cb(), (err) => cb(err));
+                        }
+                    });
+                },
+            },
+        });
+        writeStream.once('error', () => {
+            failed = true;
+            try {
+                graceful_fs_1.default.unlinkSync(tmpFilePath);
+            }
+            catch (_err) {
+                // ignore
+            }
+        });
+        return writeStream;
+    }
+    async writeFile(filePath, contents, options) {
+        let tmpFilePath = getTempFilePath(filePath);
+        await graceful_fs_1.default.promises.writeFile(tmpFilePath, contents, options);
+        await graceful_fs_1.default.promises.rename(tmpFilePath, filePath);
+    }
+    readFileSync(filePath, encoding) {
+        if (encoding != null) {
+            return graceful_fs_1.default.readFileSync(filePath, encoding);
+        }
+        return graceful_fs_1.default.readFileSync(filePath);
+    }
+    async realpath(originalPath) {
+        try {
+            return await realpath(originalPath, 'utf8');
+        }
+        catch (e) {
+            // do nothing
+        }
+        return originalPath;
+    }
+    exists(filePath) {
+        return new Promise((resolve) => {
+            graceful_fs_1.default.exists(filePath, resolve);
+        });
+    }
+    watch(dir, fn, opts) {
+        return this.watcher().subscribe(dir, fn, opts);
+    }
+    getEventsSince(dir, snapshot, opts) {
+        return this.watcher().getEventsSince(dir, snapshot, opts);
+    }
+    async writeSnapshot(dir, snapshot, opts) {
+        await this.mkdirp(path_1.default.dirname(snapshot));
+        await this.watcher().writeSnapshot(dir, snapshot, opts);
+    }
+    static deserialize() {
+        return new NodeFS();
+    }
+    serialize() {
+        return null;
+    }
+    async mkdirp(filePath) {
+        await fs_1.default.promises.mkdir(filePath, { recursive: true });
+    }
+    async rimraf(filePath) {
+        if (graceful_fs_1.default.promises.rm) {
+            await graceful_fs_1.default.promises.rm(filePath, { recursive: true, force: true });
+            return;
+        }
+        // fs.promises.rm is not supported in node 12...
+        let stat;
+        try {
+            stat = await this.stat(filePath);
+        }
+        catch (err) {
+            return;
+        }
+        if (stat.isDirectory()) {
+            await fs_1.default.promises.rmdir(filePath, { recursive: true });
+        }
+        else {
+            await fs_1.default.promises.unlink(filePath);
+        }
+    }
+}
+exports.NodeFS = NodeFS;
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:NodeFS`, NodeFS);
+let writeStreamCalls = 0;
+// @ts-expect-error TS7034
+let threadId;
+try {
+    ({ threadId } = require('worker_threads'));
+}
+catch {
+    //
+}
+// @ts-expect-error TS7034
+let useOsTmpDir;
+function shouldUseOsTmpDir(filePath) {
+    // @ts-expect-error TS7005
+    if (useOsTmpDir != null) {
+        // @ts-expect-error TS7005
+        return useOsTmpDir;
+    }
+    try {
+        const tmpDir = (0, os_1.tmpdir)();
+        fs_1.default.accessSync(tmpDir, fs_1.default.constants.R_OK | fs_1.default.constants.W_OK);
+        const tmpDirStats = fs_1.default.statSync(tmpDir);
+        const filePathStats = fs_1.default.statSync(filePath);
+        // Check the tmpdir is on the same partition as the target directory.
+        // This is required to ensure renaming is an atomic operation.
+        useOsTmpDir = tmpDirStats.dev === filePathStats.dev;
+    }
+    catch (e) {
+        // We don't have read/write access to the OS tmp directory
+        useOsTmpDir = false;
+    }
+    return useOsTmpDir;
+}
+// Generate a temporary file path used for atomic writing of files.
+function getTempFilePath(filePath) {
+    writeStreamCalls = writeStreamCalls % Number.MAX_SAFE_INTEGER;
+    let tmpFilePath = filePath;
+    // If possible, write the tmp file to the OS tmp directory
+    // This reduces the amount of FS events the watcher needs to process during the build
+    if (shouldUseOsTmpDir(filePath)) {
+        tmpFilePath = path_1.default.join((0, os_1.tmpdir)(), path_1.default.basename(filePath));
+    }
+    return (tmpFilePath +
+        '.' +
+        process.pid +
+        // @ts-expect-error TS7005
+        (threadId != null ? '.' + threadId : '') +
+        '.' +
+        (writeStreamCalls++).toString(36));
+}

package/dist/NodeVCSAwareFS.js

@@ -0,0 +1,193 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NodeVCSAwareFS_excludePatterns, _NodeVCSAwareFS_logEventDiff, _NodeVCSAwareFS_gitRepoPath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeVCSAwareFS = void 0;
+const path_1 = __importDefault(require("path"));
+const NodeFS_1 = require("./NodeFS");
+const rust_1 = require("@atlaspack/rust");
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const package_json_1 = __importDefault(require("../package.json"));
+class NodeVCSAwareFS extends NodeFS_1.NodeFS {
+    constructor(options) {
+        super();
+        /**
+         * These files are excluded from 'dirty file' tracking even if they are
+         * modified.
+         */
+        _NodeVCSAwareFS_excludePatterns.set(this, void 0);
+        /**
+         * Logging function for the diff between watcher events and vcs events.
+         */
+        _NodeVCSAwareFS_logEventDiff.set(this, void 0);
+        /**
+         * The path of the git repository containing the project root. Null if the
+         * project is not a git repository.
+         */
+        _NodeVCSAwareFS_gitRepoPath.set(this, void 0);
+        __classPrivateFieldSet(this, _NodeVCSAwareFS_excludePatterns, options.excludePatterns, "f");
+        __classPrivateFieldSet(this, _NodeVCSAwareFS_logEventDiff, options.logEventDiff, "f");
+        __classPrivateFieldSet(this, _NodeVCSAwareFS_gitRepoPath, options.gitRepoPath, "f");
+    }
+    static deserialize(data) {
+        const fs = new NodeVCSAwareFS({
+            excludePatterns: data.excludePatterns,
+            logEventDiff: null,
+            gitRepoPath: data.gitRepoPath,
+        });
+        return fs;
+    }
+    // @ts-expect-error TS2416
+    serialize() {
+        return {
+            excludePatterns: __classPrivateFieldGet(this, _NodeVCSAwareFS_excludePatterns, "f"),
+            logEventDiff: null,
+            gitRepoPath: __classPrivateFieldGet(this, _NodeVCSAwareFS_gitRepoPath, "f"),
+        };
+    }
+    setGitRepoPath(gitRepoPath) {
+        __classPrivateFieldSet(this, _NodeVCSAwareFS_gitRepoPath, gitRepoPath, "f");
+    }
+    async getEventsSince(dir, snapshot, opts) {
+        const gitRepoPath = __classPrivateFieldGet(this, _NodeVCSAwareFS_gitRepoPath, "f");
+        if (gitRepoPath == null) {
+            return this.watcher().getEventsSince(dir, snapshot, opts);
+        }
+        const { nativeSnapshotPath, vcsState } = await (0, logger_1.instrumentAsync)('NodeVCSAwareFS.readSnapshot', async () => {
+            // Note: can't use toString() directly, or it won't resolve the promise
+            const snapshotFile = await this.readFile(snapshot);
+            const snapshotFileContent = snapshotFile.toString();
+            return JSON.parse(snapshotFileContent);
+        });
+        let watcherEventsSince = [];
+        const vcsEventsSince = vcsState != null
+            ? // @ts-expect-error TS2571
+                (await (0, logger_1.instrumentAsync)('NodeVCSAwareFS::rust.getEventsSince', () => 
+                // @ts-expect-error TS2739
+                (0, rust_1.getEventsSince)(gitRepoPath, vcsState, null)))
+                    // @ts-expect-error TS7006
+                    .map((e) => ({
+                    path: e.path,
+                    type: e.changeType,
+                }))
+            : null;
+        if ((0, feature_flags_1.getFeatureFlagValue)('vcsMode') !== 'NEW' && vcsEventsSince != null) {
+            watcherEventsSince = await (0, logger_1.instrumentAsync)('NodeVCSAwareFS::watchman.getEventsSince', () => this.watcher().getEventsSince(dir, nativeSnapshotPath, opts));
+            __classPrivateFieldGet(this, _NodeVCSAwareFS_logEventDiff, "f")?.call(this, watcherEventsSince, vcsEventsSince);
+        }
+        // @ts-expect-error TS2345
+        if (['NEW_AND_CHECK', 'NEW'].includes((0, feature_flags_1.getFeatureFlagValue)('vcsMode'))) {
+            if (vcsEventsSince == null) {
+                logger_1.default.error({
+                    origin: '@atlaspack/fs',
+                    message: 'Missing VCS state. There was an error when writing the snapshot. Please clear your cache.',
+                    meta: {
+                        trackableEvent: 'vcs_state_snapshot_read_failed',
+                    },
+                });
+                return [];
+            }
+            return vcsEventsSince;
+        }
+        return watcherEventsSince;
+    }
+    async writeSnapshot(dir, snapshot, opts) {
+        const gitRepoPath = __classPrivateFieldGet(this, _NodeVCSAwareFS_gitRepoPath, "f");
+        if (gitRepoPath == null) {
+            await this.watcher().writeSnapshot(dir, snapshot, opts);
+            return;
+        }
+        const snapshotDirectory = path_1.default.dirname(snapshot);
+        await this.mkdirp(snapshotDirectory);
+        const filename = path_1.default.basename(snapshot, '.txt');
+        const nativeSnapshotPath = path_1.default.join(snapshotDirectory, `${filename}.native-snapshot.txt`);
+        if ((0, feature_flags_1.getFeatureFlagValue)('vcsMode') !== 'NEW') {
+            await (0, logger_1.instrumentAsync)('NodeVCSAwareFS::watchman.writeSnapshot', async () => {
+                await this.watcher().writeSnapshot(dir, nativeSnapshotPath, opts);
+            });
+        }
+        let vcsState = null;
+        try {
+            vcsState = await (0, logger_1.instrumentAsync)('NodeVCSAwareFS::getVcsStateSnapshot', 
+            // @ts-expect-error TS2322
+            () => (0, rust_1.getVcsStateSnapshot)(gitRepoPath, __classPrivateFieldGet(this, _NodeVCSAwareFS_excludePatterns, "f")));
+            logger_1.default.verbose({
+                origin: '@atlaspack/fs',
+                message: 'Expose VCS timing metrics',
+                meta: {
+                    trackableEvent: 'vcs_timing_metrics',
+                    // @ts-expect-error TS2339
+                    dirtyFilesExecutionTime: vcsState?.dirtyFilesExecutionTime,
+                    // @ts-expect-error TS2339
+                    yarnStatesExecutionTime: vcsState?.yarnStatesExecutionTime,
+                },
+            });
+        }
+        catch (err) {
+            logger_1.default.error({
+                origin: '@atlaspack/fs',
+                message: `Failed to get VCS state snapshot: ${err.message}`,
+                meta: {
+                    trackableEvent: 'vcs_state_snapshot_failed',
+                    error: err,
+                },
+            });
+        }
+        const snapshotContents = {
+            vcsState,
+            nativeSnapshotPath,
+        };
+        await this.writeFile(snapshot, JSON.stringify(snapshotContents));
+    }
+}
+exports.NodeVCSAwareFS = NodeVCSAwareFS;
+_NodeVCSAwareFS_excludePatterns = new WeakMap(), _NodeVCSAwareFS_logEventDiff = new WeakMap(), _NodeVCSAwareFS_gitRepoPath = new WeakMap();
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:NodeVCSAwareFS`, NodeVCSAwareFS);