@zenfs/core 0.9.7 → 0.10.0

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { Backend, BackendConfiguration } from './backends/backend.js';
 import { FileSystem } from './filesystem.js';
+import type { AbsolutePath } from './emulation/path.js';
 /**
  * Configuration for a specific mount point
  */
@@ -10,18 +11,15 @@ export type MountConfiguration<FS extends FileSystem = FileSystem, TOptions exte
  */
 export declare function resolveMountConfig<FS extends FileSystem, TOptions extends object = object>(config: MountConfiguration<FS, TOptions>, _depth?: number): Promise<FS>;
 /**
- *A mapping of mount points to their configurations
+ * Configuration
  */
-export type MappingConfiguration = Partial<{
-    uid: number;
-    gid: number;
-}> & Record<string, FileSystem | BackendConfiguration | Backend>;
-/**
- * Configuration for the file systems
- */
-export type Configuration = MountConfiguration | MappingConfiguration;
+export interface Configuration {
+    mounts: Record<AbsolutePath, MountConfiguration>;
+    uid?: number;
+    gid?: number;
+}
 /**
  * Creates filesystems with the given configuration, and initializes ZenFS with it.
  * @see Configuration for more info on the configuration object.
  */
-export declare function configure(config: Configuration): Promise<void>;
+export declare function configure(config: MountConfiguration | Configuration): Promise<void>;

package/dist/config.js

@@ -1,4 +1,4 @@
-import { ApiError, ErrorCode } from './ApiError.js';
+import { ErrnoError, Errno } from './error.js';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import * as fs from './emulation/index.js';
 import { setCred } from './emulation/shared.js';
@@ -12,10 +12,10 @@ function isMountConfig(arg) {
  */
 export async function resolveMountConfig(config, _depth = 0) {
     if (typeof config !== 'object' || config == null) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid options on mount configuration');
+        throw new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration');
     }
     if (!isMountConfig(config)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid mount configuration');
+        throw new ErrnoError(Errno.EINVAL, 'Invalid mount configuration');
     }
     if (config instanceof FileSystem) {
         return config;
@@ -31,13 +31,13 @@ export async function resolveMountConfig(config, _depth = 0) {
             continue;
         }
         if (_depth > 10) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid configuration, too deep and possibly infinite');
+            throw new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite');
         }
         config[key] = await resolveMountConfig(value, ++_depth);
     }
     const { backend } = config;
     if (!(await backend.isAvailable())) {
-        throw new ApiError(ErrorCode.EPERM, 'Backend not available: ' + backend);
+        throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
     }
     checkOptions(backend, config);
     const mount = backend.create(config);
@@ -53,14 +53,14 @@ export async function configure(config) {
     const gid = 'gid' in config ? config.gid || 0 : 0;
     if (isMountConfig(config)) {
         // single FS
-        config = { '/': config };
+        config = { mounts: { '/': config } };
     }
-    for (const [point, value] of Object.entries(config)) {
-        if (point == 'uid' || point == 'gid' || typeof value == 'number') {
-            continue;
+    for (const [point, value] of Object.entries(config.mounts)) {
+        if (!point.startsWith('/')) {
+            throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
         }
-        config[point] = await resolveMountConfig(value);
+        config.mounts[point] = await resolveMountConfig(value);
     }
-    fs.mountMapping(config);
+    fs.mountObject(config.mounts);
     setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 }

package/dist/emulation/async.js

@@ -1,4 +1,4 @@
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { BigIntStats } from '../stats.js';
 import { nop, normalizeMode } from '../utils.js';
 import { R_OK } from './constants.js';
@@ -128,7 +128,7 @@ export function ftruncate(fd, lenOrCB, cb = nop) {
     cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
     const file = fd2file(fd);
     if (length < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+        throw new ErrnoError(Errno.EINVAL);
     }
     file.truncate(length)
         .then(() => cb())
@@ -179,7 +179,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPos, cb = nop) {
             default:
                 // ...try to find the callback and get out of here!
                 cb = typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPos === 'function' ? cbPos : cb;
-                cb(new ApiError(ErrorCode.EINVAL, 'Invalid arguments.'));
+                cb(new ErrnoError(Errno.EINVAL, 'Invalid arguments.'));
                 return;
         }
         buffer = Buffer.from(data);
@@ -431,18 +431,18 @@ export function access(path, cbMode, cb = nop) {
 }
 access;
 export function watchFile(path, optsListener, listener = nop) {
-    throw ApiError.With('ENOSYS', path.toString(), 'watchFile');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'watchFile');
 }
 watchFile;
 /**
  * @todo Implement
  */
 export function unwatchFile(path, listener = nop) {
-    throw ApiError.With('ENOSYS', path.toString(), 'unwatchFile');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'unwatchFile');
 }
 unwatchFile;
 export function watch(path, options, listener = nop) {
-    throw ApiError.With('ENOSYS', path.toString(), 'watch');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'watch');
 }
 watch;
 /**

package/dist/emulation/dir.js

@@ -1,5 +1,5 @@
 import { readdir } from './promises.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { readdirSync } from './sync.js';
 import { basename } from './path.js';
 export class Dirent {
@@ -38,7 +38,7 @@ export class Dirent {
 export class Dir {
     checkClosed() {
         if (this.closed) {
-            throw new ApiError(ErrorCode.EBADF, 'Can not use closed Dir');
+            throw new ErrnoError(Errno.EBADF, 'Can not use closed Dir');
         }
     }
     constructor(path) {

package/dist/emulation/index.d.ts

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountMapping, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount } from './shared.js';
 export { Stats, BigIntStats, StatsFs } from '../stats.js';

package/dist/emulation/index.js

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountMapping, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount } from './shared.js';
 export { Stats, BigIntStats, StatsFs } from '../stats.js';

package/dist/emulation/path.d.ts

@@ -1,14 +1,15 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { ParsedPath } from 'node:path';
+export type AbsolutePath = `/${string}`;
 export declare let cwd: string;
 export declare function cd(path: string): void;
 export declare const sep = "/";
 export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
 export declare function formatExt(ext: string): string;
-export declare function resolve(...args: string[]): string;
+export declare function resolve(...parts: string[]): AbsolutePath;
 export declare function normalize(path: string): string;
 export declare function isAbsolute(path: string): boolean;
-export declare function join(...args: string[]): string;
+export declare function join(...parts: string[]): string;
 export declare function relative(from: string, to: string): string;
 export declare function dirname(path: string): string;
 export declare function basename(path: string, suffix?: string): string;

package/dist/emulation/path.js

@@ -25,11 +25,6 @@ export function cd(path) {
     cwd = resolve(cwd, path);
 }
 export const sep = '/';
-function validateString(str, name) {
-    if (typeof str != 'string') {
-        throw new TypeError(`"${name}" is not a string`);
-    }
-}
 function validateObject(str, name) {
     if (typeof str != 'object') {
         throw new TypeError(`"${name}" is not an object`);
@@ -107,19 +102,18 @@ export function normalizeString(path, allowAboveRoot) {
 export function formatExt(ext) {
     return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
 }
-export function resolve(...args) {
+export function resolve(...parts) {
     let resolved = '';
-    let absolute = false;
-    for (let i = args.length - 1; i >= -1 && !absolute; i--) {
-        const path = i >= 0 ? args[i] : cwd;
-        validateString(path, `paths[${i}]`);
-        // Skip empty entries
-        if (!path.length) {
+    for (const part of [...parts.reverse(), cwd]) {
+        if (!part.length) {
             continue;
         }
-        resolved = `${path}/${resolved}`;
-        absolute = path[0] == '/';
+        resolved = `${part}/${resolved}`;
+        if (part.startsWith('/')) {
+            break;
+        }
     }
+    const absolute = resolved.startsWith('/');
     // At this point the path should be resolved to a full absolute path, but
     // handle relative paths to be safe (might happen when cwd fails)
     // Normalize the path
@@ -127,17 +121,16 @@ export function resolve(...args) {
     if (absolute) {
         return `/${resolved}`;
     }
-    return resolved.length > 0 ? resolved : '/';
+    return resolved.length ? resolved : '/';
 }
 export function normalize(path) {
-    validateString(path, 'path');
-    if (path.length === 0)
+    if (!path.length)
         return '.';
-    const isAbsolute = path[0] === '/';
-    const trailingSeparator = path.at(-1) === '/';
+    const isAbsolute = path.startsWith('/');
+    const trailingSeparator = path.endsWith('/');
     // Normalize the path
     path = normalizeString(path, !isAbsolute);
-    if (path.length === 0) {
+    if (!path.length) {
         if (isAbsolute)
             return '/';
         return trailingSeparator ? './' : '.';
@@ -147,30 +140,17 @@ export function normalize(path) {
     return isAbsolute ? `/${path}` : path;
 }
 export function isAbsolute(path) {
-    validateString(path, 'path');
-    return path.length > 0 && path[0] === '/';
+    return path.startsWith('/');
 }
-export function join(...args) {
-    if (args.length === 0)
+export function join(...parts) {
+    if (!parts.length)
         return '.';
-    let joined;
-    for (let i = 0; i < args.length; ++i) {
-        const arg = args[i];
-        validateString(arg, 'path');
-        if (arg.length > 0) {
-            if (joined === undefined)
-                joined = arg;
-            else
-                joined += `/${arg}`;
-        }
-    }
-    if (joined === undefined)
+    const joined = parts.join('/');
+    if (!joined?.length)
         return '.';
     return normalize(joined);
 }
 export function relative(from, to) {
-    validateString(from, 'from');
-    validateString(to, 'to');
     if (from === to)
         return '';
     // Trim leading forward slashes.
@@ -233,7 +213,6 @@ export function relative(from, to) {
     return `${out}${to.slice(toStart + lastCommonSep)}`;
 }
 export function dirname(path) {
-    validateString(path, 'path');
     if (path.length === 0)
         return '.';
     const hasRoot = path[0] === '/';
@@ -258,9 +237,6 @@ export function dirname(path) {
     return path.slice(0, end);
 }
 export function basename(path, suffix) {
-    if (suffix !== undefined)
-        validateString(suffix, 'ext');
-    validateString(path, 'path');
     let start = 0;
     let end = -1;
     let matchedSlash = true;
@@ -330,7 +306,6 @@ export function basename(path, suffix) {
     return path.slice(start, end);
 }
 export function extname(path) {
-    validateString(path, 'path');
     let startDot = -1;
     let startPart = 0;
     let end = -1;
@@ -387,8 +362,7 @@ export function format(pathObject) {
     return dir === pathObject.root ? `${dir}${base}` : `${dir}/${base}`;
 }
 export function parse(path) {
-    validateString(path, 'path');
-    const isAbsolute = path[0] === '/';
+    const isAbsolute = path.startsWith('/');
     const ret = { root: isAbsolute ? '/' : '', dir: '', base: '', ext: '', name: '' };
     if (path.length === 0)
         return ret;

package/dist/emulation/promises.d.ts

@@ -13,25 +13,22 @@ import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import { File } from '../file.js';
-import { FileContents } from '../filesystem.js';
+import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export declare class FileHandle implements promises.FileHandle {
     /**
-     * Gets the file descriptor for this file handle.
+     * The file descriptor for this file handle.
      */
     readonly fd: number;
-    constructor(
-    /**
-     * Gets the file descriptor for this file handle.
-     */
-    fd: number);
     /**
      * @internal
+     * The file for this file handle
      */
-    get file(): File;
+    readonly file: File;
+    constructor(fdOrFile: number | File);
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
@@ -182,9 +179,9 @@ export declare class FileHandle implements promises.FileHandle {
 export declare function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promise<void>;
 /**
  * Test whether or not the given path exists by checking with the file system.
- * @param _path
+ * @param path
  */
-export declare function exists(_path: fs.PathLike): Promise<boolean>;
+export declare function exists(path: fs.PathLike): Promise<boolean>;
 /**
  * `stat`.
  * @param path
@@ -378,8 +375,6 @@ export declare function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs
  * Asynchronous realpath(3) - return the canonicalized absolute pathname.
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
- *
- * Note: This *Can not* use doOp since doOp depends on it
  */
 export declare function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;