@pnpm/exe 12.9.0 → 12.9.1

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

@@ -1,278 +0,0 @@
-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;
-}