memfs 3.6.0 → 4.1.0

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { TEncodingExtended, TFlags, TMode } from './misc';
+import type { IFileHandle, TEncodingExtended, TFlags, TMode } from './misc';
 export interface IOptions {
     encoding?: BufferEncoding | TEncodingExtended;
 }
@@ -34,7 +34,6 @@ export interface IMkdirOptions {
     recursive?: boolean;
 }
 export interface IRmdirOptions {
-    /** @deprecated */
     recursive?: boolean;
     maxRetries?: number;
     retryDelay?: number;
@@ -49,21 +48,36 @@ export interface IWatchFileOptions {
     persistent?: boolean;
     interval?: number;
 }
-export interface IReadStreamOptions {
+export interface IReadStreamOptions extends IOptions {
+    /** Defaults to `'r'`. */
     flags?: TFlags;
+    /** Defaults to `null`. */
     encoding?: BufferEncoding;
-    fd?: number;
+    /** Defaults to `null`. */
+    fd?: number | IFileHandle | null;
+    /** Defaults to 0o666 */
     mode?: TMode;
+    /** Defaults to `true`. */
     autoClose?: boolean;
+    /** Defaults to `true`. */
+    emitClose?: boolean;
     start?: number;
+    /** Defaults to `Infinity`. */
     end?: number;
+    /** Defaults to `64 * 1024`. */
+    highWaterMark?: number;
+    /** Defaults to `null`. */
+    fs?: object | null;
+    /** Defaults to `null`. */
+    signal?: AbortSignal | null;
 }
 export interface IWriteStreamOptions {
     flags?: TFlags;
-    defaultEncoding?: BufferEncoding;
-    fd?: number;
+    encoding?: BufferEncoding;
+    fd?: number | IFileHandle;
     mode?: TMode;
     autoClose?: boolean;
+    emitClose?: boolean;
     start?: number;
 }
 export interface IWatchOptions extends IOptions {

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

@@ -12,9 +12,9 @@ export interface FsPromisesApi {
     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>;
+    mkdir(path: misc.PathLike, options?: misc.TMode | opts.IMkdirOptions): Promise<string | undefined>;
     mkdtemp(prefix: string, options?: opts.IOptions): Promise<misc.TDataOut>;
-    open(path: misc.PathLike, flags: misc.TFlags, mode?: misc.TMode): Promise<misc.IFileHandle>;
+    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>;

package/lib/node/util.d.ts

@@ -1,2 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import type { FsCallbackApi } from './types';
+import type * as misc from './types/misc';
+import { TEncodingExtended } from '../encoding';
+export declare const isWin: boolean;
 export declare function promisify(fs: FsCallbackApi, fn: string, getResult?: (result: any) => any): (...args: any[]) => Promise<any>;
+export declare function validateCallback<T>(callback: T): misc.AssertCallback<T>;
+export declare function modeToNumber(mode: misc.TMode | undefined, def?: any): number;
+export declare function nullCheck(path: any, callback?: any): boolean;
+export declare function pathToFilename(path: misc.PathLike): string;
+export declare function createError(errorCode: string, func?: string, path?: string, path2?: string, Constructor?: ErrorConstructor): Error;
+export declare function genRndStr6(): string;
+export declare function flagsToNumber(flags: misc.TFlags | undefined): number;
+export declare function isFd(path: any): boolean;
+export declare function validateFd(fd: any): void;
+export declare function dataToBuffer(data: misc.TData, encoding?: string): Buffer;
+export declare const bufToUint8: (buf: Buffer) => Uint8Array;
+export declare const getWriteArgs: (fd: number, a?: unknown, b?: unknown, c?: unknown, d?: unknown, e?: unknown) => [fd: number, dataAsStr: boolean, buf: Buffer, offset: number, length: number, position: number | null, callback: (...args: any[]) => void];
+export declare const getWriteSyncArgs: (fd: number, a: string | Buffer | ArrayBufferView | DataView, b?: number, c?: number | BufferEncoding, d?: number) => [fd: number, buf: Buffer, offset: number, length?: number | undefined, position?: number | undefined];
+export declare function bufferToEncoding(buffer: Buffer, encoding?: TEncodingExtended): misc.TDataOut;

package/lib/node/util.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisify = void 0;
+exports.bufferToEncoding = exports.getWriteSyncArgs = exports.getWriteArgs = exports.bufToUint8 = exports.dataToBuffer = exports.validateFd = exports.isFd = exports.flagsToNumber = exports.genRndStr6 = exports.createError = exports.pathToFilename = exports.nullCheck = exports.modeToNumber = exports.validateCallback = exports.promisify = exports.isWin = void 0;
+const constants_1 = require("./constants");
+const errors = require("../internal/errors");
+const encoding_1 = require("../encoding");
+const buffer_1 = require("../internal/buffer");
+exports.isWin = process.platform === 'win32';
 function promisify(fs, fn, getResult = input => input) {
     return (...args) => new Promise((resolve, reject) => {
         fs[fn].bind(fs)(...args, (error, result) => {
@@ -11,3 +16,262 @@ function promisify(fs, fn, getResult = input => input) {
     });
 }
 exports.promisify = promisify;
+function validateCallback(callback) {
+    if (typeof callback !== 'function')
+        throw TypeError(constants_1.ERRSTR.CB);
+    return callback;
+}
+exports.validateCallback = validateCallback;
+function _modeToNumber(mode, def) {
+    if (typeof mode === 'number')
+        return mode;
+    if (typeof mode === 'string')
+        return parseInt(mode, 8);
+    if (def)
+        return modeToNumber(def);
+    return undefined;
+}
+function modeToNumber(mode, def) {
+    const result = _modeToNumber(mode, def);
+    if (typeof result !== 'number' || isNaN(result))
+        throw new TypeError(constants_1.ERRSTR.MODE_INT);
+    return result;
+}
+exports.modeToNumber = modeToNumber;
+function nullCheck(path, callback) {
+    if (('' + path).indexOf('\u0000') !== -1) {
+        const er = new Error('Path must be a string without null bytes');
+        er.code = 'ENOENT';
+        if (typeof callback !== 'function')
+            throw er;
+        process.nextTick(callback, er);
+        return false;
+    }
+    return true;
+}
+exports.nullCheck = nullCheck;
+function getPathFromURLPosix(url) {
+    if (url.hostname !== '') {
+        throw new errors.TypeError('ERR_INVALID_FILE_URL_HOST', process.platform);
+    }
+    const pathname = url.pathname;
+    for (let n = 0; n < pathname.length; n++) {
+        if (pathname[n] === '%') {
+            const third = pathname.codePointAt(n + 2) | 0x20;
+            if (pathname[n + 1] === '2' && third === 102) {
+                throw new errors.TypeError('ERR_INVALID_FILE_URL_PATH', 'must not include encoded / characters');
+            }
+        }
+    }
+    return decodeURIComponent(pathname);
+}
+function pathToFilename(path) {
+    if (typeof path !== 'string' && !Buffer.isBuffer(path)) {
+        try {
+            if (!(path instanceof require('url').URL))
+                throw new TypeError(constants_1.ERRSTR.PATH_STR);
+        }
+        catch (err) {
+            throw new TypeError(constants_1.ERRSTR.PATH_STR);
+        }
+        path = getPathFromURLPosix(path);
+    }
+    const pathString = String(path);
+    nullCheck(pathString);
+    // return slash(pathString);
+    return pathString;
+}
+exports.pathToFilename = pathToFilename;
+const ENOENT = 'ENOENT';
+const EBADF = 'EBADF';
+const EINVAL = 'EINVAL';
+const EPERM = 'EPERM';
+const EPROTO = 'EPROTO';
+const EEXIST = 'EEXIST';
+const ENOTDIR = 'ENOTDIR';
+const EMFILE = 'EMFILE';
+const EACCES = 'EACCES';
+const EISDIR = 'EISDIR';
+const ENOTEMPTY = 'ENOTEMPTY';
+const ENOSYS = 'ENOSYS';
+const ERR_FS_EISDIR = 'ERR_FS_EISDIR';
+function formatError(errorCode, func = '', path = '', path2 = '') {
+    let pathFormatted = '';
+    if (path)
+        pathFormatted = ` '${path}'`;
+    if (path2)
+        pathFormatted += ` -> '${path2}'`;
+    switch (errorCode) {
+        case ENOENT:
+            return `ENOENT: no such file or directory, ${func}${pathFormatted}`;
+        case EBADF:
+            return `EBADF: bad file descriptor, ${func}${pathFormatted}`;
+        case EINVAL:
+            return `EINVAL: invalid argument, ${func}${pathFormatted}`;
+        case EPERM:
+            return `EPERM: operation not permitted, ${func}${pathFormatted}`;
+        case EPROTO:
+            return `EPROTO: protocol error, ${func}${pathFormatted}`;
+        case EEXIST:
+            return `EEXIST: file already exists, ${func}${pathFormatted}`;
+        case ENOTDIR:
+            return `ENOTDIR: not a directory, ${func}${pathFormatted}`;
+        case EISDIR:
+            return `EISDIR: illegal operation on a directory, ${func}${pathFormatted}`;
+        case EACCES:
+            return `EACCES: permission denied, ${func}${pathFormatted}`;
+        case ENOTEMPTY:
+            return `ENOTEMPTY: directory not empty, ${func}${pathFormatted}`;
+        case EMFILE:
+            return `EMFILE: too many open files, ${func}${pathFormatted}`;
+        case ENOSYS:
+            return `ENOSYS: function not implemented, ${func}${pathFormatted}`;
+        case ERR_FS_EISDIR:
+            return `[ERR_FS_EISDIR]: Path is a directory: ${func} returned EISDIR (is a directory) ${path}`;
+        default:
+            return `${errorCode}: error occurred, ${func}${pathFormatted}`;
+    }
+}
+function createError(errorCode, func = '', path = '', path2 = '', Constructor = Error) {
+    const error = new Constructor(formatError(errorCode, func, path, path2));
+    error.code = errorCode;
+    if (path) {
+        error.path = path;
+    }
+    return error;
+}
+exports.createError = createError;
+function genRndStr6() {
+    const str = (Math.random() + 1).toString(36).substring(2, 8);
+    if (str.length === 6)
+        return str;
+    else
+        return genRndStr6();
+}
+exports.genRndStr6 = genRndStr6;
+function flagsToNumber(flags) {
+    if (typeof flags === 'number')
+        return flags;
+    if (typeof flags === 'string') {
+        const flagsNum = constants_1.FLAGS[flags];
+        if (typeof flagsNum !== 'undefined')
+            return flagsNum;
+    }
+    // throw new TypeError(formatError(ERRSTR_FLAG(flags)));
+    throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'flags', flags);
+}
+exports.flagsToNumber = flagsToNumber;
+function isFd(path) {
+    return path >>> 0 === path;
+}
+exports.isFd = isFd;
+function validateFd(fd) {
+    if (!isFd(fd))
+        throw TypeError(constants_1.ERRSTR.FD);
+}
+exports.validateFd = validateFd;
+function dataToBuffer(data, encoding = encoding_1.ENCODING_UTF8) {
+    if (Buffer.isBuffer(data))
+        return data;
+    else if (data instanceof Uint8Array)
+        return (0, buffer_1.bufferFrom)(data);
+    else
+        return (0, buffer_1.bufferFrom)(String(data), encoding);
+}
+exports.dataToBuffer = dataToBuffer;
+const bufToUint8 = (buf) => new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+exports.bufToUint8 = bufToUint8;
+const getWriteArgs = (fd, a, b, c, d, e) => {
+    validateFd(fd);
+    let offset = 0;
+    let length;
+    let position = null;
+    let encoding;
+    let callback;
+    const tipa = typeof a;
+    const tipb = typeof b;
+    const tipc = typeof c;
+    const tipd = typeof d;
+    if (tipa !== 'string') {
+        if (tipb === 'function') {
+            callback = b;
+        }
+        else if (tipc === 'function') {
+            offset = b | 0;
+            callback = c;
+        }
+        else if (tipd === 'function') {
+            offset = b | 0;
+            length = c;
+            callback = d;
+        }
+        else {
+            offset = b | 0;
+            length = c;
+            position = d;
+            callback = e;
+        }
+    }
+    else {
+        if (tipb === 'function') {
+            callback = b;
+        }
+        else if (tipc === 'function') {
+            position = b;
+            callback = c;
+        }
+        else if (tipd === 'function') {
+            position = b;
+            encoding = c;
+            callback = d;
+        }
+    }
+    const buf = dataToBuffer(a, encoding);
+    if (tipa !== 'string') {
+        if (typeof length === 'undefined')
+            length = buf.length;
+    }
+    else {
+        offset = 0;
+        length = buf.length;
+    }
+    const cb = validateCallback(callback);
+    return [fd, tipa === 'string', buf, offset, length, position, cb];
+};
+exports.getWriteArgs = getWriteArgs;
+const getWriteSyncArgs = (fd, a, b, c, d) => {
+    validateFd(fd);
+    let encoding;
+    let offset;
+    let length;
+    let position;
+    const isBuffer = typeof a !== 'string';
+    if (isBuffer) {
+        offset = (b || 0) | 0;
+        length = c;
+        position = d;
+    }
+    else {
+        position = b;
+        encoding = c;
+    }
+    const buf = dataToBuffer(a, encoding);
+    if (isBuffer) {
+        if (typeof length === 'undefined') {
+            length = buf.length;
+        }
+    }
+    else {
+        offset = 0;
+        length = buf.length;
+    }
+    return [fd, buf, offset || 0, length, position];
+};
+exports.getWriteSyncArgs = getWriteSyncArgs;
+function bufferToEncoding(buffer, encoding) {
+    if (!encoding || encoding === 'buffer')
+        return buffer;
+    else
+        return buffer.toString(encoding);
+}
+exports.bufferToEncoding = bufferToEncoding;

package/lib/node-to-fsa/NodeFileSystemDirectoryHandle.d.ts

@@ -0,0 +1,71 @@
+import { NodeFileSystemHandle } from './NodeFileSystemHandle';
+import type { NodeFsaContext, NodeFsaFs } from './types';
+import type { GetDirectoryHandleOptions, GetFileHandleOptions, IFileSystemDirectoryHandle, IFileSystemFileHandle, RemoveEntryOptions } from '../fsa/types';
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle
+ */
+export declare class NodeFileSystemDirectoryHandle extends NodeFileSystemHandle implements IFileSystemDirectoryHandle {
+    protected readonly fs: NodeFsaFs;
+    readonly __path: string;
+    protected readonly ctx: Partial<NodeFsaContext>;
+    constructor(fs: NodeFsaFs, __path: string, ctx?: Partial<NodeFsaContext>);
+    /**
+     * Returns a new array iterator containing the keys for each item in
+     * {@link NodeFileSystemDirectoryHandle} object.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/keys
+     */
+    keys(): AsyncIterableIterator<string>;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/entries
+     */
+    entries(): AsyncIterableIterator<[string, NodeFileSystemHandle]>;
+    /**
+     * Returns a new array iterator containing the values for each index in the
+     * {@link FileSystemDirectoryHandle} object.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/values
+     */
+    values(): AsyncIterableIterator<NodeFileSystemHandle>;
+    /**
+     * Returns a {@link NodeFileSystemDirectoryHandle} for a subdirectory with the specified
+     * name within the directory handle on which the method is called.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/getDirectoryHandle
+     * @param name A string representing the {@link NodeFileSystemHandle} name of
+     *        the subdirectory you wish to retrieve.
+     * @param options An optional object containing options for the retrieved
+     *        subdirectory.
+     */
+    getDirectoryHandle(name: string, options?: GetDirectoryHandleOptions): Promise<IFileSystemDirectoryHandle>;
+    /**
+     * Returns a {@link FileSystemFileHandle} for a file with the specified name,
+     * within the directory the method is called.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/getFileHandle
+     * @param name A string representing the {@link NodeFileSystemHandle} name of
+     *        the file you wish to retrieve.
+     * @param options An optional object containing options for the retrieved file.
+     */
+    getFileHandle(name: string, options?: GetFileHandleOptions): Promise<IFileSystemFileHandle>;
+    /**
+     * Attempts to remove an entry if the directory handle contains a file or
+     * directory called the name specified.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/removeEntry
+     * @param name A string representing the {@link FileSystemHandle} name of the
+     *        entry you wish to remove.
+     * @param options An optional object containing options.
+     */
+    removeEntry(name: string, { recursive }?: RemoveEntryOptions): Promise<void>;
+    /**
+     * The `resolve()` method of the {@link FileSystemDirectoryHandle} interface
+     * returns an {@link Array} of directory names from the parent handle to the specified
+     * child entry, with the name of the child entry as the last array item.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle/resolve
+     * @param possibleDescendant The {@link NodeFileSystemFileHandle} from which
+     *        to return the relative path.
+     */
+    resolve(possibleDescendant: NodeFileSystemHandle): Promise<string[] | null>;
+}