@zenfs/core 1.6.8 → 1.6.10

package/dist/backends/backend.d.ts

@@ -1,6 +1,6 @@
 import type { RequiredKeys } from 'utilium';
 import type { FileSystem } from '../filesystem.js';
-type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | (abstract new (...args: any[]) => any);
 /**
  * Resolves the type of Backend.options from the options interface
  */

package/dist/backends/backend.js

@@ -1,5 +1,4 @@
 import { ErrnoError, Errno } from '../error.js';
-import { levenshtein } from '../utils.js';
 /** @internal */
 export function isBackend(arg) {
     return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';
@@ -14,30 +13,24 @@ export async function checkOptions(backend, options) {
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
-        const providedValue = options?.[optName];
-        if (providedValue === undefined || providedValue === null) {
+        const value = options?.[optName];
+        if (value === undefined || value === null) {
             if (!opt.required) {
                 continue;
             }
-            /* Required option not provided.
-            if any incorrect options provided, which ones are close to the provided one?
-            (edit distance 5 === close)*/
-            const incorrectOptions = Object.keys(options)
-                .filter(o => !(o in backend.options))
-                .map((a) => {
-                return { str: a, distance: levenshtein(optName, a) };
-            })
-                .filter(o => o.distance < 5)
-                .sort((a, b) => a.distance - b.distance);
-            throw new ErrnoError(Errno.EINVAL, `${backend.name}: Required option '${optName}' not provided.${incorrectOptions.length > 0 ? ` You provided '${incorrectOptions[0].str}', did you mean '${optName}'.` : ''}`);
+            throw new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName);
         }
-        // Option provided, check type.
-        const typeMatches = Array.isArray(opt.type) ? opt.type.indexOf(typeof providedValue) != -1 : typeof providedValue == opt.type;
-        if (!typeMatches) {
-            throw new ErrnoError(Errno.EINVAL, `${backend.name}: Value provided for option ${optName} is not the proper type. Expected ${Array.isArray(opt.type) ? `one of {${opt.type.join(', ')}}` : opt.type}, but received ${typeof providedValue}`);
+        const isType = (value) => (typeof opt.type == 'function' ? value instanceof opt.type : typeof value === opt.type);
+        if (Array.isArray(opt.type) ? !opt.type.some(isType) : !isType(value)) {
+            // The type of the value as a string
+            const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
+            // The expected type (as a string)
+            const name = (type) => (typeof type == 'function' ? type.name : type);
+            const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
+            throw new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`);
         }
         if (opt.validator) {
-            await opt.validator(providedValue);
+            await opt.validator(value);
         }
         // Otherwise: All good!
     }

package/dist/emulation/promises.js

@@ -773,7 +773,8 @@ export async function readlink(path, options) {
         const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), 'r', 0o644, false), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options?.encoding : options;
-        return encoding == 'buffer' ? value : value.toString(encoding);
+        // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
+        return encoding == 'buffer' ? value : value.toString((encoding ?? 'utf-8'));
     }
     catch (e_6) {
         env_6.error = e_6;

package/dist/emulation/sync.d.ts

@@ -1,10 +1,10 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
+import type { V_Context } from '../context.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
-import type { V_Context } from '../context.js';
-import type { ReaddirOptsI, ReaddirOptsU, InternalOptions, ReaddirOptions, NullEnc } from './types.js';
+import type { InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 export declare function renameSync(this: V_Context, oldPath: fs.PathLike, newPath: fs.PathLike): void;
 /**
  * Test whether or not `path` exists by checking with the file system.

package/dist/emulation/sync.js

@@ -549,7 +549,8 @@ export function readlinkSync(path, options) {
     if (encoding == 'buffer') {
         return value;
     }
-    return value.toString(encoding);
+    // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
+    return value.toString(encoding ?? 'utf-8');
 }
 readlinkSync;
 export function chownSync(path, uid, gid) {

package/dist/utils.d.ts

@@ -2,21 +2,10 @@ import type * as fs from 'node:fs';
 import { type ClassLike, type OptionalTuple } from 'utilium';
 import { type AbsolutePath } from './emulation/path.js';
 import { ErrnoError } from './error.js';
-import type { FileSystem } from './filesystem.js';
 declare global {
     function atob(data: string): string;
     function btoa(data: string): string;
 }
-/**
- * Synchronous recursive makedir.
- * @hidden
- */
-export declare function mkdirpSync(path: string, mode: number, fs: FileSystem): void;
-/**
- * Calculates levenshtein distance.
- * @hidden
- */
-export declare function levenshtein(a: string, b: string): number;
 /**
  * Encodes a string into a buffer
  * @internal

package/dist/utils.js

@@ -1,89 +1,6 @@
 import { randomHex } from 'utilium';
-import { dirname, resolve } from './emulation/path.js';
+import { resolve } from './emulation/path.js';
 import { Errno, ErrnoError } from './error.js';
-/**
- * Synchronous recursive makedir.
- * @hidden
- */
-export function mkdirpSync(path, mode, fs) {
-    if (!fs.existsSync(path)) {
-        mkdirpSync(dirname(path), mode, fs);
-        fs.mkdirSync(path, mode);
-    }
-}
-function _min(d0, d1, d2, bx, ay) {
-    return Math.min(d0 + 1, d1 + 1, d2 + 1, bx === ay ? d1 : d1 + 1);
-}
-/**
- * Calculates levenshtein distance.
- * @hidden
- */
-export function levenshtein(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    if (a.length > b.length) {
-        [a, b] = [b, a]; // Swap a and b
-    }
-    let la = a.length;
-    let lb = b.length;
-    // Trim common suffix
-    while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
-        la--;
-        lb--;
-    }
-    let offset = 0;
-    // Trim common prefix
-    while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
-        offset++;
-    }
-    la -= offset;
-    lb -= offset;
-    if (la === 0 || lb === 1) {
-        return lb;
-    }
-    const vector = new Array(la << 1);
-    for (let y = 0; y < la;) {
-        vector[la + y] = a.charCodeAt(offset + y);
-        vector[y] = ++y;
-    }
-    let x;
-    let d0;
-    let d1;
-    let d2;
-    let d3;
-    for (x = 0; x + 3 < lb;) {
-        const bx0 = b.charCodeAt(offset + (d0 = x));
-        const bx1 = b.charCodeAt(offset + (d1 = x + 1));
-        const bx2 = b.charCodeAt(offset + (d2 = x + 2));
-        const bx3 = b.charCodeAt(offset + (d3 = x + 3));
-        let dd = (x += 4);
-        for (let y = 0; y < la;) {
-            const ay = vector[la + y];
-            const dy = vector[y];
-            d0 = _min(dy, d0, d1, bx0, ay);
-            d1 = _min(d0, d1, d2, bx1, ay);
-            d2 = _min(d1, d2, d3, bx2, ay);
-            dd = _min(d2, d3, dd, bx3, ay);
-            vector[y++] = dd;
-            d3 = d2;
-            d2 = d1;
-            d1 = d0;
-            d0 = dy;
-        }
-    }
-    let dd = 0;
-    for (; x < lb;) {
-        const bx0 = b.charCodeAt(offset + (d0 = x));
-        dd = ++x;
-        for (let y = 0; y < la; y++) {
-            const dy = vector[y];
-            vector[y] = dd = dy < d0 || dd < d0 ? (dy > dd ? dd + 1 : dy + 1) : bx0 === vector[la + y] ? d0 : d0 + 1;
-            d0 = dy;
-        }
-    }
-    return dd;
-}
 /**
  * Encodes a string into a buffer
  * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.6.8",
+	"version": "1.6.10",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -44,7 +44,6 @@
 		".": "./dist/index.js",
 		"./*": "./dist/*",
 		"./promises": "./dist/emulation/promises.js",
-		"./mixins": "./dist/mixins/index.js",
 		"./path": "./dist/emulation/path.js",
 		"./eslint": "./eslint.shared.js",
 		"./tests/*": "./tests/*"

package/readme.md

@@ -147,9 +147,6 @@ fs.umount('/mnt/zip'); // finished using the zip
 
 ### Devices and device files
 
-> [!WARNING]
-> This is an **experimental** feature. Breaking changes may occur during non-major releases. Using this feature is the fastest way to make it stable.
-
 ZenFS includes experimental support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. You can automatically add some normal devices with the `addDevices` configuration option:
 
 ```ts