@zenfs/core 0.0.12 → 0.1.0

package/dist/utils.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { ErrorCode, ApiError } from './ApiError.js';
 import * as path from './emulation/path.js';
 /**
@@ -101,83 +92,81 @@ function levenshtein(a, b) {
  * Checks that the given options object is valid for the file system options.
  * @internal
  */
-export function checkOptions(backend, opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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}`);
+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;
                     }
-                    // Else: Optional option, not provided. That is OK.
+                    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 {
-                    // 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;
+                    typeMatches = typeof providedValue === opt.type;
+                }
+                if (!typeMatches) {
+                    // Validators may be synchronous.
+                    if (callbackCalled) {
+                        return;
                     }
-                    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}`);
+                    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);
                     }
-                    else if (opt.validator) {
-                        pendingValidators++;
-                        try {
-                            yield opt.validator(providedValue);
-                        }
-                        catch (e) {
-                            if (!callbackCalled) {
-                                if (e) {
-                                    callbackCalled = true;
-                                    throw e;
-                                }
-                                pendingValidators--;
-                                if (pendingValidators === 0 && loopEnded) {
-                                    return;
-                                }
+                    catch (e) {
+                        if (!callbackCalled) {
+                            if (e) {
+                                callbackCalled = true;
+                                throw e;
+                            }
+                            pendingValidators--;
+                            if (pendingValidators === 0 && loopEnded) {
+                                return;
                             }
                         }
                     }
-                    // Otherwise: All good!
                 }
+                // Otherwise: All good!
             }
         }
-        loopEnded = true;
-        if (pendingValidators === 0 && !callbackCalled) {
-            return;
-        }
-    });
+    }
+    loopEnded = true;
+    if (pendingValidators === 0 && !callbackCalled) {
+        return;
+    }
 }
 /** Waits n ms.  */
 export function wait(ms) {
@@ -212,10 +201,22 @@ export const setImmediate = typeof globalThis.setImmediate == 'function' ? globa
  * @internal
  */
 export const ROOT_NODE_ID = '/';
+/**
+ * @internal
+ * Used for caching text decoders
+ */
+const decoderCache = new Map();
 const textEncoder = new globalThis.TextEncoder();
-export const encode = textEncoder.encode.bind(textEncoder);
-const textDecoder = new globalThis.TextDecoder();
-export const decode = textDecoder.decode.bind(textDecoder);
+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));
+    }
+    return decoderCache.get(encoding)(input);
+}
 /**
  * Generates a random ID.
  * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.0.12",
+  "version": "0.1.0",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",
@@ -43,7 +43,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@types/node": "^14.0.0"
+    "@types/node": "^14.0.0",
+    "@types/readable-stream": "^4.0.10",
+    "readable-stream": "^4.5.2"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",

package/readme.md

@@ -1,6 +1,6 @@
 # ZenFS
 
-ZenFS is an in-browser file system that emulates the [Node JS file system API](http://nodejs.org/api/fs.html) and supports storing and retrieving files from various backends. ZenFS also integrates nicely into the Emscripten file system.
+ZenFS is an in-browser file system that emulates the [Node JS file system API](http://nodejs.org/api/fs.html) and supports storing and retrieving files from various backends. ZenFS also integrates nicely with other tools.
 
 ## Backends
 
@@ -254,44 +254,6 @@ If you want to use an asynchronous backend, you must wrap it in an `AsyncMirror`
 
 Run unit tests with `npm test`.
 
-### Citing
-
-ZenFS is a component of the [Doppio](http://doppiojvm.org/) and [Browsix](https://browsix.org/) research projects from the PLASMA lab at the University of Massachusetts Amherst. If you decide to use ZenFS in a project that leads to a publication, please cite the academic papers on [Doppio](https://dl.acm.org/citation.cfm?doid=2594291.2594293) and [Browsix](https://dl.acm.org/citation.cfm?id=3037727):
-
-> John Vilk and Emery D. Berger. Doppio: Breaking the Browser Language Barrier. In
-> _Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation_
-> (2014), pp. 508–518.
-
-```bibtex
-@inproceedings{VilkDoppio,
-	author		= {John Vilk and
-							 Emery D. Berger},
-	title		 = {{Doppio: Breaking the Browser Language Barrier}},
-	booktitle = {Proceedings of the 35th {ACM} {SIGPLAN} Conference on Programming Language Design and Implementation},
-	pages		 = {508--518},
-	year			= {2014},
-	url			 = {http://doi.acm.org/10.1145/2594291.2594293},
-	doi			 = {10.1145/2594291.2594293}
-}
-```
-
-> Bobby Powers, John Vilk, and Emery D. Berger. Browsix: Bridging the Gap Between Unix and the Browser. In _Proceedings of the Twenty-Second International Conference on Architectural Support for Programming Languages and Operating Systems_ (2017), pp. 253–266.
-
-```bibtex
-@inproceedings{PowersBrowsix,
-	author		= {Bobby Powers and
-							 John Vilk and
-							 Emery D. Berger},
-	title		 = {{Browsix: Bridging the Gap Between Unix and the Browser}},
-	booktitle = {Proceedings of the Twenty-Second International Conference on Architectural
-							 Support for Programming Languages and Operating Systems},
-	pages		 = {253--266},
-	year			= {2017},
-	url			 = {http://doi.acm.org/10.1145/3037697.3037727},
-	doi			 = {10.1145/3037697.3037727}
-}
-```
-
 ### License
 
-ZenFS is licensed under the MIT License. See `LICENSE` for details.
+ZenFS is licensed under the MIT License.