@zenfs/core 0.8.0 → 0.9.0

package/dist/emulation/sync.js

@@ -2,9 +2,11 @@ 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 { Dirent } from './dir.js';
+import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { COPYFILE_EXCL, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } 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';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -104,22 +106,22 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
                 if (!parentStats.isDirectory()) {
-                    throw ApiError.With('ENOTDIR', dirname(path), '_openSync');
+                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
                 }
                 return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.With('ENOENT', path, '_openSync');
+                throw ApiError.With('ENOENT', path, '_open');
             default:
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
         }
     }
     if (!stats.hasAccess(mode, cred)) {
-        throw ApiError.With('EACCES', path, '_openSync');
+        throw ApiError.With('EACCES', path, '_open');
     }
     // File exists.
     switch (pathExistsAction(flag)) {
         case ActionType.THROW:
-            throw ApiError.With('EEXIST', path, '_openSync');
+            throw ApiError.With('EEXIST', path, '_open');
         case ActionType.TRUNCATE:
             // Delete file.
             doOp('unlinkSync', resolveSymlinks, path, cred);
@@ -426,7 +428,7 @@ export function symlinkSync(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
     }
     if (existsSync(path)) {
-        throw ApiError.With('EEXIST', path, 'symlinkSync');
+        throw ApiError.With('EEXIST', path, 'symlink');
     }
     writeFileSync(path, target);
     const file = _openSync(path, 'r+', 0o644, false);
@@ -542,54 +544,151 @@ export function accessSync(path, mode = 0o600) {
     }
 }
 accessSync;
-/* eslint-disable @typescript-eslint/no-unused-vars */
 /**
- * @todo Implement
+ * Synchronous `rm`. Removes files or directories (recursively).
+ * @param path The path to the file or directory to remove.
  */
-export function rmSync(path) {
-    throw ApiError.With('ENOTSUP', path, 'rmSync');
+export function rmSync(path, options) {
+    path = normalizePath(path);
+    const stats = statSync(path);
+    switch (stats.mode & S_IFMT) {
+        case S_IFDIR:
+            if (options?.recursive) {
+                for (const entry of readdirSync(path)) {
+                    rmSync(join(path, entry));
+                }
+            }
+            rmdirSync(path);
+            return;
+        case S_IFREG:
+        case S_IFLNK:
+            unlinkSync(path);
+            return;
+        case S_IFBLK:
+        case S_IFCHR:
+        case S_IFIFO:
+        case S_IFSOCK:
+        default:
+            throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
+    }
 }
 rmSync;
 export function mkdtempSync(prefix, options) {
-    throw ApiError.With('ENOTSUP', prefix, 'mkdtempSync');
+    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const resolvedPath = '/tmp/' + fsName;
+    mkdirSync(resolvedPath);
+    return encoding == 'buffer' ? Buffer.from(resolvedPath) : resolvedPath;
 }
 mkdtempSync;
 /**
- * @todo Implement
+ * Synchronous `copyFile`. Copies a file.
+ * @param src The source file.
+ * @param dest The destination file.
+ * @param flags Optional flags for the copy operation. Currently supports these flags:
+ *    * `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
  */
 export function copyFileSync(src, dest, flags) {
-    throw ApiError.With('ENOTSUP', src, 'copyFileSync');
+    src = normalizePath(src);
+    dest = normalizePath(dest);
+    if (flags && flags & COPYFILE_EXCL && existsSync(dest)) {
+        throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+    }
+    writeFileSync(dest, readFileSync(src));
 }
 copyFileSync;
 /**
- * @todo Implement
+ * Synchronous `readv`. Reads from a file descriptor into multiple buffers.
+ * @param fd The file descriptor.
+ * @param buffers An array of Uint8Array buffers.
+ * @param position The position in the file where to begin reading.
+ * @returns The number of bytes read.
  */
 export function readvSync(fd, buffers, position) {
-    throw ApiError.With('ENOTSUP', fd2file(fd).path, 'readvSync');
+    const file = fd2file(fd);
+    let bytesRead = 0;
+    for (const buffer of buffers) {
+        bytesRead += file.readSync(buffer, 0, buffer.length, position + bytesRead);
+    }
+    return bytesRead;
 }
 readvSync;
 /**
- * @todo Implement
+ * Synchronous `writev`. Writes from multiple buffers into a file descriptor.
+ * @param fd The file descriptor.
+ * @param buffers An array of Uint8Array buffers.
+ * @param position The position in the file where to begin writing.
+ * @returns The number of bytes written.
  */
 export function writevSync(fd, buffers, position) {
-    throw ApiError.With('ENOTSUP', fd2file(fd).path, 'writevSync');
+    const file = fd2file(fd);
+    let bytesWritten = 0;
+    for (const buffer of buffers) {
+        bytesWritten += file.writeSync(buffer, 0, buffer.length, position + bytesWritten);
+    }
+    return bytesWritten;
 }
 writevSync;
 /**
- * @todo Implement
+ * Synchronous `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 function opendirSync(path, options) {
-    throw ApiError.With('ENOTSUP', path, 'opendirSync');
+    path = normalizePath(path);
+    return new Dir(path); // Re-use existing `Dir` class
 }
 opendirSync;
 /**
- * @todo Implement
+ * Synchronous `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.cpSync':
+ *   * `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 function cpSync(source, destination, opts) {
-    throw ApiError.With('ENOTSUP', source, 'cpSync');
+    source = normalizePath(source);
+    destination = normalizePath(destination);
+    const srcStats = lstatSync(source); // Use lstat to follow symlinks if not dereferencing
+    if (opts?.errorOnExist && existsSync(destination)) {
+        throw new ApiError(ErrorCode.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+    }
+    switch (srcStats.mode & S_IFMT) {
+        case S_IFDIR:
+            if (!opts?.recursive) {
+                throw new ApiError(ErrorCode.EISDIR, source + ' is a directory (not copied)', source, 'cp');
+            }
+            mkdirSync(destination, { recursive: true }); // Ensure the destination directory exists
+            for (const dirent of readdirSync(source, { withFileTypes: true })) {
+                if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
+                    continue; // Skip if the filter returns false
+                }
+                cpSync(join(source, dirent.name), join(destination, dirent.name), opts);
+            }
+            break;
+        case S_IFREG:
+        case S_IFLNK:
+            copyFileSync(source, destination);
+            break;
+        case S_IFBLK:
+        case S_IFCHR:
+        case S_IFIFO:
+        case S_IFSOCK:
+        default:
+            throw new ApiError(ErrorCode.EPERM, 'File type not supported', source, 'rm');
+    }
+    // Optionally preserve timestamps
+    if (opts?.preserveTimestamps) {
+        utimesSync(destination, srcStats.atime, srcStats.mtime);
+    }
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ApiError.With('ENOTSUP', path, 'statfsSync');
+    throw ApiError.With('ENOSYS', path, 'statfs');
 }
-/* eslint-enable @typescript-eslint/no-unused-vars */

package/dist/filesystem.d.ts

@@ -220,5 +220,8 @@ declare abstract class ReadonlyFileSystem extends FileSystem {
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
+/**
+ * Implements the non-readonly methods to throw `EROFS`
+ */
 export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFileSystem) & T;
 export {};

package/dist/filesystem.js

@@ -24,7 +24,6 @@ export class FileSystem {
             freeSpace: 0,
         };
     }
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
     constructor(options) {
         // unused
     }
@@ -57,9 +56,6 @@ export class FileSystem {
  * Implements the asynchronous API in terms of the synchronous API.
  */
 export function Sync(FS) {
-    /**
-     * Implements the asynchronous API in terms of the synchronous API.
-     */
     class _SyncFileSystem extends FS {
         async ready() {
             return this;
@@ -239,6 +235,9 @@ export function Async(FS) {
     }
     return _AsyncFileSystem;
 }
+/**
+ * Implements the non-readonly methods to throw `EROFS`
+ */
 export function Readonly(FS) {
     class _ReadonlyFileSystem extends FS {
         metadata() {

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export * from './config.js';
 export * from './cred.js';
 export * from './file.js';
 export * from './filesystem.js';
-export * from './FileIndex.js';
+export * from './backends/FileIndex.js';
 export * from './inode.js';
 export * from './mutex.js';
 export * from './stats.js';

package/dist/index.js

@@ -9,7 +9,7 @@ export * from './config.js';
 export * from './cred.js';
 export * from './file.js';
 export * from './filesystem.js';
-export * from './FileIndex.js';
+export * from './backends/FileIndex.js';
 export * from './inode.js';
 export * from './mutex.js';
 export * from './stats.js';

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import type { OptionalTuple } from 'utilium';
 import { ApiError } from './ApiError.js';
 import { Cred } from './cred.js';
@@ -41,3 +43,46 @@ export declare function decodeDirListing(data: Uint8Array): Record<string, bigin
  */
 export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;
 export type Callback<Args extends unknown[] = []> = (e?: ApiError, ...args: OptionalTuple<Args>) => unknown;
+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;

package/dist/utils.js

@@ -1,5 +1,5 @@
 import { ApiError, ErrorCode } from './ApiError.js';
-import { dirname } from './emulation/path.js';
+import { dirname, resolve } from './emulation/path.js';
 /**
  * Synchronous recursive makedir.
  * @hidden
@@ -133,3 +133,96 @@ export function encodeDirListing(data) {
         return v.toString();
     }));
 }
+/**
+ * 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
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "dist",