@pnpm/exe 12.8.2 → 12.9.0

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/patchFs/patchFs.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFs = patchFs;
+exports.extendFs = extendFs;
+const util_1 = require("util");
+const NodePathFS_1 = require("../NodePathFS");
+const FileHandle_1 = require("./FileHandle");
+const SYNC_IMPLEMENTATIONS = new Set([
+    `accessSync`,
+    `appendFileSync`,
+    `createReadStream`,
+    `createWriteStream`,
+    `chmodSync`,
+    `fchmodSync`,
+    `chownSync`,
+    `fchownSync`,
+    `closeSync`,
+    `copyFileSync`,
+    `linkSync`,
+    `lstatSync`,
+    `fstatSync`,
+    `lutimesSync`,
+    `mkdirSync`,
+    `openSync`,
+    `opendirSync`,
+    `readlinkSync`,
+    `readFileSync`,
+    `readdirSync`,
+    `readlinkSync`,
+    `realpathSync`,
+    `renameSync`,
+    `rmdirSync`,
+    `rmSync`,
+    `statSync`,
+    `symlinkSync`,
+    `truncateSync`,
+    `ftruncateSync`,
+    `unlinkSync`,
+    `unwatchFile`,
+    `utimesSync`,
+    `watch`,
+    `watchFile`,
+    `writeFileSync`,
+    `writeSync`,
+]);
+const ASYNC_IMPLEMENTATIONS = new Set([
+    `accessPromise`,
+    `appendFilePromise`,
+    `fchmodPromise`,
+    `chmodPromise`,
+    `fchownPromise`,
+    `chownPromise`,
+    `closePromise`,
+    `copyFilePromise`,
+    `linkPromise`,
+    `fstatPromise`,
+    `lstatPromise`,
+    `lutimesPromise`,
+    `mkdirPromise`,
+    `openPromise`,
+    `opendirPromise`,
+    `readdirPromise`,
+    `realpathPromise`,
+    `readFilePromise`,
+    `readdirPromise`,
+    `readlinkPromise`,
+    `renamePromise`,
+    `rmdirPromise`,
+    `rmPromise`,
+    `statPromise`,
+    `symlinkPromise`,
+    `truncatePromise`,
+    `ftruncatePromise`,
+    `unlinkPromise`,
+    `utimesPromise`,
+    `writeFilePromise`,
+    `writeSync`,
+]);
+//#endregion
+function patchFs(patchedFs, fakeFs) {
+    // We wrap the `fakeFs` with a `NodePathFS` to add support for all path types supported by Node
+    fakeFs = new NodePathFS_1.NodePathFS(fakeFs);
+    const setupFn = (target, name, replacement) => {
+        const orig = target[name];
+        target[name] = replacement;
+        // Preserve any util.promisify implementations
+        if (typeof orig?.[util_1.promisify.custom] !== `undefined`) {
+            replacement[util_1.promisify.custom] = orig[util_1.promisify.custom];
+        }
+    };
+    /** Callback implementations */
+    {
+        setupFn(patchedFs, `exists`, (p, ...args) => {
+            const hasCallback = typeof args[args.length - 1] === `function`;
+            const callback = hasCallback ? args.pop() : () => { };
+            process.nextTick(() => {
+                fakeFs.existsPromise(p).then(exists => {
+                    callback(exists);
+                }, () => {
+                    callback(false);
+                });
+            });
+        });
+        // Adapted from https://github.com/nodejs/node/blob/e5c1fd7a2a1801fd75bdde23b260488e85453eb2/lib/fs.js#L603-L667
+        setupFn(patchedFs, `read`, (...args) => {
+            let [fd, buffer, offset, length, position, callback] = args;
+            if (args.length <= 3) {
+                // Assume fs.read(fd, options, callback)
+                let options = {};
+                if (args.length < 3) {
+                    // This is fs.read(fd, callback)
+                    callback = args[1];
+                }
+                else {
+                    // This is fs.read(fd, {}, callback)
+                    options = args[1];
+                    callback = args[2];
+                }
+                ({
+                    buffer = Buffer.alloc(16384),
+                    offset = 0,
+                    length = buffer.byteLength,
+                    position,
+                } = options);
+            }
+            if (offset == null)
+                offset = 0;
+            length |= 0;
+            if (length === 0) {
+                process.nextTick(() => {
+                    callback(null, 0, buffer);
+                });
+                return;
+            }
+            if (position == null)
+                position = -1;
+            process.nextTick(() => {
+                fakeFs.readPromise(fd, buffer, offset, length, position).then(bytesRead => {
+                    callback(null, bytesRead, buffer);
+                }, error => {
+                    // https://github.com/nodejs/node/blob/1317252dfe8824fd9cfee125d2aaa94004db2f3b/lib/fs.js#L655-L658
+                    // Known issue: bytesRead could theoretically be > than 0, but we currently always return 0
+                    callback(error, 0, buffer);
+                });
+            });
+        });
+        for (const fnName of ASYNC_IMPLEMENTATIONS) {
+            const origName = fnName.replace(/Promise$/, ``);
+            if (typeof patchedFs[origName] === `undefined`)
+                continue;
+            const fakeImpl = fakeFs[fnName];
+            if (typeof fakeImpl === `undefined`)
+                continue;
+            const wrapper = (...args) => {
+                const hasCallback = typeof args[args.length - 1] === `function`;
+                const callback = hasCallback ? args.pop() : () => { };
+                process.nextTick(() => {
+                    fakeImpl.apply(fakeFs, args).then((result) => {
+                        callback(null, result);
+                    }, (error) => {
+                        callback(error);
+                    });
+                });
+            };
+            setupFn(patchedFs, origName, wrapper);
+        }
+        patchedFs.realpath.native = patchedFs.realpath;
+    }
+    /** Sync implementations */
+    {
+        setupFn(patchedFs, `existsSync`, (p) => {
+            try {
+                return fakeFs.existsSync(p);
+            }
+            catch {
+                return false;
+            }
+        });
+        // Adapted from https://github.com/nodejs/node/blob/e5c1fd7a2a1801fd75bdde23b260488e85453eb2/lib/fs.js#L684-L725
+        setupFn(patchedFs, `readSync`, (...args) => {
+            let [fd, buffer, offset, length, position] = args;
+            if (args.length <= 3) {
+                // Assume fs.read(fd, buffer, options)
+                const options = args[2] || {};
+                ({ offset = 0, length = buffer.byteLength, position } = options);
+            }
+            if (offset == null)
+                offset = 0;
+            length |= 0;
+            if (length === 0)
+                return 0;
+            if (position == null)
+                position = -1;
+            return fakeFs.readSync(fd, buffer, offset, length, position);
+        });
+        for (const fnName of SYNC_IMPLEMENTATIONS) {
+            const origName = fnName;
+            if (typeof patchedFs[origName] === `undefined`)
+                continue;
+            const fakeImpl = fakeFs[fnName];
+            if (typeof fakeImpl === `undefined`)
+                continue;
+            setupFn(patchedFs, origName, fakeImpl.bind(fakeFs));
+        }
+        patchedFs.realpathSync.native = patchedFs.realpathSync;
+    }
+    /** Promise implementations */
+    {
+        // `fs.promises` is a getter that returns a reference to require(`fs/promises`),
+        // so we can just patch `fs.promises` and both will be updated
+        const patchedFsPromises = patchedFs.promises;
+        // `fs.promises.exists` doesn't exist
+        for (const fnName of ASYNC_IMPLEMENTATIONS) {
+            const origName = fnName.replace(/Promise$/, ``);
+            if (typeof patchedFsPromises[origName] === `undefined`)
+                continue;
+            const fakeImpl = fakeFs[fnName];
+            if (typeof fakeImpl === `undefined`)
+                continue;
+            // Open is a bit particular with fs.promises: it returns a file handle
+            // instance instead of the traditional file descriptor number
+            if (fnName === `open`)
+                continue;
+            setupFn(patchedFsPromises, origName, (pathLike, ...args) => {
+                if (pathLike instanceof FileHandle_1.FileHandle) {
+                    return pathLike[origName].apply(pathLike, args);
+                }
+                else {
+                    return fakeImpl.call(fakeFs, pathLike, ...args);
+                }
+            });
+        }
+        setupFn(patchedFsPromises, `open`, async (...args) => {
+            // @ts-expect-error - reason TBS
+            const fd = await fakeFs.openPromise(...args);
+            return new FileHandle_1.FileHandle(fd, fakeFs);
+        });
+        // `fs.promises.realpath` doesn't have a `native` property
+    }
+    /** util.promisify implementations */
+    {
+        // TODO add promisified `fs.readv` and `fs.writev`, once they are implemented
+        // Override the promisified versions of `fs.read` and `fs.write` to return an object as per
+        // https://github.com/nodejs/node/blob/dc79f3f37caf6f25b8efee4623bec31e2c20f595/lib/fs.js#L559-L560
+        // and
+        // https://github.com/nodejs/node/blob/dc79f3f37caf6f25b8efee4623bec31e2c20f595/lib/fs.js#L690-L691
+        // and
+        // https://github.com/nodejs/node/blob/ba684805b6c0eded76e5cd89ee00328ac7a59365/lib/internal/util.js#L293
+        // @ts-expect-error - reason TBS
+        patchedFs.read[util_1.promisify.custom] = async (fd, buffer, ...args) => {
+            const res = fakeFs.readPromise(fd, buffer, ...args);
+            return { bytesRead: await res, buffer };
+        };
+        // @ts-expect-error - reason TBS
+        patchedFs.write[util_1.promisify.custom] = async (fd, buffer, ...args) => {
+            const res = fakeFs.writePromise(fd, buffer, ...args);
+            return { bytesWritten: await res, buffer };
+        };
+    }
+}
+function extendFs(realFs, fakeFs) {
+    const patchedFs = Object.create(realFs);
+    patchFs(patchedFs, fakeFs);
+    return patchedFs;
+}

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/path.d.ts

@@ -0,0 +1,84 @@
+declare enum PathType {
+    File = 0,
+    Portable = 1,
+    Native = 2
+}
+export type PortablePath = string & {
+    __pathType: PathType.File | PathType.Portable;
+};
+export type NativePath = string & {
+    __pathType?: PathType.File | PathType.Native;
+};
+export declare const PortablePath: {
+    root: PortablePath;
+    dot: PortablePath;
+    parent: PortablePath;
+};
+export type Filename = string & {
+    __pathType: PathType.File;
+};
+export type Path = PortablePath | NativePath;
+export declare const Filename: {
+    home: Filename;
+    nodeModules: Filename;
+    manifest: Filename;
+    lockfile: Filename;
+    virtual: Filename;
+    /**
+     * @deprecated
+     */
+    pnpJs: Filename;
+    pnpCjs: Filename;
+    pnpData: Filename;
+    pnpEsmLoader: Filename;
+    rc: Filename;
+    env: Filename;
+};
+export type TolerateLiterals<T> = {
+    [K in keyof T]: ValidateLiteral<T[K]> | PortablePath | Filename;
+};
+export type ValidateLiteral<T> = T extends `${infer X}` ? T : never;
+export interface PortablePathGenerics {
+    join<T extends Array<string>>(...segments: TolerateLiterals<T>): PortablePath;
+    resolve<T extends string>(...pathSegments: Array<PortablePath | Filename | TolerateLiterals<T>>): PortablePath;
+}
+export type FSPath<T extends Path> = T | number;
+export declare const npath: PathUtils<NativePath> & ConvertUtils;
+export declare const ppath: PathUtils<PortablePath> & PortablePathGenerics;
+export interface ParsedPath<P extends Path> {
+    root: P;
+    dir: P;
+    base: Filename;
+    ext: string;
+    name: Filename;
+}
+export interface FormatInputPathObject<P extends Path> {
+    root?: P;
+    dir?: P;
+    base?: Filename;
+    ext?: string;
+    name?: Filename;
+}
+type NoInfer<T> = [T][T extends any ? 0 : never];
+export interface PathUtils<P extends Path> {
+    cwd(): P;
+    join(...paths: Array<NoInfer<P> | Filename>): P;
+    resolve(...pathSegments: Array<NoInfer<P> | Filename>): P;
+    normalize(p: P): P;
+    isAbsolute(path: P): boolean;
+    relative(from: P, to: P): P;
+    dirname(p: P): P;
+    basename(p: P, ext?: string): Filename;
+    extname(p: P): string;
+    readonly sep: P;
+    readonly delimiter: string;
+    parse(pathString: P): ParsedPath<P>;
+    format(pathObject: FormatInputPathObject<P>): P;
+    contains(from: P, to: P): P | null;
+}
+export interface ConvertUtils {
+    fromPortablePath: (p: Path) => NativePath;
+    toPortablePath: (p: Path) => PortablePath;
+}
+export declare function convertPath<P extends Path>(targetPathUtils: PathUtils<P>, sourcePath: Path): P;
+export {};

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/path.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ppath = exports.npath = exports.Filename = exports.PortablePath = void 0;
+exports.convertPath = convertPath;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+var PathType;
+(function (PathType) {
+    PathType[PathType["File"] = 0] = "File";
+    PathType[PathType["Portable"] = 1] = "Portable";
+    PathType[PathType["Native"] = 2] = "Native";
+})(PathType || (PathType = {}));
+exports.PortablePath = {
+    root: `/`,
+    dot: `.`,
+    parent: `..`,
+};
+exports.Filename = {
+    home: `~`,
+    nodeModules: `node_modules`,
+    manifest: `package.json`,
+    lockfile: `yarn.lock`,
+    virtual: `__virtual__`,
+    /**
+     * @deprecated
+     */
+    pnpJs: `.pnp.js`,
+    pnpCjs: `.pnp.cjs`,
+    pnpData: `.pnp.data.json`,
+    pnpEsmLoader: `.pnp.loader.mjs`,
+    rc: `.yarnrc.yml`,
+    env: `.env`,
+};
+exports.npath = Object.create(path_1.default);
+exports.ppath = Object.create(path_1.default.posix);
+exports.npath.cwd = () => process.cwd();
+exports.ppath.cwd = process.platform === `win32`
+    ? () => toPortablePath(process.cwd())
+    : process.cwd;
+if (process.platform === `win32`) {
+    exports.ppath.resolve = (...segments) => {
+        if (segments.length > 0 && exports.ppath.isAbsolute(segments[0])) {
+            return path_1.default.posix.resolve(...segments);
+        }
+        else {
+            return path_1.default.posix.resolve(exports.ppath.cwd(), ...segments);
+        }
+    };
+}
+const contains = function (pathUtils, from, to) {
+    from = pathUtils.normalize(from);
+    to = pathUtils.normalize(to);
+    if (from === to)
+        return `.`;
+    if (!from.endsWith(pathUtils.sep))
+        from = (from + pathUtils.sep);
+    if (to.startsWith(from)) {
+        return to.slice(from.length);
+    }
+    else {
+        return null;
+    }
+};
+exports.npath.contains = (from, to) => contains(exports.npath, from, to);
+exports.ppath.contains = (from, to) => contains(exports.ppath, from, to);
+const WINDOWS_PATH_REGEXP = /^([a-zA-Z]:.*)$/;
+const UNC_WINDOWS_PATH_REGEXP = /^\/\/(\.\/)?(.*)$/;
+const PORTABLE_PATH_REGEXP = /^\/([a-zA-Z]:.*)$/;
+const UNC_PORTABLE_PATH_REGEXP = /^\/unc\/(\.dot\/)?(.*)$/;
+// Path should look like "/N:/berry/scripts/plugin-pack.js"
+// And transform to "N:\berry\scripts\plugin-pack.js"
+function fromPortablePathWin32(p) {
+    let portablePathMatch, uncPortablePathMatch;
+    if ((portablePathMatch = p.match(PORTABLE_PATH_REGEXP)))
+        p = portablePathMatch[1];
+    else if ((uncPortablePathMatch = p.match(UNC_PORTABLE_PATH_REGEXP)))
+        p = `\\\\${uncPortablePathMatch[1] ? `.\\` : ``}${uncPortablePathMatch[2]}`;
+    else
+        return p;
+    return p.replace(/\//g, `\\`);
+}
+// Path should look like "N:/berry/scripts/plugin-pack.js"
+// And transform to "/N:/berry/scripts/plugin-pack.js"
+function toPortablePathWin32(p) {
+    p = p.replace(/\\/g, `/`);
+    let windowsPathMatch, uncWindowsPathMatch;
+    if ((windowsPathMatch = p.match(WINDOWS_PATH_REGEXP)))
+        p = `/${windowsPathMatch[1]}`;
+    else if ((uncWindowsPathMatch = p.match(UNC_WINDOWS_PATH_REGEXP)))
+        p = `/unc/${uncWindowsPathMatch[1] ? `.dot/` : ``}${uncWindowsPathMatch[2]}`;
+    return p;
+}
+const toPortablePath = process.platform === `win32`
+    ? toPortablePathWin32
+    : (p) => p;
+const fromPortablePath = process.platform === `win32`
+    ? fromPortablePathWin32
+    : (p) => p;
+exports.npath.fromPortablePath = fromPortablePath;
+exports.npath.toPortablePath = toPortablePath;
+function convertPath(targetPathUtils, sourcePath) {
+    return (targetPathUtils === exports.npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath));
+}

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/statUtils.d.ts

@@ -0,0 +1,81 @@
+import { BigIntStats, Stats } from 'fs';
+import { Filename } from './path';
+export declare const DEFAULT_MODE: number;
+export declare class DirEntry<T = undefined> {
+    name: Filename;
+    path: T;
+    mode: number;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isDirectory(): boolean;
+    isFIFO(): boolean;
+    isFile(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+}
+export declare class StatEntry {
+    uid: number;
+    gid: number;
+    size: number;
+    blksize: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    rdev: number;
+    blocks: number;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isDirectory(): boolean;
+    isFIFO(): boolean;
+    isFile(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+}
+export declare class BigIntStatsEntry {
+    uid: bigint;
+    gid: bigint;
+    size: bigint;
+    blksize: bigint;
+    atimeMs: bigint;
+    mtimeMs: bigint;
+    ctimeMs: bigint;
+    birthtimeMs: bigint;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+    birthtimeNs: bigint;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    dev: bigint;
+    ino: bigint;
+    mode: bigint;
+    nlink: bigint;
+    rdev: bigint;
+    blocks: bigint;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isDirectory(): boolean;
+    isFIFO(): boolean;
+    isFile(): boolean;
+    isSocket(): boolean;
+    isSymbolicLink(): boolean;
+}
+export declare function makeDefaultStats(): StatEntry;
+export declare function makeEmptyStats(): Stats | BigIntStats;
+/**
+ * Mutates the provided stats object to zero it out then returns it for convenience
+ */
+export declare function clearStats(stats: Stats | BigIntStats): Stats | BigIntStats;
+export declare function convertToBigIntStats(stats: Stats): BigIntStats;
+export declare function areStatsEqual(a: Stats | BigIntStatsEntry, b: Stats | BigIntStatsEntry): boolean;