@zenfs/core 2.1.1 → 2.2.0

package/dist/backends/backend.d.ts

@@ -1,5 +1,5 @@
 import type { RequiredKeys } from 'utilium';
-import type { FileSystem } from '../internal/filesystem.js';
+import type { CaseFold, FileSystem } from '../internal/filesystem.js';
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | string | ((arg: any) => boolean) | {
     [Symbol.hasInstance](instance: any): boolean;
     toString(): string;
@@ -33,6 +33,10 @@ export interface SharedConfig {
      * If set, disables the sync cache and sync operations on async file systems.
      */
     disableAsyncCache?: boolean;
+    /**
+     * If set, sets case folding for the file system(s).
+     */
+    caseFold?: CaseFold;
 }
 /**
  * A backend

package/dist/config.d.ts

@@ -1,6 +1,12 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import type { Device, DeviceDriver } from './internal/devices.js';
 import { log } from 'kerium';
+import { FileSystem } from './internal/filesystem.js';
+/**
+ * Update the configuration of a file system.
+ * @category Backends and Configuration
+ */
+export declare function configureFileSystem(fs: FileSystem, config: SharedConfig): void;
 /**
  * Configuration for a specific mount point
  * @category Backends and Configuration

package/dist/config.js

@@ -7,6 +7,16 @@ import { FileSystem } from './internal/filesystem.js';
 import { _setAccessChecks } from './vfs/config.js';
 import * as fs from './vfs/index.js';
 import { mounts } from './vfs/shared.js';
+/**
+ * Update the configuration of a file system.
+ * @category Backends and Configuration
+ */
+export function configureFileSystem(fs, config) {
+    if (config.disableAsyncCache)
+        fs.attributes.set('no_async_preload');
+    if (config.caseFold)
+        fs.attributes.set('case_fold', config.caseFold);
+}
 function isMountConfig(arg) {
     return isBackendConfig(arg) || isBackend(arg) || arg instanceof FileSystem;
 }
@@ -46,8 +56,7 @@ export async function resolveMountConfig(configuration, _depth = 0) {
     }
     checkOptions(backend, configuration);
     const mount = (await backend.create(configuration));
-    if (configuration.disableAsyncCache)
-        mount.attributes.set('no_async_preload');
+    configureFileSystem(mount, configuration);
     await mount.ready();
     return mount;
 }
@@ -98,10 +107,11 @@ export function addDevice(driver, options) {
  * @see Configuration
  */
 export async function configure(configuration) {
-    var _a;
-    const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
-    const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
-    Object.assign(defaultContext.credentials, createCredentials({ uid, gid }));
+    var _a, _b;
+    Object.assign(defaultContext.credentials, createCredentials({
+        uid: configuration.uid || 0,
+        gid: configuration.gid || 0,
+    }));
     _setAccessChecks(!configuration.disableAccessChecks);
     if (configuration.log)
         log.configure(configuration.log);
@@ -111,13 +121,17 @@ export async function configure(configuration) {
             const point = _point.startsWith('/') ? _point : '/' + _point;
             if (isBackendConfig(mountConfig)) {
                 (_a = mountConfig.disableAsyncCache) !== null && _a !== void 0 ? _a : (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
+                (_b = mountConfig.caseFold) !== null && _b !== void 0 ? _b : (mountConfig.caseFold = configuration.caseFold);
             }
             if (point == '/')
                 fs.umount('/');
             await mount(point, await resolveMountConfig(mountConfig));
         }
     }
-    if (configuration.addDevices) {
+    for (const fs of mounts.values()) {
+        configureFileSystem(fs, configuration);
+    }
+    if (configuration.addDevices && !mounts.has('/dev')) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();

package/dist/internal/filesystem.d.ts

@@ -29,13 +29,14 @@ export interface UsageInfo {
      */
     freeNodes?: number;
 }
+export type CaseFold = 'upper' | 'lower';
 /**
  * Attributes that control how the file system interacts with the VFS.
  * No options are set by default.
  * @category Internals
  * @internal
  */
-export type FileSystemAttributes = {
+export interface FileSystemAttributes {
     /**
      * If set disables async file systems from preloading their contents.
      * This means *sync operations will not work* (unless the contents are cached)
@@ -79,7 +80,11 @@ export type FileSystemAttributes = {
      * @experimental
      */
     sync: void;
-};
+    /**
+     * If set, the VFS layer will convert paths to lower/upper case.
+     */
+    case_fold?: CaseFold;
+}
 /**
  * Options used when creating files and directories.
  * This weird naming and such is to preserve backward compatibility.

package/dist/internal/filesystem.js

@@ -39,8 +39,7 @@ export class FileSystem {
             this.attributes.set('default_stream_write');
     }
     toString() {
-        var _a;
-        return `${this.name} ${(_a = this.label) !== null && _a !== void 0 ? _a : ''} (${this._mountPoint ? 'mounted on ' + this._mountPoint : 'unmounted'})`;
+        return `${this.name} ${this.label ? JSON.stringify(this.label) : ''} (${this._mountPoint ? 'mounted on ' + this._mountPoint : 'unmounted'})`;
     }
     /**
      * Default implementation.

package/dist/internal/index_fs.js

@@ -128,6 +128,7 @@ export class IndexFS extends FileSystem {
             size: 0,
             uid: parent.mode & S_ISUID ? parent.uid : options.uid,
             gid: parent.mode & S_ISGID ? parent.gid : options.gid,
+            nlink: 1,
         });
         this.index.set(path, inode);
         return inode;

package/dist/mixins/async.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystem } from '../internal/filesystem.js';
-import type { _SyncFSKeys, AsyncFSMethods, Mixin } from './shared.js';
+import { type _SyncFSKeys, type AsyncFSMethods, type Mixin } from './shared.js';
 /**
  * @internal
  * @category Internals
@@ -16,7 +16,13 @@ export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'exist
      * @internal @protected
      */
     _sync?: FileSystem;
+    /**
+     * @deprecated Use {@link sync | `sync`} instead
+     */
     queueDone(): Promise<void>;
+    /**
+     * @deprecated Use {@link sync | `sync`} instead
+     */
     ready(): Promise<void>;
 }
 /**

package/dist/mixins/async.js

@@ -1,6 +1,6 @@
+import { _asyncFSKeys } from './shared.js';
 import { withErrno } from 'kerium';
 import { crit, debug, err } from 'kerium/log';
-import { getAllPrototypes } from 'utilium';
 import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
@@ -16,11 +16,17 @@ import { join } from '../path.js';
  */
 export function Async(FS) {
     class AsyncFS extends FS {
+        /**
+         * @deprecated Use {@link sync | `sync`} instead
+         */
         async done() {
-            await this._promise;
+            return this.sync();
         }
+        /**
+         * @deprecated Use {@link sync | `sync`} instead
+         */
         queueDone() {
-            return this.done();
+            return this.sync();
         }
         _async(promise) {
             this._promise = this._promise.then(() => promise);
@@ -91,8 +97,8 @@ export function Async(FS) {
         }
         unlinkSync(path) {
             this.checkSync();
-            this._sync.unlinkSync(path);
             this._async(this.unlink(path));
+            this._sync.unlinkSync(path);
         }
         rmdirSync(path) {
             this.checkSync();
@@ -114,8 +120,8 @@ export function Async(FS) {
             this._async(this.link(srcpath, dstpath));
         }
         async sync() {
-            this.checkSync();
-            this._sync.syncSync();
+            if (!this.attributes.has('no_async_preload') && this._sync)
+                this._sync.syncSync();
             await this._promise;
         }
         syncSync() {
@@ -180,19 +186,19 @@ export function Async(FS) {
          * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            const methods = Array.from(getAllPrototypes(this))
-                .flatMap(Object.getOwnPropertyNames)
-                .filter(key => typeof this[key] == 'function' && `${key}Sync` in this);
-            debug('Async: patching methods: ' + methods.join(', '));
-            for (const key of methods) {
+            debug(`Async: patched ${_asyncFSKeys.length} methods`);
+            for (const key of _asyncFSKeys) {
                 // TS does not narrow the union based on the key
-                const originalMethod = this[key];
+                const originalMethod = this[key].bind(this);
                 this[key] = async (...args) => {
-                    var _a, _b, _c;
-                    const result = await originalMethod.apply(this, args);
-                    const stack = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(2).join('\n');
-                    // !stack == From the async queue
-                    if ((stack === null || stack === void 0 ? void 0 : stack.includes(`at <computed> [as ${key}]`)) || (stack === null || stack === void 0 ? void 0 : stack.includes(`${key}Sync `)) || !stack)
+                    var _a, _b;
+                    const result = await originalMethod(...args);
+                    const stack = new Error().stack.split('\n').slice(2).join('\n');
+                    // From the async queue
+                    if (!stack
+                        || stack.includes(`at <computed> [as ${key}]`)
+                        || stack.includes(`at async <computed> [as ${key}]`)
+                        || stack.includes(`${key}Sync `))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -200,10 +206,16 @@ export function Async(FS) {
                     }
                     try {
                         // @ts-expect-error 2556 - The type of `args` is not narrowed
-                        (_c = (_b = this._sync) === null || _b === void 0 ? void 0 : _b[`${key}Sync`]) === null || _c === void 0 ? void 0 : _c.call(_b, ...args);
+                        (_b = (_a = this._sync) === null || _a === void 0 ? void 0 : _a[`${key}Sync`]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args);
                     }
                     catch (e) {
-                        throw err(withErrno(e.errno, e.message + ' (Out of sync!)'));
+                        const stack = e.stack.split('\n').slice(3).join('\n');
+                        if (stack.includes(`at <computed> [as ${key}]`)
+                            || stack.includes(`at async <computed> [as ${key}]`)
+                            || stack.includes(`${key}Sync `))
+                            return result;
+                        e.message += ' (Out of sync!)';
+                        throw err(e);
                     }
                     return result;
                 };

package/dist/mixins/mutexed.d.ts

@@ -30,7 +30,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     get name(): string;
     get label(): string | undefined;
     set label(value: string | undefined);
-    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void> & Map<string, any>;
+    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void | import("../internal/filesystem.js").CaseFold | undefined> & Map<string, any>;
     get _uuid(): UUID;
     set _uuid(value: UUID);
     get uuid(): UUID;

package/dist/mixins/shared.d.ts

@@ -18,15 +18,18 @@ export type _SyncFSKeys = Exclude<Extract<keyof FileSystem, `${string}Sync`>, '_
 export type _AsyncFSKeys = {
     [K in _SyncFSKeys]: K extends `${infer T}Sync` ? T : never;
 }[_SyncFSKeys];
+export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write"];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
  * @category Internals
  * @internal
  */
-export type AsyncFSMethods = Pick<FileSystem, _AsyncFSKeys>;
+export interface AsyncFSMethods extends Pick<FileSystem, _AsyncFSKeys> {
+}
 /**
  * Concrete `FileSystem`. This is a convenience type.
  * @category Internals
  * @internal
  */
-export type ConcreteFS = ExtractProperties<FileSystem, any>;
+export interface ConcreteFS extends ExtractProperties<FileSystem, any> {
+}

package/dist/mixins/shared.js

@@ -1,5 +1,19 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-empty-object-type,@typescript-eslint/no-explicit-any */
 /*
     Code shared by various mixins
 */
-export {};
+export const _asyncFSKeys = [
+    'rename',
+    'stat',
+    'touch',
+    'createFile',
+    'unlink',
+    'rmdir',
+    'mkdir',
+    'readdir',
+    'exists',
+    'link',
+    'sync',
+    'read',
+    'write',
+];

package/dist/path.d.ts

@@ -14,3 +14,4 @@ export declare function basename(path: string, suffix?: string): string;
 export declare function extname(path: string): string;
 export declare function format(pathObject: ParsedPath): string;
 export declare function parse(path: string): ParsedPath;
+export declare function matchesGlob(pattern: string, str: string): boolean;

package/dist/path.js

@@ -21,6 +21,7 @@ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 import { defaultContext } from './internal/contexts.js';
+import { globToRegex } from './utils.js';
 export const sep = '/';
 function validateObject(str, name) {
     if (typeof str != 'object') {
@@ -419,3 +420,6 @@ export function parse(path) {
         ret.dir = '/';
     return ret;
 }
+export function matchesGlob(pattern, str) {
+    return globToRegex(pattern).test(str);
+}

package/dist/readline.d.ts

@@ -85,6 +85,7 @@ export declare class Interface extends EventEmitter<InterfaceEvents> implements
      */
     getMaxListeners(): number;
     [Symbol.asyncIterator](): AsyncIteratorObject<string>;
+    [Symbol.dispose](): void;
     [Symbol.asyncDispose](): Promise<void>;
     rawListeners(event: keyof InterfaceEvents): ((...args: any[]) => void)[];
 }

package/dist/readline.js

@@ -365,6 +365,9 @@ export class Interface extends EventEmitter {
             },
         };
     }
+    [Symbol.dispose]() {
+        this.close();
+    }
     async [Symbol.asyncDispose]() {
         if (this._closed)
             return;

package/dist/utils.d.ts

@@ -53,3 +53,8 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     flag: string;
     mode: number;
 };
+/**
+ * Converts a glob pattern to a regular expression
+ * @internal
+ */
+export declare function globToRegex(pattern: string): RegExp;

package/dist/utils.js

@@ -96,3 +96,15 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
+/**
+ * Converts a glob pattern to a regular expression
+ * @internal
+ */
+export function globToRegex(pattern) {
+    pattern = pattern
+        .replace(/([.?+^$(){}|[\]/])/g, '$1')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${pattern}$`);
+}

package/dist/vfs/promises.d.ts

@@ -128,7 +128,7 @@ export declare class FileHandle implements promises.FileHandle {
      * Read file data using a `ReadableStream`.
      * The handle will not be closed automatically.
      */
-    readableWebStream(options?: promises.ReadableWebStreamOptions & StreamOptions): NodeReadableStream<Uint8Array>;
+    readableWebStream(options?: StreamOptions): NodeReadableStream<Uint8Array>;
     /**
      * Not part of the Node.js API!
      *
@@ -136,7 +136,7 @@ export declare class FileHandle implements promises.FileHandle {
      * The handle will not be closed automatically.
      * @internal
      */
-    writableWebStream(options?: promises.ReadableWebStreamOptions & StreamOptions): WritableStream;
+    writableWebStream(options?: StreamOptions): WritableStream;
     /**
      * Creates a readline Interface object that allows reading the file line by line
      * @param options Options for creating a read stream

package/dist/vfs/promises.js

@@ -55,10 +55,10 @@ import { Exception, rethrow, setUVMessage, UV } from 'kerium';
 import { decodeUTF8, pick } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, parse, resolve } from '../path.js';
+import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
 import '../polyfills.js';
 import { createInterface } from '../readline.js';
-import { __assertType, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -1219,19 +1219,12 @@ export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
     // Escape special characters in pattern
-    const regexPatterns = pattern.map(p => {
-        p = p
-            .replace(/([.?+^$(){}|[\]/])/g, '$1')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '.');
-        return new RegExp(`^${p}$`);
-    });
+    const regexPatterns = pattern.map(globToRegex);
     async function* recursiveList(dir) {
         const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
-            if (exclude((withFileTypes ? entry : fullPath)))
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
              * @todo is the pattern.source check correct?

package/dist/vfs/shared.js

@@ -55,12 +55,17 @@ export function resolveMount(path, ctx) {
     const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // descending order of the string length
     for (const [mountPoint, fs] of sortedMounts) {
         // We know path is normalized, so it would be a substring of the mount point.
-        if (_isParentOf(mountPoint, path)) {
-            path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
-            if (path === '')
-                path = root;
-            return { fs, path, mountPoint, root };
-        }
+        if (!_isParentOf(mountPoint, path))
+            continue;
+        path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
+        if (path === '')
+            path = root;
+        const case_fold = fs.attributes.get('case_fold');
+        if (case_fold === 'lower')
+            path = path.toLowerCase();
+        if (case_fold === 'upper')
+            path = path.toUpperCase();
+        return { fs, path, mountPoint, root };
     }
     throw alert(new Exception(Errno.EIO, 'No file system for ' + path));
 }

package/dist/vfs/sync.js

@@ -56,8 +56,8 @@ import { decodeUTF8, encodeUTF8 } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, parse, resolve } from '../path.js';
-import { __assertType, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
+import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -860,20 +860,13 @@ export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
     // Escape special characters in pattern
-    const regexPatterns = pattern.map(p => {
-        p = p
-            .replace(/([.?+^$(){}|[\]/])/g, '\\$1')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '.');
-        return new RegExp(`^${p}$`);
-    });
+    const regexPatterns = pattern.map(globToRegex);
     const results = [];
     function recursiveList(dir) {
         const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
-            if (exclude((withFileTypes ? entry : fullPath)))
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
              * @todo is the pattern.source check correct?

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.1.1",
+	"version": "2.2.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -67,7 +67,7 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^22.10.1 <22.13.7",
+		"@types/node": "^22.15.2",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",

package/tests/common/casefold.test.ts

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { mounts, configure, fs } from '../../dist/index.js';
+
+suite('Case folding', () => {
+	test('Configuration', async () => {
+		await configure({ caseFold: 'lower' });
+		assert.equal(mounts.get('/')?.attributes.get('case_fold'), 'lower');
+	});
+
+	test('Write', () => {
+		fs.writeFileSync('/Test.txt', 'test');
+		assert(fs.existsSync('/test.txt'));
+	});
+
+	test('Read', () => {
+		assert.equal(fs.readFileSync('/TEST.txt', 'utf8'), 'test');
+	});
+});

package/tests/fs/directory.test.ts

@@ -21,7 +21,7 @@ suite('Directories', () => {
 	test('mkdir', async () => {
 		await fs.promises.mkdir('/one', 0o755);
 		assert(await fs.promises.exists('/one'));
-		await assert.rejects(fs.promises.mkdir('/one', 0o755), /EEXIST/);
+		await assert.rejects(fs.promises.mkdir('/one', 0o755), { code: 'EEXIST' });
 	});
 
 	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));