@zenfs/core 0.8.1 → 0.9.1

package/dist/emulation/promises.js

@@ -2,10 +2,12 @@ import { Buffer } from 'buffer';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
-import { F_OK } from './constants.js';
-import { Dirent } from './dir.js';
+import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import * as constants from './constants.js';
+import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, normalizeMode, normalizeOptions, normalizePath, normalizeTime, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(
@@ -15,12 +17,12 @@ export class FileHandle {
     fd) {
         this.fd = fd;
     }
+    /**
+     * @internal
+     */
     get file() {
         return fd2file(this.fd);
     }
-    get path() {
-        return this.file.path;
-    }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
@@ -128,13 +130,35 @@ export class FileHandle {
      * @experimental
      */
     readableWebStream(options) {
-        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readableWebStream');
+        // Note: using an arrow function to preserve `this`
+        const start = async ({ close, enqueue, error }) => {
+            try {
+                const chunkSize = 64 * 1024, maxChunks = 1e7;
+                let i = 0, position = 0, result;
+                while (result.bytesRead > 0) {
+                    result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
+                    if (!result.bytesRead) {
+                        close();
+                        return;
+                    }
+                    enqueue(result.buffer.slice(0, result.bytesRead));
+                    position += result.bytesRead;
+                    if (++i >= maxChunks) {
+                        throw new ApiError(ErrorCode.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
+                    }
+                }
+            }
+            catch (e) {
+                error(e);
+            }
+        };
+        return new ReadableStream({ start, type: options.type });
     }
     readLines(options) {
-        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readLines');
+        throw ApiError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
     }
     [Symbol.asyncDispose]() {
-        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.@@asyncDispose');
+        return this.close();
     }
     async stat(opts) {
         const stats = await this.file.stat();
@@ -191,26 +215,80 @@ export class FileHandle {
         await this.file.close();
         fdMap.delete(this.fd);
     }
-    /* eslint-disable @typescript-eslint/no-unused-vars */
     /**
-     * See `fs.writev` promisified version.
-     * @todo Implement
+     * Asynchronous `writev`. Writes from multiple buffers.
+     * @param buffers An array of Uint8Array buffers.
+     * @param position The position in the file where to begin writing.
+     * @returns The number of bytes written.
      */
-    writev(buffers, position) {
-        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.writev');
+    async writev(buffers, position) {
+        let bytesWritten = 0;
+        for (const buffer of buffers) {
+            bytesWritten += (await this.write(buffer, 0, buffer.length, position + bytesWritten)).bytesWritten;
+        }
+        return { bytesWritten, buffers };
     }
     /**
-     * See `fs.readv` promisified version.
-     * @todo Implement
+     * Asynchronous `readv`. Reads into multiple buffers.
+     * @param buffers An array of Uint8Array buffers.
+     * @param position The position in the file where to begin reading.
+     * @returns The number of bytes read.
      */
-    readv(buffers, position) {
-        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readv');
+    async readv(buffers, position) {
+        let bytesRead = 0;
+        for (const buffer of buffers) {
+            bytesRead += (await this.read(buffer, 0, buffer.byteLength, position + bytesRead)).bytesRead;
+        }
+        return { bytesRead, buffers };
     }
+    /**
+     * Creates a `ReadStream` for reading from the file.
+     *
+     * @param options Options for the readable stream
+     * @returns A `ReadStream` object.
+     */
     createReadStream(options) {
-        throw ApiError.With('ENOTSUP', this.path, 'createReadStream');
+        const streamOptions = {
+            highWaterMark: options?.highWaterMark || 64 * 1024,
+            encoding: options?.encoding,
+            read: async (size) => {
+                try {
+                    const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
+                    stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead)); // Push data or null for EOF
+                    this.file.position += result.bytesRead;
+                }
+                catch (error) {
+                    stream.destroy(error);
+                }
+            },
+        };
+        const stream = new ReadStream(streamOptions);
+        stream.path = this.file.path;
+        return stream;
     }
+    /**
+     * Creates a `WriteStream` for writing to the file.
+     *
+     * @param options Options for the writeable stream.
+     * @returns A `WriteStream` object
+     */
     createWriteStream(options) {
-        throw ApiError.With('ENOTSUP', this.path, 'createWriteStream');
+        const streamOptions = {
+            highWaterMark: options?.highWaterMark,
+            encoding: options?.encoding,
+            write: async (chunk, encoding, callback) => {
+                try {
+                    const { bytesWritten } = await this.write(chunk, null, encoding);
+                    callback(bytesWritten == chunk.length ? null : new Error('Failed to write full chunk'));
+                }
+                catch (error) {
+                    callback(error);
+                }
+            },
+        };
+        const stream = new WriteStream(streamOptions);
+        stream.path = this.file.path;
+        return stream;
     }
 }
 /**
@@ -405,7 +483,7 @@ export async function readFile(filename, _options) {
 }
 readFile;
 /**
- * Synchronously writes data to a file, replacing the file if it already exists.
+ * Asynchronously writes data to a file, replacing the file if it already exists.
  *
  * The encoding option is ignored if data is a buffer.
  * @param filename
@@ -647,7 +725,7 @@ export async function realpath(path, options) {
 }
 realpath;
 export function watch(filename, options) {
-    throw ApiError.With('ENOTSUP', filename, 'watch');
+    throw ApiError.With('ENOSYS', filename, 'watch');
 }
 watch;
 /**
@@ -655,44 +733,126 @@ watch;
  * @param path
  * @param mode
  */
-export async function access(path, mode = F_OK) {
+export async function access(path, mode = constants.F_OK) {
     const stats = await stat(path);
     if (!stats.hasAccess(mode, cred)) {
         throw new ApiError(ErrorCode.EACCES);
     }
 }
 access;
-/* eslint-disable @typescript-eslint/no-unused-vars */
 /**
- * @todo Implement
+ * Asynchronous `rm`. Removes files or directories (recursively).
+ * @param path The path to the file or directory to remove.
  */
 export async function rm(path, options) {
-    throw ApiError.With('ENOTSUP', path, 'rm');
+    path = normalizePath(path);
+    const stats = await stat(path);
+    switch (stats.mode & constants.S_IFMT) {
+        case constants.S_IFDIR:
+            if (options?.recursive) {
+                for (const entry of await readdir(path)) {
+                    await rm(join(path, entry));
+                }
+            }
+            await rmdir(path);
+            return;
+        case constants.S_IFREG:
+        case constants.S_IFLNK:
+            await unlink(path);
+            return;
+        case constants.S_IFBLK:
+        case constants.S_IFCHR:
+        case constants.S_IFIFO:
+        case constants.S_IFSOCK:
+        default:
+            throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
+    }
 }
 rm;
 export async function mkdtemp(prefix, options) {
-    throw ApiError.With('ENOTSUP', prefix, 'mkdtemp');
+    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const resolvedPath = '/tmp/' + fsName;
+    await mkdir(resolvedPath);
+    return encoding == 'buffer' ? Buffer.from(resolvedPath) : resolvedPath;
 }
 mkdtemp;
 /**
- * @todo Implement
+ * Asynchronous `copyFile`. Copies a file.
+ * @param src The source file.
+ * @param dest The destination file.
+ * @param mode Optional flags for the copy operation. Currently supports these flags:
+ *    * `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
  */
 export async function copyFile(src, dest, mode) {
-    throw ApiError.With('ENOTSUP', src, 'copyFile');
+    src = normalizePath(src);
+    dest = normalizePath(dest);
+    if (mode && mode & constants.COPYFILE_EXCL && (await exists(dest))) {
+        throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+    }
+    await writeFile(dest, await readFile(src));
 }
 copyFile;
 /**
- * @todo Implement
+ * Asynchronous `opendir`. Opens a directory.
+ * @param path The path to the directory.
+ * @param options Options for opening the directory.
+ * @returns A `Dir` object representing the opened directory.
  */
 export async function opendir(path, options) {
-    throw ApiError.With('ENOTSUP', path, 'opendir');
+    path = normalizePath(path);
+    return new Dir(path);
 }
 opendir;
+/**
+ * Asynchronous `cp`. Recursively copies a file or directory.
+ * @param source The source file or directory.
+ * @param destination The destination file or directory.
+ * @param opts Options for the copy operation. Currently supports these options from Node.js 'fs.await cp':
+ *   * `dereference`: Dereference symbolic links.
+ *   * `errorOnExist`: Throw an error if the destination file or directory already exists.
+ *   * `filter`: A function that takes a source and destination path and returns a boolean, indicating whether to copy the given source element.
+ *   * `force`: Overwrite the destination if it exists, and overwrite existing readonly destination files.
+ *   * `preserveTimestamps`: Preserve file timestamps.
+ *   * `recursive`: If `true`, copies directories recursively.
+ */
 export async function cp(source, destination, opts) {
-    throw ApiError.With('ENOTSUP', source, 'cp');
+    source = normalizePath(source);
+    destination = normalizePath(destination);
+    const srcStats = await lstat(source); // Use lstat to follow symlinks if not dereferencing
+    if (opts?.errorOnExist && (await exists(destination))) {
+        throw new ApiError(ErrorCode.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+    }
+    switch (srcStats.mode & constants.S_IFMT) {
+        case constants.S_IFDIR:
+            if (!opts?.recursive) {
+                throw new ApiError(ErrorCode.EISDIR, source + ' is a directory (not copied)', source, 'cp');
+            }
+            await mkdir(destination, { recursive: true }); // Ensure the destination directory exists
+            for (const dirent of await readdir(source, { withFileTypes: true })) {
+                if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
+                    continue; // Skip if the filter returns false
+                }
+                await cp(join(source, dirent.name), join(destination, dirent.name), opts);
+            }
+            break;
+        case constants.S_IFREG:
+        case constants.S_IFLNK:
+            await copyFile(source, destination);
+            break;
+        case constants.S_IFBLK:
+        case constants.S_IFCHR:
+        case constants.S_IFIFO:
+        case constants.S_IFSOCK:
+        default:
+            throw new ApiError(ErrorCode.EPERM, 'File type not supported', source, 'rm');
+    }
+    // Optionally preserve timestamps
+    if (opts?.preserveTimestamps) {
+        await utimes(destination, srcStats.atime, srcStats.mtime);
+    }
 }
 cp;
 export async function statfs(path, opts) {
-    throw ApiError.With('ENOTSUP', path, 'statfs');
+    throw ApiError.With('ENOSYS', path, 'statfs');
 }
-/* eslint-enable @typescript-eslint/no-unused-vars */

package/dist/emulation/shared.d.ts

@@ -1,51 +1,6 @@
-/// <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)
- *
- * @internal
- */
-export declare function _toUnixTimestamp(time: Date | number): number;
-/**
- * Normalizes a mode
- * @internal
- */
-export declare function normalizeMode(mode: string | number | unknown, def?: number): number;
-/**
- * Normalizes a time
- * @internal
- */
-export declare function normalizeTime(time: string | number | Date): Date;
-/**
- * Normalizes a path
- * @internal
- */
-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?: WriteFileOptions | (EncodingOption & {
-    flag?: OpenMode;
-}), encoding?: BufferEncoding, flag?: string, mode?: number): {
-    encoding: BufferEncoding;
-    flag: string;
-    mode: number;
-};
-/**
- * Do nothing
- * @internal
- */
-export declare function nop(): void;
+import { FileSystem } from '../filesystem.js';
 export declare let cred: Cred;
 export declare function setCred(val: Cred): void;
 export declare const fdMap: Map<number, File>;

package/dist/emulation/shared.js

@@ -1,101 +1,9 @@
 // Utilities and shared data
-import { resolve } from './path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
-import { rootCred } from '../cred.js';
 import { InMemory } from '../backends/InMemory.js';
-/**
- * converts Date or number to a integer UNIX timestamp
- * Grabbed from NodeJS sources (lib/fs.js)
- *
- * @internal
- */
-export function _toUnixTimestamp(time) {
-    if (typeof time === 'number') {
-        return Math.floor(time);
-    }
-    if (time instanceof Date) {
-        return Math.floor(time.getTime() / 1000);
-    }
-    throw new Error('Cannot parse time: ' + time);
-}
-/**
- * Normalizes a mode
- * @internal
- */
-export function normalizeMode(mode, def) {
-    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;
-    }
-    throw new ApiError(ErrorCode.EINVAL, 'Invalid mode: ' + mode?.toString());
-}
-/**
- * Normalizes a time
- * @internal
- */
-export function normalizeTime(time) {
-    if (time instanceof Date) {
-        return time;
-    }
-    if (typeof time == 'number') {
-        return new Date(time * 1000);
-    }
-    if (typeof time == 'string') {
-        return new Date(time);
-    }
-    throw new ApiError(ErrorCode.EINVAL, 'Invalid time.');
-}
-/**
- * Normalizes a path
- * @internal
- */
-export function normalizePath(p) {
-    // Node doesn't allow null characters in paths.
-    if (p.includes('\x00')) {
-        throw new ApiError(ErrorCode.EINVAL, 'Path must be a string without null bytes.');
-    }
-    if (p.length == 0) {
-        throw new ApiError(ErrorCode.EINVAL, 'Path must not be empty.');
-    }
-    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, 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
- * @internal
- */
-export function nop() {
-    // do nothing
-}
+import { rootCred } from '../cred.js';
+import { normalizePath } from '../utils.js';
+import { resolve } from './path.js';
 // credentials
 export let cred = rootCred;
 export function setCred(val) {

package/dist/emulation/streams.d.ts

@@ -8,100 +8,10 @@ export declare class ReadStream extends Readable implements Node.ReadStream {
     bytesRead: number;
     path: string | Buffer;
     pending: boolean;
-    addListener(event: 'close', listener: () => void): this;
-    addListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
-    addListener(event: 'end', listener: () => void): this;
-    addListener(event: 'error', listener: (err: Error) => void): this;
-    addListener(event: 'open', listener: (fd: number) => void): this;
-    addListener(event: 'pause', listener: () => void): this;
-    addListener(event: 'readable', listener: () => void): this;
-    addListener(event: 'ready', listener: () => void): this;
-    addListener(event: 'resume', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'data', listener: (chunk: Buffer | string) => void): this;
-    on(event: 'end', listener: () => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    on(event: 'open', listener: (fd: number) => void): this;
-    on(event: 'pause', listener: () => void): this;
-    on(event: 'readable', listener: () => void): this;
-    on(event: 'ready', listener: () => void): this;
-    on(event: 'resume', listener: () => void): this;
-    once(event: 'close', listener: () => void): this;
-    once(event: 'data', listener: (chunk: Buffer | string) => void): this;
-    once(event: 'end', listener: () => void): this;
-    once(event: 'error', listener: (err: Error) => void): this;
-    once(event: 'open', listener: (fd: number) => void): this;
-    once(event: 'pause', listener: () => void): this;
-    once(event: 'readable', listener: () => void): this;
-    once(event: 'ready', listener: () => void): this;
-    once(event: 'resume', listener: () => void): this;
-    prependListener(event: 'close', listener: () => void): this;
-    prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
-    prependListener(event: 'end', listener: () => void): this;
-    prependListener(event: 'error', listener: (err: Error) => void): this;
-    prependListener(event: 'open', listener: (fd: number) => void): this;
-    prependListener(event: 'pause', listener: () => void): this;
-    prependListener(event: 'readable', listener: () => void): this;
-    prependListener(event: 'ready', listener: () => void): this;
-    prependListener(event: 'resume', listener: () => void): this;
-    prependOnceListener(event: 'close', listener: () => void): this;
-    prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
-    prependOnceListener(event: 'end', listener: () => void): this;
-    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-    prependOnceListener(event: 'open', listener: (fd: number) => void): this;
-    prependOnceListener(event: 'pause', listener: () => void): this;
-    prependOnceListener(event: 'readable', listener: () => void): this;
-    prependOnceListener(event: 'ready', listener: () => void): this;
-    prependOnceListener(event: 'resume', listener: () => void): this;
 }
 export declare class WriteStream extends Writable implements Node.WriteStream {
     close(callback?: Callback): void;
     bytesWritten: number;
     path: string | Buffer;
     pending: boolean;
-    addListener(event: 'close', listener: () => void): this;
-    addListener(event: 'drain', listener: () => void): this;
-    addListener(event: 'error', listener: (err: Error) => void): this;
-    addListener(event: 'finish', listener: () => void): this;
-    addListener(event: 'open', listener: (fd: number) => void): this;
-    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;
-    on(event: 'finish', listener: () => void): this;
-    on(event: 'open', listener: (fd: number) => void): this;
-    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;
-    once(event: 'finish', listener: () => void): this;
-    once(event: 'open', listener: (fd: number) => void): this;
-    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;
-    prependListener(event: 'finish', listener: () => void): this;
-    prependListener(event: 'open', listener: (fd: number) => void): this;
-    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;
-    prependOnceListener(event: 'finish', listener: () => void): this;
-    prependOnceListener(event: 'open', listener: (fd: number) => void): this;
-    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;
 }

package/dist/emulation/streams.js

@@ -10,21 +10,6 @@ export class ReadStream extends Readable {
             callback(err);
         }
     }
-    addListener(event, listener) {
-        return super.addListener(event, listener);
-    }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    prependListener(event, listener) {
-        return super.prependListener(event, listener);
-    }
-    prependOnceListener(event, listener) {
-        return super.prependOnceListener(event, listener);
-    }
 }
 export class WriteStream extends Writable {
     close(callback = () => null) {
@@ -37,19 +22,4 @@ export class WriteStream extends Writable {
             callback(err);
         }
     }
-    addListener(event, listener) {
-        return super.addListener(event, listener);
-    }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    prependListener(event, listener) {
-        return super.prependListener(event, listener);
-    }
-    prependOnceListener(event, listener) {
-        return super.prependOnceListener(event, listener);
-    }
 }