@zenfs/core 0.5.4 → 0.5.6

package/dist/emulation/promises.js

@@ -1,11 +1,12 @@
+import { Buffer } from 'buffer';
 import { ApiError, ErrorCode } from '../ApiError.js';
-export * as constants from './constants.js';
-import { ActionType, isReadable, isWriteable, isAppendable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
-import { normalizePath, normalizeMode, getFdForFile, normalizeOptions, fd2file, fdMap, normalizeTime, cred, nop, resolveFS, fixError, mounts } from './shared.js';
+import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
-import { decode, encode } from '../utils.js';
+import { F_OK } from './constants.js';
 import { Dirent } from './dir.js';
 import { dirname, join } from './path.js';
+import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, normalizeMode, normalizeOptions, normalizePath, normalizeTime, resolveFS } from './shared.js';
+export * as constants from './constants.js';
 export class FileHandle {
     constructor(
     /**
@@ -14,11 +15,17 @@ export class FileHandle {
     fd) {
         this.fd = fd;
     }
+    get file() {
+        return fd2file(this.fd);
+    }
+    get path() {
+        return this.file.path;
+    }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     chown(uid, gid) {
-        return fd2file(this.fd).chown(uid, gid);
+        return this.file.chown(uid, gid);
     }
     /**
      * Asynchronous fchmod(2) - Change permissions of a file.
@@ -29,19 +36,19 @@ export class FileHandle {
         if (numMode < 0) {
             throw new ApiError(ErrorCode.EINVAL, 'Invalid mode.');
         }
-        return fd2file(this.fd).chmod(numMode);
+        return this.file.chmod(numMode);
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
      */
     datasync() {
-        return fd2file(this.fd).datasync();
+        return this.file.datasync();
     }
     /**
      * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
      */
     sync() {
-        return fd2file(this.fd).sync();
+        return this.file.sync();
     }
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
@@ -51,7 +58,7 @@ export class FileHandle {
         if (len < 0) {
             throw new ApiError(ErrorCode.EINVAL);
         }
-        return fd2file(this.fd).truncate(len);
+        return this.file.truncate(len);
     }
     /**
      * Asynchronously change file timestamps of the file.
@@ -59,7 +66,7 @@ export class FileHandle {
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
     utimes(atime, mtime) {
-        return fd2file(this.fd).utimes(normalizeTime(atime), normalizeTime(mtime));
+        return this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
     /**
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
@@ -80,8 +87,8 @@ export class FileHandle {
         if (typeof data != 'string' && !options.encoding) {
             throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
         }
-        const encodedData = typeof data == 'string' ? encode(data) : data;
-        await fd2file(this.fd).write(encodedData, 0, encodedData.length, null);
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
+        await this.file.write(encodedData, 0, encodedData.length, null);
     }
     /**
      * Asynchronously reads data from the file.
@@ -93,23 +100,44 @@ export class FileHandle {
      */
     read(buffer, offset, length, position) {
         if (isNaN(+position)) {
-            position = fd2file(this.fd).position;
+            position = this.file.position;
         }
-        return fd2file(this.fd).read(buffer, offset, length, position);
+        return this.file.read(buffer, offset, length, position);
     }
     async readFile(_options) {
-        const options = normalizeOptions(_options, null, 'r', null);
+        const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
             throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
         }
         const { size } = await this.stat();
         const data = new Uint8Array(size);
-        await fd2file(this.fd).read(data, 0, size, 0);
-        return options.encoding ? decode(data, options.encoding) : data;
+        await this.file.read(data, 0, size, 0);
+        const buffer = Buffer.from(data);
+        return options.encoding ? buffer.toString(options.encoding) : buffer;
+    }
+    /**
+     * Returns a `ReadableStream` that may be used to read the files data.
+     *
+     * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
+     * or closing.
+     *
+     * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
+     *
+     * @since v17.0.0
+     * @experimental
+     */
+    readableWebStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readableWebStream');
+    }
+    readLines(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readLines');
+    }
+    [Symbol.asyncDispose]() {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.@@asyncDispose');
     }
     async stat(opts) {
-        const stats = await fd2file(this.fd).stat();
+        const stats = await this.file.stat();
         return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
@@ -119,7 +147,7 @@ export class FileHandle {
             position = typeof posOrOff === 'number' ? posOrOff : null;
             const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
             offset = 0;
-            buffer = encode(data, encoding);
+            buffer = Buffer.from(data, encoding);
             length = buffer.length;
         }
         else {
@@ -129,8 +157,8 @@ export class FileHandle {
             length = lenOrEnc;
             position = typeof position === 'number' ? position : null;
         }
-        position ?? (position = fd2file(this.fd).position);
-        const bytesWritten = await fd2file(this.fd).write(buffer, offset, length, position);
+        position ?? (position = this.file.position);
+        const bytesWritten = await this.file.write(buffer, offset, length, position);
         return { buffer, bytesWritten };
     }
     /**
@@ -153,28 +181,36 @@ export class FileHandle {
         if (typeof data != 'string' && !options.encoding) {
             throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
         }
-        const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
-        await fd2file(this.fd).write(encodedData, 0, encodedData.length, 0);
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
+        await this.file.write(encodedData, 0, encodedData.length, 0);
     }
     /**
      * See `fs.writev` promisified version.
+     * @todo Implement
      */
     writev(buffers, position) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.writev');
     }
     /**
      * See `fs.readv` promisified version.
+     * @todo Implement
      */
     readv(buffers, position) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readv');
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
      */
     async close() {
-        await fd2file(this.fd).close();
+        await this.file.close();
         fdMap.delete(this.fd);
     }
+    createReadStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'createReadStream');
+    }
+    createWriteStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'createWriteStream');
+    }
 }
 /**
  * Utility for FS ops. It handles
@@ -208,15 +244,18 @@ async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
 export async function rename(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const { path: old } = resolveFS(oldPath);
-    const { fs, path } = resolveFS(newPath);
+    const src = resolveFS(oldPath);
+    const dst = resolveFS(newPath);
     try {
-        const data = await readFile(oldPath);
-        await writeFile(newPath, data);
+        if (src.mountPoint == dst.mountPoint) {
+            await src.fs.rename(src.path, dst.path, cred);
+            return;
+        }
+        await writeFile(newPath, await readFile(oldPath));
         await unlink(oldPath);
     }
     catch (e) {
-        throw fixError(e, { [old]: oldPath, [path]: newPath });
+        throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
     }
 }
 rename;
@@ -279,7 +318,7 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
     try {
         switch (pathExistsAction(flag)) {
             case ActionType.THROW:
-                throw ApiError.EEXIST(path);
+                throw ApiError.With('EEXIST', path, '_open');
             case ActionType.TRUNCATE:
                 /*
                     In a previous implementation, we deleted the file and
@@ -307,11 +346,11 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = await doOp('stat', resolveSymlinks, dirname(path), cred);
                 if (parentStats && !parentStats.isDirectory()) {
-                    throw ApiError.ENOTDIR(dirname(path));
+                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
                 }
                 return await doOp('createFile', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.ENOENT(path);
+                throw ApiError.With('ENOENT', path, '_open');
             default:
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
         }
@@ -359,8 +398,8 @@ export async function readFile(filename, _options) {
     if (!isReadable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
     }
-    const data = await _readFile(filename, options.flag, true);
-    return options.encoding ? decode(data, options.encoding) : data;
+    const data = Buffer.from(await _readFile(filename, options.flag, true));
+    return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile;
 /**
@@ -417,60 +456,10 @@ export async function appendFile(filename, data, _options) {
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? encode(data) : data;
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
     await _appendFile(filename, encodedData, options.flag, options.mode, true);
 }
 appendFile;
-export function write(handle, data, posOrOff, lenOrEnc, position) {
-    return handle.write(data, posOrOff, lenOrEnc, position);
-}
-write;
-/**
- * Read data from the file specified by `fd`.
- * @param handle
- * @param buffer The buffer that the data will be
- *   written to.
- * @param offset The offset within the buffer where writing will
- *   start.
- * @param length An integer specifying the number of bytes to read.
- * @param position An integer specifying where to begin reading from
- *   in the file. If position is null, data will be read from the current file
- *   position.
- */
-export function read(handle, buffer, offset, length, position) {
-    return handle.read(buffer, offset, length, position);
-}
-read;
-/**
- * `fchown`.
- * @param handle
- * @param uid
- * @param gid
- */
-export function fchown(handle, uid, gid) {
-    return handle.chown(uid, gid);
-}
-fchown;
-/**
- * `fchmod`.
- * @param handle
- * @param mode
- */
-export function fchmod(handle, mode) {
-    return handle.chmod(mode);
-}
-fchmod;
-/**
- * Change the file timestamps of a file referenced by the supplied file
- * descriptor.
- * @param handle
- * @param atime
- * @param mtime
- */
-export function futimes(handle, atime, mtime) {
-    return handle.utimes(atime, mtime);
-}
-futimes;
 // DIRECTORY-ONLY METHODS
 /**
  * `rmdir`.
@@ -527,7 +516,7 @@ export async function symlink(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
     }
     if (await exists(path)) {
-        throw ApiError.EEXIST(path);
+        throw ApiError.With('EEXIST', path, 'symlink');
     }
     await writeFile(path, target);
     const file = await _open(path, 'r+', 0o644, false);
@@ -535,12 +524,12 @@ export async function symlink(target, path, type = 'file') {
 }
 symlink;
 export async function readlink(path, options) {
-    const value = await _readFile(path, 'r', false);
+    const value = Buffer.from(await _readFile(path, 'r', false));
     const encoding = typeof options == 'object' ? options.encoding : options;
     if (encoding == 'buffer') {
         return value;
     }
-    return decode(value, encoding);
+    return value.toString(encoding);
 }
 readlink;
 // PROPERTY OPERATIONS
@@ -646,7 +635,7 @@ export async function realpath(path, options) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = mountPoint + normalizePath(decode(await _readFile(resolvedPath, 'r+', false)));
+        const dst = mountPoint + normalizePath(Buffer.from(await _readFile(resolvedPath, 'r+', false)).toString());
         return realpath(dst);
     }
     catch (e) {
@@ -654,38 +643,51 @@ export async function realpath(path, options) {
     }
 }
 realpath;
-export async function watchFile(filename, arg2, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
-}
-export async function unwatchFile(filename, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
-}
-export async function watch(filename, arg2, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+export function watch(filename, options) {
+    throw ApiError.With('ENOTSUP', filename, 'watch');
 }
+watch;
 /**
  * `access`.
  * @param path
  * @param mode
  */
-export async function access(path, mode = 0o600) {
+export async function access(path, mode = F_OK) {
     const stats = await stat(path);
     if (!stats.hasAccess(mode, cred)) {
         throw new ApiError(ErrorCode.EACCES);
     }
 }
-export async function createReadStream(path, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+access;
+/**
+ * @todo Implement
+ */
+export async function rm(path, options) {
+    throw ApiError.With('ENOTSUP', path, 'rm');
 }
-export async function createWriteStream(path, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+rm;
+export async function mkdtemp(prefix, options) {
+    throw ApiError.With('ENOTSUP', prefix, 'mkdtemp');
 }
-export async function rm(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+mkdtemp;
+/**
+ * @todo Implement
+ */
+export async function copyFile(src, dest, mode) {
+    throw ApiError.With('ENOTSUP', src, 'copyFile');
+}
+copyFile;
+/**
+ * @todo Implement
+ */
+export async function opendir(path, options) {
+    throw ApiError.With('ENOTSUP', path, 'opendir');
 }
-export async function mkdtemp(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+opendir;
+export async function cp(source, destination, opts) {
+    throw ApiError.With('ENOTSUP', source, 'cp');
 }
-export async function copyFile(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+cp;
+export async function statfs(path, opts) {
+    throw ApiError.With('ENOTSUP', path, 'statfs');
 }

package/dist/emulation/shared.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { Cred } from '../cred.js';
 import { FileSystem } from '../filesystem.js';
 import type { File } from '../file.js';
+import type { EncodingOption, OpenMode, WriteFileOptions } from 'node:fs';
 /**
  * converts Date or number to a integer UNIX timestamp
  * Grabbed from NodeJS sources (lib/fs.js)
@@ -26,9 +28,15 @@ export declare function normalizeTime(time: string | number | Date): Date;
 export declare function normalizePath(p: string): string;
 /**
  * Normalizes options
+ * @param options options to normalize
+ * @param encoding default encoding
+ * @param flag default flag
+ * @param mode default mode
  * @internal
  */
-export declare function normalizeOptions(options: unknown, defEnc: string | null, defFlag: string, defMode: number | null): {
+export declare function normalizeOptions(options?: WriteFileOptions | (EncodingOption & {
+    flag?: OpenMode;
+}), encoding?: BufferEncoding, flag?: string, mode?: number): {
     encoding: BufferEncoding;
     flag: string;
     mode: number;
@@ -83,12 +91,3 @@ export declare function initialize(mountMapping: MountMapping): void;
  * In the future, maybe support URL?
  */
 export type PathLike = string;
-/**
- * @internal
- *
- * Recursivly converts `From` in `Target` to `To`
- */
-export type Convert<Target, From, To> = Target extends From ? To : Target extends (...args: any[]) => unknown ? (...args: Convert<Parameters<Target>, From, To> & Array<unknown>) => Convert<ReturnType<Target>, From, To> : Target extends object ? {
-    [K in keyof Target]: Convert<Target[K], From, To>;
-} : Target;
-export type BufferToUint8Array<T> = Convert<T, Buffer, Uint8Array>;

package/dist/emulation/shared.js

@@ -23,16 +23,14 @@ export function _toUnixTimestamp(time) {
  * @internal
  */
 export function normalizeMode(mode, def) {
-    switch (typeof mode) {
-        case 'number':
-            // (path, flag, mode, cb?)
-            return mode;
-        case 'string':
-            // (path, flag, modeString, cb?)
-            const trueMode = parseInt(mode, 8);
-            if (!isNaN(trueMode)) {
-                return trueMode;
-            }
+    if (typeof mode == 'number') {
+        return mode;
+    }
+    if (typeof mode == 'string') {
+        const parsed = parseInt(mode, 8);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
     }
     if (typeof def == 'number') {
         return def;
@@ -61,45 +59,35 @@ export function normalizeTime(time) {
  */
 export function normalizePath(p) {
     // Node doesn't allow null characters in paths.
-    if (p.indexOf('\u0000') >= 0) {
+    if (p.includes('\x00')) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must be a string without null bytes.');
     }
-    if (p === '') {
+    if (p.length == 0) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must not be empty.');
     }
-    p = p.replaceAll(/\/+/g, '/');
-    return resolve(p);
+    return resolve(p.replaceAll(/[/\\]+/g, '/'));
 }
 /**
  * Normalizes options
+ * @param options options to normalize
+ * @param encoding default encoding
+ * @param flag default flag
+ * @param mode default mode
  * @internal
  */
-export function normalizeOptions(options, defEnc, defFlag, defMode) {
-    // typeof null === 'object' so special-case handing is needed.
-    switch (options === null ? 'null' : typeof options) {
-        case 'object':
-            return {
-                encoding: typeof options['encoding'] !== 'undefined' ? options['encoding'] : defEnc,
-                flag: typeof options['flag'] !== 'undefined' ? options['flag'] : defFlag,
-                mode: normalizeMode(options['mode'], defMode),
-            };
-        case 'string':
-            return {
-                encoding: options,
-                flag: defFlag,
-                mode: defMode,
-            };
-        case 'null':
-        case 'undefined':
-        case 'function':
-            return {
-                encoding: defEnc,
-                flag: defFlag,
-                mode: defMode,
-            };
-        default:
-            throw new TypeError(`"options" must be a string or an object, got ${typeof options} instead.`);
-    }
+export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
+    if (typeof options != 'object' || options === null) {
+        return {
+            encoding: typeof options == 'string' ? options : encoding,
+            flag,
+            mode,
+        };
+    }
+    return {
+        encoding: typeof options?.encoding == 'string' ? options.encoding : encoding,
+        flag: typeof options?.flag == 'string' ? options.flag : flag,
+        mode: normalizeMode('mode' in options ? options?.mode : null, mode),
+    };
 }
 /**
  * Do nothing

package/dist/emulation/streams.d.ts

@@ -67,6 +67,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     addListener(event: 'pipe', listener: (src: Readable) => void): this;
     addListener(event: 'ready', listener: () => void): this;
     addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
     on(event: 'close', listener: () => void): this;
     on(event: 'drain', listener: () => void): this;
     on(event: 'error', listener: (err: Error) => void): this;
@@ -75,6 +76,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     on(event: 'pipe', listener: (src: Readable) => void): this;
     on(event: 'ready', listener: () => void): this;
     on(event: 'unpipe', listener: (src: Readable) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     once(event: 'close', listener: () => void): this;
     once(event: 'drain', listener: () => void): this;
     once(event: 'error', listener: (err: Error) => void): this;
@@ -83,6 +85,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     once(event: 'pipe', listener: (src: Readable) => void): this;
     once(event: 'ready', listener: () => void): this;
     once(event: 'unpipe', listener: (src: Readable) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
     prependListener(event: 'close', listener: () => void): this;
     prependListener(event: 'drain', listener: () => void): this;
     prependListener(event: 'error', listener: (err: Error) => void): this;
@@ -91,6 +94,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     prependListener(event: 'pipe', listener: (src: Readable) => void): this;
     prependListener(event: 'ready', listener: () => void): this;
     prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
     prependOnceListener(event: 'close', listener: () => void): this;
     prependOnceListener(event: 'drain', listener: () => void): this;
     prependOnceListener(event: 'error', listener: (err: Error) => void): this;
@@ -99,4 +103,5 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
     prependOnceListener(event: 'ready', listener: () => void): this;
     prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 }