@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,278 @@
+import { BigIntStats, Stats } from 'fs';
+import { WatchOptions, WatchCallback, Watcher, StatOptions, StatSyncOptions, DirentNoPath, RmOptions } from './FakeFS';
+import { FakeFS, MkdirOptions, RmdirOptions, WriteFileOptions, OpendirOptions } from './FakeFS';
+import { Dirent, SymlinkType } from './FakeFS';
+import { CreateReadStreamOptions, CreateWriteStreamOptions, BasePortableFakeFS, ExtractHintOptions, WatchFileOptions, WatchFileCallback, StatWatcher } from './FakeFS';
+import { Filename, FSPath, PortablePath } from './path';
+export type GetMountPointFn = (path: PortablePath, prefixPath: PortablePath) => PortablePath | null;
+export interface MountableFS extends FakeFS<PortablePath> {
+    hasOpenFileHandles?(): boolean;
+    saveAndClose?(): void;
+    discardAndClose?(): void;
+}
+export type MountFSOptions<MountedFS extends MountableFS> = {
+    baseFs?: FakeFS<PortablePath>;
+    filter?: RegExp | null;
+    magicByte?: number;
+    maxOpenFiles?: number;
+    typeCheck?: number | null;
+    useCache?: boolean;
+    /**
+     * Functions used to create the sub-filesystem to use when accessing specific paths.
+     */
+    factorySync: (baseFs: FakeFS<PortablePath>, path: PortablePath) => MountedFS;
+    factoryPromise: (baseFs: FakeFS<PortablePath>, path: PortablePath) => Promise<() => MountedFS>;
+    /**
+     * A function that will be called to figure out the segment of a path that represents a mount point.
+     *
+     * It must return a strict prefix of the original path, or `null` if the path isn't part of a mount archive.
+     */
+    getMountPoint: GetMountPointFn;
+    /**
+     * Maximum age of the child filesystem, after which they will be discarded. Each new access resets this time.
+     *
+     * Only used if `useCache` is set to `true`.
+     */
+    maxAge?: number;
+};
+export declare class MountFS<MountedFS extends MountableFS> extends BasePortableFakeFS {
+    private readonly baseFs;
+    private readonly mountInstances;
+    private readonly fdMap;
+    private nextFd;
+    private readonly factoryPromise;
+    private readonly factorySync;
+    private readonly filter;
+    private readonly getMountPoint;
+    private readonly magic;
+    private readonly maxAge;
+    private readonly maxOpenFiles;
+    private readonly typeCheck;
+    private isMount;
+    private notMount;
+    private realPaths;
+    constructor({ baseFs, filter, magicByte, maxOpenFiles, useCache, maxAge, typeCheck, getMountPoint, factoryPromise, factorySync }: MountFSOptions<MountedFS>);
+    getExtractHint(hints: ExtractHintOptions): boolean;
+    getRealPath(): PortablePath;
+    saveAndClose(): void;
+    discardAndClose(): void;
+    resolve(p: PortablePath): PortablePath;
+    private remapFd;
+    openPromise(p: PortablePath, flags: string, mode?: number): Promise<number>;
+    openSync(p: PortablePath, flags: string, mode?: number): number;
+    opendirPromise(p: PortablePath, opts?: OpendirOptions): Promise<import("./FakeFS").Dir<PortablePath>>;
+    opendirSync(p: PortablePath, opts?: OpendirOptions): import("./FakeFS").Dir<PortablePath>;
+    readPromise(fd: number, buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
+    readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
+    writePromise(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): Promise<number>;
+    writePromise(fd: number, buffer: string, position?: number): Promise<number>;
+    writeSync(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, buffer: string, position?: number): number;
+    closePromise(fd: number): Promise<void>;
+    closeSync(fd: number): void;
+    createReadStream(p: PortablePath | null, opts?: CreateReadStreamOptions): import("fs").ReadStream;
+    createWriteStream(p: PortablePath | null, opts?: CreateWriteStreamOptions): import("fs").WriteStream;
+    realpathPromise(p: PortablePath): Promise<PortablePath>;
+    realpathSync(p: PortablePath): PortablePath;
+    existsPromise(p: PortablePath): Promise<boolean>;
+    existsSync(p: PortablePath): boolean;
+    accessPromise(p: PortablePath, mode?: number): Promise<void>;
+    accessSync(p: PortablePath, mode?: number): void;
+    statPromise(p: PortablePath): Promise<Stats>;
+    statPromise(p: PortablePath, opts: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined): Promise<Stats>;
+    statPromise(p: PortablePath, opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    statPromise(p: PortablePath, opts?: StatOptions): Promise<Stats | BigIntStats>;
+    statSync(p: PortablePath): Stats;
+    statSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    statSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+    }): Stats;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+    }): BigIntStats;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false | undefined;
+    }): Stats | BigIntStats;
+    fstatPromise(fd: number): Promise<Stats>;
+    fstatPromise(fd: number, opts: {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    fstatPromise(fd: number, opts?: {
+        bigint: boolean;
+    }): Promise<BigIntStats | Stats>;
+    fstatSync(fd: number): Stats;
+    fstatSync(fd: number, opts: {
+        bigint: true;
+    }): BigIntStats;
+    fstatSync(fd: number, opts?: {
+        bigint: boolean;
+    }): BigIntStats | Stats;
+    lstatPromise(p: PortablePath): Promise<Stats>;
+    lstatPromise(p: PortablePath, opts: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined): Promise<Stats>;
+    lstatPromise(p: PortablePath, opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    lstatSync(p: PortablePath): Stats;
+    lstatSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    lstatSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+    }): Stats;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+    }): BigIntStats;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false | undefined;
+    }): Stats | BigIntStats;
+    fchmodPromise(fd: number, mask: number): Promise<void>;
+    fchmodSync(fd: number, mask: number): void;
+    chmodPromise(p: PortablePath, mask: number): Promise<void>;
+    chmodSync(p: PortablePath, mask: number): void;
+    fchownPromise(fd: number, uid: number, gid: number): Promise<void>;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    chownPromise(p: PortablePath, uid: number, gid: number): Promise<void>;
+    chownSync(p: PortablePath, uid: number, gid: number): void;
+    renamePromise(oldP: PortablePath, newP: PortablePath): Promise<void>;
+    renameSync(oldP: PortablePath, newP: PortablePath): void;
+    copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags?: number): Promise<void>;
+    copyFileSync(sourceP: PortablePath, destP: PortablePath, flags?: number): void;
+    appendFilePromise(p: FSPath<PortablePath>, content: string | Uint8Array, opts?: WriteFileOptions): Promise<void>;
+    appendFileSync(p: FSPath<PortablePath>, content: string | Uint8Array, opts?: WriteFileOptions): void;
+    writeFilePromise(p: FSPath<PortablePath>, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): Promise<void>;
+    writeFileSync(p: FSPath<PortablePath>, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): void;
+    unlinkPromise(p: PortablePath): Promise<void>;
+    unlinkSync(p: PortablePath): void;
+    utimesPromise(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
+    utimesSync(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): void;
+    lutimesPromise(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
+    lutimesSync(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): void;
+    mkdirPromise(p: PortablePath, opts?: MkdirOptions): Promise<string | undefined>;
+    mkdirSync(p: PortablePath, opts?: MkdirOptions): string | undefined;
+    rmdirPromise(p: PortablePath, opts?: RmdirOptions): Promise<void>;
+    rmdirSync(p: PortablePath, opts?: RmdirOptions): void;
+    rmPromise(p: PortablePath, opts?: RmOptions): Promise<void>;
+    rmSync(p: PortablePath, opts?: RmOptions): void;
+    linkPromise(existingP: PortablePath, newP: PortablePath): Promise<void>;
+    linkSync(existingP: PortablePath, newP: PortablePath): void;
+    symlinkPromise(target: PortablePath, p: PortablePath, type?: SymlinkType): Promise<void>;
+    symlinkSync(target: PortablePath, p: PortablePath, type?: SymlinkType): void;
+    readFilePromise(p: FSPath<PortablePath>, encoding?: null): Promise<NonSharedBuffer>;
+    readFilePromise(p: FSPath<PortablePath>, encoding: BufferEncoding): Promise<string>;
+    readFilePromise(p: FSPath<PortablePath>, encoding?: BufferEncoding | null): Promise<NonSharedBuffer | string>;
+    readFileSync(p: FSPath<PortablePath>, encoding?: null): NonSharedBuffer;
+    readFileSync(p: FSPath<PortablePath>, encoding: BufferEncoding): string;
+    readFileSync(p: FSPath<PortablePath>, encoding?: BufferEncoding | null): NonSharedBuffer | string;
+    readdirPromise(p: PortablePath, opts?: null): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: true;
+    }): Promise<Array<DirentNoPath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes?: false;
+    }): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: boolean;
+    }): Promise<Array<DirentNoPath | Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: true;
+    }): Promise<Array<Dirent<PortablePath>>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes?: false;
+    }): Promise<Array<PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: boolean;
+    }): Promise<Array<Dirent<PortablePath> | PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: true;
+    }): Promise<Array<Dirent<PortablePath> | DirentNoPath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes?: false;
+    }): Promise<Array<PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: boolean;
+    }): Promise<Array<Dirent<PortablePath> | DirentNoPath | PortablePath>>;
+    readdirSync(p: PortablePath, opts?: null): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: true;
+    }): Array<DirentNoPath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes?: false;
+    }): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: boolean;
+    }): Array<DirentNoPath | Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: true;
+    }): Array<Dirent<PortablePath>>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes?: false;
+    }): Array<PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: boolean;
+    }): Array<Dirent<PortablePath> | PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: true;
+    }): Array<Dirent<PortablePath> | DirentNoPath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes?: false;
+    }): Array<PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: boolean;
+    }): Array<Dirent<PortablePath> | DirentNoPath | PortablePath>;
+    readlinkPromise(p: PortablePath): Promise<PortablePath>;
+    readlinkSync(p: PortablePath): PortablePath;
+    truncatePromise(p: PortablePath, len?: number): Promise<void>;
+    truncateSync(p: PortablePath, len?: number): void;
+    ftruncatePromise(fd: number, len?: number): Promise<void>;
+    ftruncateSync(fd: number, len?: number): void;
+    watch(p: PortablePath, cb?: WatchCallback): Watcher;
+    watch(p: PortablePath, opts: WatchOptions, cb?: WatchCallback): Watcher;
+    watchFile(p: PortablePath, cb: WatchFileCallback): StatWatcher;
+    watchFile(p: PortablePath, opts: WatchFileOptions, cb: WatchFileCallback): StatWatcher;
+    unwatchFile(p: PortablePath, cb?: WatchFileCallback): void;
+    private makeCallPromise;
+    private makeCallSync;
+    private findMount;
+    private limitOpenFilesTimeout;
+    private limitOpenFiles;
+    private getMountPromise;
+    private getMountSync;
+}