@zenfs/core 1.6.7 → 1.6.9

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,8 +1,7 @@
 import { ErrnoError, Errno } from '../error.js';
-import { levenshtein } from '../utils.js';
 /** @internal */
 export function isBackend(arg) {
-    return arg != null && typeof arg == 'object' && 'isAvailable' in arg && typeof arg.isAvailable == 'function' && 'create' in arg && typeof arg.create == 'function';
+    return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';
 }
 /**
  * Checks that `options` object is valid for the file system options.
@@ -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/sync.js

@@ -518,7 +518,7 @@ export function linkSync(targetPath, linkPath) {
         if (config.checkAccess && !fs.statSync(path).hasAccess(constants.R_OK, this)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
-        return fs.linkSync(path, linkPath);
+        return fs.linkSync(path, link.path);
     }
     catch (e) {
         throw fixError(e, { [path]: targetPath, [link.path]: linkPath });

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.7",
+	"version": "1.6.9",
 	"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/*"