@zenfs/core 0.5.11 → 0.6.0

package/dist/config.d.ts

@@ -1,23 +1,27 @@
-import type { Backend, BackendConfig } from './backends/backend.js';
+import type { Backend, BackendConfiguration } from './backends/backend.js';
 import { FileSystem } from './filesystem.js';
 /**
- * Initializes ZenFS with the given file systems.
+ * Configuration for a specific mount point
  */
-export declare function initialize(mounts: {
-    [point: string]: FileSystem;
-}, uid?: number, gid?: number): void;
+export type MountConfiguration<FS extends FileSystem = FileSystem> = FS | BackendConfiguration<FS> | Backend<FS>;
 /**
- * Defines a mapping of mount points to their configurations
+ * Retrieve a file system with the given configuration.
+ * @param config A BackendConfig object.
  */
-export interface ConfigMapping {
-    [mountPoint: string]: FileSystem | BackendConfig | Backend;
-}
+export declare function resolveMountConfig<FS extends FileSystem>(config: MountConfiguration<FS>, _depth?: number): Promise<FS>;
 /**
- * A configuration for ZenFS
+ *A mapping of mount points to their configurations
  */
-export type Configuration = FileSystem | BackendConfig | ConfigMapping;
+export type MappingConfiguration = Partial<{
+    uid: number;
+    gid: number;
+}> & Record<string, FileSystem | BackendConfiguration | Backend>;
+/**
+ * Configuration for the file systems
+ */
+export type Configuration = MountConfiguration | MappingConfiguration;
 /**
  * Creates filesystems with the given configuration, and initializes ZenFS with it.
- * See the Configuration type for more info on the configuration object.
+ * @see Configuration for more info on the configuration object.
  */
 export declare function configure(config: Configuration): Promise<void>;

package/dist/config.js

@@ -1,35 +1,66 @@
-import { isBackend, resolveBackend } from './backends/backend.js';
+import { ApiError, ErrorCode } from './ApiError.js';
+import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import * as fs from './emulation/index.js';
 import { setCred } from './emulation/shared.js';
 import { FileSystem } from './filesystem.js';
+function isMountConfig(arg) {
+    return isBackendConfig(arg) || isBackend(arg) || arg instanceof FileSystem;
+}
 /**
- * Initializes ZenFS with the given file systems.
+ * Retrieve a file system with the given configuration.
+ * @param config A BackendConfig object.
  */
-export function initialize(mounts, uid = 0, gid = 0) {
-    setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
-    fs.initialize(mounts);
+export async function resolveMountConfig(config, _depth = 0) {
+    if (typeof config !== 'object' || config == null) {
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid options on mount configuration');
+    }
+    if (!isMountConfig(config)) {
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid mount configuration');
+    }
+    if (config instanceof FileSystem) {
+        return config;
+    }
+    if (isBackend(config)) {
+        config = { backend: config };
+    }
+    for (const [key, value] of Object.entries(config)) {
+        if (key == 'backend') {
+            continue;
+        }
+        if (!isMountConfig(value)) {
+            continue;
+        }
+        if (_depth > 10) {
+            throw new ApiError(ErrorCode.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);
+    }
+    checkOptions(backend, config);
+    const mount = backend.create(config);
+    await mount.ready();
+    return mount;
 }
 /**
  * Creates filesystems with the given configuration, and initializes ZenFS with it.
- * See the Configuration type for more info on the configuration object.
+ * @see Configuration for more info on the configuration object.
  */
 export async function configure(config) {
-    if ('backend' in config || config instanceof FileSystem) {
+    const uid = 'uid' in config ? +config.uid || 0 : 0;
+    const gid = 'gid' in config ? +config.gid || 0 : 0;
+    if (isMountConfig(config)) {
         // single FS
         config = { '/': config };
     }
-    for (let [point, value] of Object.entries(config)) {
-        if (typeof value == 'number') {
-            //should never happen
+    for (const [point, value] of Object.entries(config)) {
+        if (point == 'uid' || point == 'gid' || typeof value == 'number') {
             continue;
         }
-        if (value instanceof FileSystem) {
-            continue;
-        }
-        if (isBackend(value)) {
-            value = { backend: value };
-        }
-        config[point] = await resolveBackend(value);
+        config[point] = await resolveMountConfig(value);
     }
-    initialize(config);
+    fs.mountMapping(config);
+    setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 }

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 { initialize, mounts, mount, umount, _toUnixTimestamp } from './shared.js';
+export { mountMapping, mounts, mount, umount, _toUnixTimestamp } 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 { initialize, mounts, mount, umount, _toUnixTimestamp } from './shared.js';
+export { mountMapping, mounts, mount, umount, _toUnixTimestamp } from './shared.js';
 export { Stats, BigIntStats, StatsFs } from '../stats.js';

package/dist/emulation/path.js

@@ -108,26 +108,26 @@ export function formatExt(ext) {
     return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
 }
 export function resolve(...args) {
-    let resolvedPath = '';
-    let resolvedAbsolute = false;
-    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    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 === 0) {
+        if (!path.length) {
             continue;
         }
-        resolvedPath = `${path}/${resolvedPath}`;
-        resolvedAbsolute = path[0] === '/';
+        resolved = `${path}/${resolved}`;
+        absolute = path[0] == '/';
     }
     // At this point the path should be resolved to a full absolute path, but
-    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // handle relative paths to be safe (might happen when cwd fails)
     // Normalize the path
-    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-    if (resolvedAbsolute) {
-        return `/${resolvedPath}`;
+    resolved = normalizeString(resolved, !absolute);
+    if (absolute) {
+        return `/${resolved}`;
     }
-    return resolvedPath.length > 0 ? resolvedPath : '.';
+    return resolved.length > 0 ? resolved : '/';
 }
 export function normalize(path) {
     validateString(path, 'path');

package/dist/emulation/promises.d.ts

@@ -8,13 +8,14 @@ import { Buffer } from 'buffer';
 import type * as Node from 'node:fs';
 import type * as promises from 'node:fs/promises';
 import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo, FileReadResult, FlagAndOpenMode } from 'node:fs/promises';
+import type { ReadableStream } from 'node:stream/web';
+import type { Interface as ReadlineInterface } from 'readline';
 import { FileContents } from '../filesystem.js';
 import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
 import { Dirent, type Dir } from './dir.js';
 import type { PathLike } from './shared.js';
+import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
-import type { ReadableStream } from 'node:stream/web';
-import type { Interface as ReadlineInterface } from 'readline';
 export declare class FileHandle implements promises.FileHandle {
     /**
      * Gets the file descriptor for this file handle.
@@ -161,8 +162,8 @@ export declare class FileHandle implements promises.FileHandle {
      * @todo Implement
      */
     readv(buffers: readonly NodeJS.ArrayBufferView[], position?: number): Promise<Node.ReadVResult>;
-    createReadStream(options?: CreateReadStreamOptions): Node.ReadStream;
-    createWriteStream(options?: CreateWriteStreamOptions): Node.WriteStream;
+    createReadStream(options?: CreateReadStreamOptions): ReadStream;
+    createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
 }
 /**
  * Renames a file

package/dist/emulation/promises.js

@@ -4,8 +4,8 @@ import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExist
 import { BigIntStats, FileType } from '../stats.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';
+import { dirname, join, parse } from './path.js';
+import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, normalizeMode, normalizeOptions, normalizePath, normalizeTime, resolveMount } from './shared.js';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(
@@ -227,7 +227,8 @@ export class FileHandle {
  */
 async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
     rawPath = normalizePath(rawPath);
-    const { fs, path } = resolveFS(resolveSymlinks && (await exists(rawPath)) ? await realpath(rawPath) : rawPath);
+    const _path = resolveSymlinks && (await exists(rawPath)) ? await realpath(rawPath) : rawPath;
+    const { fs, path } = resolveMount(_path);
     try {
         // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
         return fs[name](path, ...args);
@@ -245,8 +246,8 @@ async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
 export async function rename(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const src = resolveFS(oldPath);
-    const dst = resolveFS(newPath);
+    const src = resolveMount(oldPath);
+    const dst = resolveMount(newPath);
     try {
         if (src.mountPoint == dst.mountPoint) {
             await src.fs.rename(src.path, dst.path, cred);
@@ -266,8 +267,8 @@ rename;
  */
 export async function exists(_path) {
     try {
-        const { fs, path } = resolveFS(_path);
-        return fs.exists(path, cred);
+        const { fs, path } = resolveMount(await realpath(_path));
+        return await fs.exists(path, cred);
     }
     catch (e) {
         if (e.errno == ErrorCode.ENOENT) {
@@ -394,7 +395,7 @@ async function _readFile(fname, flag, resolveSymlinks) {
     }
 }
 export async function readFile(filename, _options) {
-    const options = normalizeOptions(_options, null, 'r', null);
+    const options = normalizeOptions(_options, null, 'r', 0);
     const flag = parseFlag(options.flag);
     if (!isReadable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
@@ -630,17 +631,18 @@ export async function lutimes(path, atime, mtime) {
 lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
+    const { base, dir } = parse(path);
+    const lpath = join(dir == '/' ? '/' : await realpath(dir), base);
+    const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
         const stats = await fs.stat(resolvedPath, cred);
         if (!stats.isSymbolicLink()) {
-            return path;
+            return lpath;
         }
-        const dst = mountPoint + normalizePath(Buffer.from(await _readFile(resolvedPath, 'r+', false)).toString());
-        return realpath(dst);
+        return realpath(mountPoint + (await readlink(lpath)));
     }
     catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
+        throw fixError(e, { [resolvedPath]: lpath });
     }
 }
 realpath;

package/dist/emulation/shared.d.ts

@@ -70,7 +70,7 @@ export declare function umount(mountPoint: string): void;
 /**
  * Gets the internal FileSystem for the path, then returns it along with the path relative to the FS' root
  */
-export declare function resolveFS(path: string): {
+export declare function resolveMount(path: string): {
     fs: FileSystem;
     path: string;
     mountPoint: string;
@@ -84,7 +84,7 @@ export declare function fixPaths(text: string, paths: {
 export declare function fixError<E extends Error>(e: E, paths: {
     [from: string]: string;
 }): E;
-export declare function initialize(mountMapping: MountMapping): void;
+export declare function mountMapping(mountMapping: MountMapping): void;
 /**
  * Types supports as path parameters.
  *

package/dist/emulation/shared.js

@@ -153,7 +153,7 @@ export function umount(mountPoint) {
 /**
  * Gets the internal FileSystem for the path, then returns it along with the path relative to the FS' root
  */
-export function resolveFS(path) {
+export function resolveMount(path) {
     path = normalizePath(path);
     const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // decending order of the string length
     for (const [mountPoint, fs] of sortedMounts) {
@@ -184,7 +184,7 @@ export function fixError(e, paths) {
     e.message = fixPaths(e.message, paths);
     return e;
 }
-export function initialize(mountMapping) {
+export function mountMapping(mountMapping) {
     if ('/' in mountMapping) {
         umount('/');
     }

package/dist/emulation/sync.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'buffer';
+import type * as Node from 'fs';
+import type { BufferEncodingOption, EncodingOption, ReadSyncOptions, symlink } from 'fs';
 import { FileContents } from '../filesystem.js';
 import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
-import type { symlink, ReadSyncOptions, EncodingOption, BufferEncodingOption } from 'fs';
-import type * as Node from 'fs';
-import { PathLike } from './shared.js';
 import { Dir, Dirent } from './dir.js';
+import { PathLike } from './shared.js';
 /**
  * Synchronous rename.
  * @param oldPath

package/dist/emulation/sync.js

@@ -1,12 +1,13 @@
+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 { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts } from './shared.js';
 import { Dirent } from './dir.js';
-import { dirname, join } from './path.js';
+import { dirname, join, parse } from './path.js';
+import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, normalizeMode, normalizeOptions, normalizePath, normalizeTime, resolveMount } from './shared.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
-    const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
     try {
         // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
         return fs[name](resolvedPath, ...args);
@@ -23,8 +24,8 @@ function doOp(...[name, resolveSymlinks, path, ...args]) {
 export function renameSync(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const _old = resolveFS(oldPath);
-    const _new = resolveFS(newPath);
+    const _old = resolveMount(oldPath);
+    const _new = resolveMount(newPath);
     const paths = { [_old.path]: oldPath, [_new.path]: newPath };
     try {
         if (_old === _new) {
@@ -45,7 +46,7 @@ renameSync;
 export function existsSync(path) {
     path = normalizePath(path);
     try {
-        const { fs, path: resolvedPath } = resolveFS(path);
+        const { fs, path: resolvedPath } = resolveMount(realpathSync(path));
         return fs.existsSync(resolvedPath, cred);
     }
     catch (e) {
@@ -514,17 +515,18 @@ export function lutimesSync(path, atime, mtime) {
 lutimesSync;
 export function realpathSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
+    const { base, dir } = parse(path);
+    const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
+    const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
         const stats = fs.statSync(resolvedPath, cred);
         if (!stats.isSymbolicLink()) {
-            return path;
+            return lpath;
         }
-        const dst = normalizePath(mountPoint + Buffer.from(_readFileSync(resolvedPath, 'r+', false)).toString());
-        return realpathSync(dst);
+        return realpathSync(mountPoint + readlinkSync(lpath));
     }
     catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
+        throw fixError(e, { [resolvedPath]: lpath });
     }
 }
 realpathSync;

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from './inode.js';
 export * from './mutex.js';
 export * from './stats.js';
 export * from './utils.js';
+export * from './emulation/index.js';
 import * as fs from './emulation/index.js';
 export { fs };
 export default fs;

package/dist/index.js

@@ -15,6 +15,7 @@ export * from './inode.js';
 export * from './mutex.js';
 export * from './stats.js';
 export * from './utils.js';
+export * from './emulation/index.js';
 import * as fs from './emulation/index.js';
 export { fs };
 export default fs;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.5.11",
+	"version": "0.6.0",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "dist",
@@ -32,7 +32,8 @@
 	},
 	"exports": {
 		".": "./dist/index.js",
-		"./*": "./dist/*"
+		"./*": "./dist/*",
+		"./promises": "./dist/emulations/promises.js"
 	},
 	"typesVersions": {
 		"*": {