memfs 3.5.3 → 4.0.0

package/lib/node/types/misc.d.ts

@@ -0,0 +1,112 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { PathLike, symlink } from 'fs';
+import type { constants } from '../../constants';
+import type { EventEmitter } from 'events';
+import type { TSetTimeout } from '../../setTimeoutUnref';
+import type { IAppendFileOptions, IReadFileOptions, IReadStreamOptions, IStatOptions, IWriteFileOptions, IWriteStreamOptions } from './options';
+import type { Readable, Writable } from 'stream';
+export { PathLike, symlink };
+export type TDataOut = string | Buffer;
+export type TEncodingExtended = BufferEncoding | 'buffer';
+export type TFileId = PathLike | number;
+export type TData = TDataOut | ArrayBufferView | DataView;
+export type TFlags = string | number;
+export type TMode = string | number;
+export type TTime = number | string | Date;
+export type TCallback<TData> = (error?: IError | null, data?: TData) => void;
+export interface IError extends Error {
+    code?: string;
+}
+export type TFlagsCopy = typeof constants.COPYFILE_EXCL | typeof constants.COPYFILE_FICLONE | typeof constants.COPYFILE_FICLONE_FORCE;
+export type TStatNumber = number | bigint;
+export interface IStats<T = TStatNumber> {
+    uid: T;
+    gid: T;
+    rdev: T;
+    blksize: T;
+    ino: T;
+    size: T;
+    blocks: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    dev: T;
+    mode: T;
+    nlink: T;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface IDirent {
+    name: TDataOut;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface IStatWatcher extends EventEmitter {
+    filename: string;
+    interval: number;
+    timeoutRef?: any;
+    setTimeout: TSetTimeout;
+    prev: IStats;
+    start(path: string, persistent?: boolean, interval?: number): void;
+    stop(): void;
+}
+export interface IReadStream extends Readable {
+    new (path: PathLike, options: IReadStreamOptions): any;
+    open(): any;
+    close(callback: TCallback<void>): any;
+    bytesRead: number;
+    path: string;
+}
+export interface IWriteStream extends Writable {
+    bytesWritten: number;
+    path: string;
+    new (path: PathLike, options: IWriteStreamOptions): any;
+    open(): any;
+    close(): any;
+}
+export interface IFSWatcher extends EventEmitter {
+    start(path: PathLike, persistent?: boolean, recursive?: boolean, encoding?: BufferEncoding): void;
+    close(): void;
+}
+export interface IFileHandle {
+    fd: number;
+    appendFile(data: TData, options?: IAppendFileOptions | string): Promise<void>;
+    chmod(mode: TMode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    close(): Promise<void>;
+    datasync(): Promise<void>;
+    read(buffer: Buffer | Uint8Array, offset: number, length: number, position: number): Promise<TFileHandleReadResult>;
+    readFile(options?: IReadFileOptions | string): Promise<TDataOut>;
+    stat(options?: IStatOptions): Promise<IStats>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: TTime, mtime: TTime): Promise<void>;
+    write(buffer: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): Promise<TFileHandleWriteResult>;
+    writeFile(data: TData, options?: IWriteFileOptions): Promise<void>;
+}
+export type TFileHandle = PathLike | IFileHandle;
+export interface TFileHandleReadResult {
+    bytesRead: number;
+    buffer: Buffer | Uint8Array;
+}
+export interface TFileHandleWriteResult {
+    bytesWritten: number;
+    buffer: Buffer | Uint8Array;
+}

package/lib/node/types/misc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/types/options.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import type { TEncodingExtended, TFlags, TMode } from './misc';
+export interface IOptions {
+    encoding?: BufferEncoding | TEncodingExtended;
+}
+export interface IFileOptions extends IOptions {
+    mode?: TMode;
+    flag?: TFlags;
+}
+export interface IWriteFileOptions extends IFileOptions {
+}
+export interface IReadFileOptions extends IOptions {
+    flag?: string;
+}
+export interface IRealpathOptions {
+    encoding?: TEncodingExtended;
+}
+export interface IAppendFileOptions extends IFileOptions {
+}
+export interface IStatOptions {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+}
+export interface IFStatOptions {
+    bigint?: boolean;
+}
+export interface IAppendFileOptions extends IFileOptions {
+}
+export interface IReaddirOptions extends IOptions {
+    withFileTypes?: boolean;
+}
+export interface IMkdirOptions {
+    mode?: TMode;
+    recursive?: boolean;
+}
+export interface IRmdirOptions {
+    /** @deprecated */
+    recursive?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+export interface IRmOptions {
+    force?: boolean;
+    maxRetries?: number;
+    recursive?: boolean;
+    retryDelay?: number;
+}
+export interface IWatchFileOptions {
+    persistent?: boolean;
+    interval?: number;
+}
+export interface IReadStreamOptions {
+    flags?: TFlags;
+    encoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+    end?: number;
+}
+export interface IWriteStreamOptions {
+    flags?: TFlags;
+    defaultEncoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+}
+export interface IWatchOptions extends IOptions {
+    persistent?: boolean;
+    recursive?: boolean;
+}

package/lib/node/types/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/types/promises.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as misc from './misc';
+import * as opts from './options';
+export interface FsPromisesApi {
+    FileHandle: new (...args: unknown[]) => misc.IFileHandle;
+    access(path: misc.PathLike, mode?: number): Promise<void>;
+    appendFile(path: misc.TFileHandle, data: misc.TData, options?: opts.IAppendFileOptions | string): Promise<void>;
+    chmod(path: misc.PathLike, mode: misc.TMode): Promise<void>;
+    chown(path: misc.PathLike, uid: number, gid: number): Promise<void>;
+    copyFile(src: misc.PathLike, dest: misc.PathLike, flags?: misc.TFlagsCopy): Promise<void>;
+    lchmod(path: misc.PathLike, mode: misc.TMode): Promise<void>;
+    lchown(path: misc.PathLike, uid: number, gid: number): Promise<void>;
+    link(existingPath: misc.PathLike, newPath: misc.PathLike): Promise<void>;
+    lstat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats>;
+    mkdir(path: misc.PathLike, options?: misc.TMode | opts.IMkdirOptions): Promise<void>;
+    mkdtemp(prefix: string, options?: opts.IOptions): Promise<misc.TDataOut>;
+    open(path: misc.PathLike, flags: misc.TFlags, mode?: misc.TMode): Promise<misc.IFileHandle>;
+    readdir(path: misc.PathLike, options?: opts.IReaddirOptions | string): Promise<misc.TDataOut[] | misc.IDirent[]>;
+    readFile(id: misc.TFileHandle, options?: opts.IReadFileOptions | string): Promise<misc.TDataOut>;
+    readlink(path: misc.PathLike, options?: opts.IOptions): Promise<misc.TDataOut>;
+    realpath(path: misc.PathLike, options?: opts.IRealpathOptions | string): Promise<misc.TDataOut>;
+    rename(oldPath: misc.PathLike, newPath: misc.PathLike): Promise<void>;
+    rmdir(path: misc.PathLike, options?: opts.IRmdirOptions): Promise<void>;
+    rm(path: misc.PathLike, options?: opts.IRmOptions): Promise<void>;
+    stat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats>;
+    symlink(target: misc.PathLike, path: misc.PathLike, type?: misc.symlink.Type): Promise<void>;
+    truncate(path: misc.PathLike, len?: number): Promise<void>;
+    unlink(path: misc.PathLike): Promise<void>;
+    utimes(path: misc.PathLike, atime: misc.TTime, mtime: misc.TTime): Promise<void>;
+    writeFile(id: misc.TFileHandle, data: misc.TData, options?: opts.IWriteFileOptions): Promise<void>;
+}

package/lib/node/types/promises.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/types/sync.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { PathLike, symlink } from 'fs';
+import type * as misc from './misc';
+import type * as opts from './options';
+export interface FsSynchronousApi {
+    openSync(path: PathLike, flags: misc.TFlags, mode?: misc.TMode): number;
+    closeSync(fd: number): void;
+    readSync(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, length: number, position: number): number;
+    readFileSync(file: misc.TFileId, options?: opts.IReadFileOptions | string): misc.TDataOut;
+    writeSync(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, str: string, position?: number, encoding?: BufferEncoding): number;
+    writeFileSync(id: misc.TFileId, data: misc.TData, options?: opts.IWriteFileOptions): void;
+    copyFileSync(src: PathLike, dest: PathLike, flags?: misc.TFlagsCopy): void;
+    linkSync(existingPath: PathLike, newPath: PathLike): void;
+    unlinkSync(path: PathLike): void;
+    symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type): void;
+    realpathSync(path: PathLike, options?: opts.IRealpathOptions | string): misc.TDataOut;
+    lstatSync(path: PathLike): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<bigint>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): misc.IStats<bigint> | undefined;
+    statSync(path: PathLike): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry?: true;
+    }): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true;
+    }): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true;
+    }): misc.IStats<bigint>;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): misc.IStats<bigint> | undefined;
+    fstatSync(fd: number): misc.IStats<number>;
+    fstatSync(fd: number, options: {
+        bigint: false;
+    }): misc.IStats<number>;
+    fstatSync(fd: number, options: {
+        bigint: true;
+    }): misc.IStats<bigint>;
+    renameSync(oldPath: PathLike, newPath: PathLike): void;
+    existsSync(path: PathLike): boolean;
+    accessSync(path: PathLike, mode?: number): void;
+    appendFileSync(id: misc.TFileId, data: misc.TData, options?: opts.IAppendFileOptions | string): void;
+    readdirSync(path: PathLike, options?: opts.IReaddirOptions | string): misc.TDataOut[] | misc.IDirent[];
+    readlinkSync(path: PathLike, options?: opts.IOptions): misc.TDataOut;
+    fdatasyncSync(fd: number): void;
+    ftruncateSync(fd: number, len?: number): void;
+    truncateSync(id: misc.TFileId, len?: number): void;
+    futimesSync(fd: number, atime: misc.TTime, mtime: misc.TTime): void;
+    utimesSync(path: PathLike, atime: misc.TTime, mtime: misc.TTime): void;
+    mkdirSync(path: PathLike, options: opts.IMkdirOptions & {
+        recursive: true;
+    }): string | undefined;
+    mkdirSync(path: PathLike, options?: misc.TMode | (opts.IMkdirOptions & {
+        recursive?: false;
+    })): void;
+    mkdirSync(path: PathLike, options?: misc.TMode | opts.IMkdirOptions): string | undefined;
+    mkdirpSync(path: PathLike, mode?: misc.TMode): void;
+    mkdtempSync(prefix: string, options?: opts.IOptions): misc.TDataOut;
+    rmdirSync(path: PathLike, options?: opts.IRmdirOptions): void;
+    rmSync(path: PathLike, options?: opts.IRmOptions): void;
+    fchmodSync(fd: number, mode: misc.TMode): void;
+    chmodSync(path: PathLike, mode: misc.TMode): void;
+    lchmodSync(path: PathLike, mode: misc.TMode): void;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    chownSync(path: PathLike, uid: number, gid: number): void;
+    lchownSync(path: PathLike, uid: number, gid: number): void;
+}

package/lib/node/types/sync.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/util.d.ts

@@ -0,0 +1,2 @@
+import type { FsCallbackApi } from './types';
+export declare function promisify(fs: FsCallbackApi, fn: string, getResult?: (result: any) => any): (...args: any[]) => Promise<any>;

package/lib/node/util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promisify = void 0;
+function promisify(fs, fn, getResult = input => input) {
+    return (...args) => new Promise((resolve, reject) => {
+        fs[fn].bind(fs)(...args, (error, result) => {
+            if (error)
+                return reject(error);
+            return resolve(getResult(result));
+        });
+    });
+}
+exports.promisify = promisify;

package/lib/node.d.ts

@@ -48,7 +48,7 @@ export declare class Node extends EventEmitter {
     isSymlink(): boolean;
     makeSymlink(steps: string[]): void;
     write(buf: Buffer, off?: number, len?: number, pos?: number): number;
-    read(buf: Buffer | Uint8Array, off?: number, len?: number, pos?: number): number;
+    read(buf: Buffer | ArrayBufferView | DataView, off?: number, len?: number, pos?: number): number;
     truncate(len?: number): void;
     chmod(perm: number): void;
     chown(uid: number, gid: number): void;
@@ -150,7 +150,7 @@ export declare class File {
     seekTo(position: number): void;
     stats(): Stats<number>;
     write(buf: Buffer, offset?: number, length?: number, position?: number): number;
-    read(buf: Buffer | Uint8Array, offset?: number, length?: number, position?: number): number;
+    read(buf: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): number;
     chmod(perm: number): void;
     chown(uid: number, gid: number): void;
 }