@zenfs/core 0.1.0 → 0.2.0

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { ErrorCode, ApiError } from './ApiError.js';
+import { ApiError, ErrorCode } from './ApiError.js';
 import * as path from './emulation/path.js';
 /**
  * Synchronous recursive makedir.
@@ -19,10 +19,9 @@ function _min(d0, d1, d2, bx, ay) {
 }
 /**
  * Calculates levenshtein distance.
- * @param a
- * @param b
+ * @internal
  */
-function levenshtein(a, b) {
+export function levenshtein(a, b) {
     if (a === b) {
         return 0;
     }
@@ -88,86 +87,6 @@ function levenshtein(a, b) {
     }
     return dd;
 }
-/**
- * Checks that the given options object is valid for the file system options.
- * @internal
- */
-export async function checkOptions(backend, opts) {
-    const optsInfo = backend.Options;
-    const fsName = backend.Name;
-    let pendingValidators = 0;
-    let callbackCalled = false;
-    let loopEnded = false;
-    // Check for required options.
-    for (const optName in optsInfo) {
-        if (Object.prototype.hasOwnProperty.call(optsInfo, optName)) {
-            const opt = optsInfo[optName];
-            const providedValue = opts && opts[optName];
-            if (providedValue === undefined || providedValue === null) {
-                if (!opt.optional) {
-                    // Required option, not provided.
-                    // Any incorrect options provided? Which ones are close to the provided one?
-                    // (edit distance 5 === close)
-                    const incorrectOptions = Object.keys(opts)
-                        .filter(o => !(o in optsInfo))
-                        .map((a) => {
-                        return { str: a, distance: levenshtein(optName, a) };
-                    })
-                        .filter(o => o.distance < 5)
-                        .sort((a, b) => a.distance - b.distance);
-                    // Validators may be synchronous.
-                    if (callbackCalled) {
-                        return;
-                    }
-                    callbackCalled = true;
-                    throw new ApiError(ErrorCode.EINVAL, `[${fsName}] Required option '${optName}' not provided.${incorrectOptions.length > 0 ? ` You provided unrecognized option '${incorrectOptions[0].str}'; perhaps you meant to type '${optName}'.` : ''}\nOption description: ${opt.description}`);
-                }
-                // Else: Optional option, not provided. That is OK.
-            }
-            else {
-                // Option provided! Check type.
-                let typeMatches = false;
-                if (Array.isArray(opt.type)) {
-                    typeMatches = opt.type.indexOf(typeof providedValue) !== -1;
-                }
-                else {
-                    typeMatches = typeof providedValue === opt.type;
-                }
-                if (!typeMatches) {
-                    // Validators may be synchronous.
-                    if (callbackCalled) {
-                        return;
-                    }
-                    callbackCalled = true;
-                    throw new ApiError(ErrorCode.EINVAL, `[${fsName}] 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}\nOption description: ${opt.description}`);
-                }
-                else if (opt.validator) {
-                    pendingValidators++;
-                    try {
-                        await opt.validator(providedValue);
-                    }
-                    catch (e) {
-                        if (!callbackCalled) {
-                            if (e) {
-                                callbackCalled = true;
-                                throw e;
-                            }
-                            pendingValidators--;
-                            if (pendingValidators === 0 && loopEnded) {
-                                return;
-                            }
-                        }
-                    }
-                }
-                // Otherwise: All good!
-            }
-        }
-    }
-    loopEnded = true;
-    if (pendingValidators === 0 && !callbackCalled) {
-        return;
-    }
-}
 /** Waits n ms.  */
 export function wait(ms) {
     return new Promise(resolve => {
@@ -198,34 +117,86 @@ export function toPromise(fn) {
  */
 export const setImmediate = typeof globalThis.setImmediate == 'function' ? globalThis.setImmediate : cb => setTimeout(cb, 0);
 /**
+ * Encodes a string into a buffer
  * @internal
  */
-export const ROOT_NODE_ID = '/';
+export function encode(input, encoding = 'utf8') {
+    switch (encoding) {
+        case 'ascii':
+            return new TextEncoder().encode(input).map(v => v & 0x7f);
+        case 'latin1':
+        case 'binary':
+        case 'utf8':
+        case 'utf-8':
+        case 'base64':
+        case 'base64url':
+        case 'hex':
+            return new TextEncoder().encode(input);
+        case 'utf16le':
+        case 'ucs2':
+        case 'ucs-2':
+            return new TextEncoder().encode(input).slice(0, -1);
+        default:
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
+    }
+}
 /**
+ * Decodes a string from a buffer
  * @internal
- * Used for caching text decoders
  */
-const decoderCache = new Map();
-const textEncoder = new globalThis.TextEncoder();
-export function encode(input, encoding = 'utf8') {
-    return textEncoder.encode(input);
-}
 export function decode(input, encoding = 'utf8') {
-    if (!decoderCache.has(encoding)) {
-        const textDecoder = new globalThis.TextDecoder(encoding);
-        decoderCache.set(encoding, textDecoder.decode.bind(textDecoder));
+    switch (encoding) {
+        case 'ascii':
+        case 'utf8':
+        case 'utf-8':
+            return new TextDecoder().decode(input);
+        case 'latin1':
+        case 'binary':
+            return new TextDecoder('latin1').decode(input);
+        case 'utf16le':
+        case 'ucs2':
+        case 'ucs-2':
+            let utf16leString = '';
+            for (let i = 0; i < input.length; i += 2) {
+                const code = input[i] | (input[i + 1] << 8);
+                utf16leString += String.fromCharCode(code);
+            }
+            return utf16leString;
+        case 'base64':
+            return btoa(Array.from(input)
+                .map(v => String.fromCharCode(v))
+                .join(''));
+        case 'base64url':
+            return decode(input, 'base64').replace('/', '_').replace('+', '-');
+        case 'hex':
+            return Array.from(input)
+                .map(e => e.toString(16))
+                .join('');
+        default:
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
     }
-    return decoderCache.get(encoding)(input);
 }
 /**
- * Generates a random ID.
+ * Decodes a directory listing
  * @internal
  */
-export function randomUUID() {
-    // From http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0;
-        const v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
+export function decodeDirListing(data) {
+    return JSON.parse(decode(data), (k, v) => {
+        if (k == '') {
+            return v;
+        }
+        return BigInt(v);
     });
 }
+/**
+ * Encodes a directory listing
+ * @internal
+ */
+export function encodeDirListing(data) {
+    return encode(JSON.stringify(data, (k, v) => {
+        if (k == '') {
+            return v;
+        }
+        return v.toString();
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",
@@ -36,10 +36,11 @@
   "scripts": {
     "format": "prettier --write src test",
     "format:check": "prettier --check src test",
-    "lint": "eslint src test",
+    "lint": "eslint src test && tsc -p tsconfig.json --noEmit",
     "test": "cross-env NODE_OPTIONS=--experimental-vm-modules npx jest",
-    "build": "node scripts/build.mjs",
+    "build": "node scripts/build.js",
     "build:docs": "typedoc --out docs --name ZenFS src/index.ts",
+    "dev": "node scripts/build.js --watch",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {