@zenfs/core 0.0.12 → 0.2.0

package/dist/stats.js

@@ -10,35 +10,41 @@ export var FileType;
     FileType[FileType["SYMLINK"] = S_IFLNK] = "SYMLINK";
 })(FileType = FileType || (FileType = {}));
 /**
- * Implementation of Node's `Stats`.
- *
- * Attribute descriptions are from `man 2 stat'
- * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
- * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ * Common code used by both Stats and BigIntStats
  */
-export class Stats {
-    static Deserialize(data) {
-        const view = new DataView('buffer' in data ? data.buffer : data);
-        const size = view.getUint32(0, true), mode = view.getUint32(4, true), atime = view.getFloat64(8, true), mtime = view.getFloat64(16, true), ctime = view.getFloat64(24, true), uid = view.getUint32(32, true), gid = view.getUint32(36, true);
-        return new Stats(mode & S_IFMT, size, mode & ~S_IFMT, atime, mtime, ctime, uid, gid);
+export class StatsCommon {
+    get _typename() {
+        return this._isBigint ? 'bigint' : 'number';
     }
-    /**
-     * Clones the stats object.
-     */
-    static clone(s) {
-        return new Stats(s.mode & S_IFMT, s.size, s.mode & ~S_IFMT, s.atimeMs, s.mtimeMs, s.ctimeMs, s.uid, s.gid, s.birthtimeMs);
+    get _typename_inverse() {
+        return this._isBigint ? 'number' : 'bigint';
+    }
+    _convert(arg) {
+        return (this._isBigint ? BigInt(arg) : Number(arg));
     }
     get atime() {
-        return new Date(this.atimeMs);
+        return new Date(Number(this.atimeMs));
+    }
+    set atime(value) {
+        this.atimeMs = this._convert(value.getTime());
     }
     get mtime() {
-        return new Date(this.mtimeMs);
+        return new Date(Number(this.mtimeMs));
+    }
+    set mtime(value) {
+        this.mtimeMs = this._convert(value.getTime());
     }
     get ctime() {
-        return new Date(this.ctimeMs);
+        return new Date(Number(this.ctimeMs));
+    }
+    set ctime(value) {
+        this.ctimeMs = this._convert(value.getTime());
     }
     get birthtime() {
-        return new Date(this.birthtimeMs);
+        return new Date(Number(this.birthtimeMs));
+    }
+    set birthtime(value) {
+        this.birthtimeMs = this._convert(value.getTime());
     }
     /**
      * Provides information about a particular entry in the file system.
@@ -53,113 +59,106 @@ export class Stats {
      * @param gid the id of the group that owns the file
      * @param birthtimeMs time of file creation, in milliseconds since epoch
      */
-    constructor(itemType, size, mode, atimeMs, mtimeMs, ctimeMs, uid, gid, birthtimeMs) {
-        // ID of device containing file
-        this.dev = 0;
-        // inode number
-        this.ino = 0;
-        // device ID (if special file)
-        this.rdev = 0;
-        // number of hard links
-        this.nlink = 1;
-        // blocksize for file system I/O
-        this.blksize = 4096;
-        // user ID of owner
-        this.uid = 0;
-        // group ID of owner
-        this.gid = 0;
-        // Some file systems stash data on stats objects.
+    constructor(itemType = FileType.FILE, size = -1, mode, atimeMs, mtimeMs, ctimeMs, uid, gid, birthtimeMs) {
+        /**
+         * ID of device containing file
+         */
+        this.dev = this._convert(0);
+        /**
+         * inode number
+         */
+        this.ino = this._convert(0);
+        /**
+         * device ID (if special file)
+         */
+        this.rdev = this._convert(0);
+        /**
+         * number of hard links
+         */
+        this.nlink = this._convert(1);
+        /**
+         * blocksize for file system I/O
+         */
+        this.blksize = this._convert(4096);
+        /**
+         * user ID of owner
+         */
+        this.uid = this._convert(0);
+        /**
+         * group ID of owner
+         */
+        this.gid = this._convert(0);
+        /**
+         * Some file systems stash data on stats objects.
+         */
         this.fileData = null;
-        this.size = size;
-        let currentTime = 0;
-        if (typeof atimeMs !== 'number') {
-            currentTime = Date.now();
-            atimeMs = currentTime;
-        }
-        if (typeof mtimeMs !== 'number') {
-            if (!currentTime) {
-                currentTime = Date.now();
-            }
-            mtimeMs = currentTime;
+        const currentTime = Date.now();
+        const resolveT = (v, def) => (typeof v == this._typename ? v : this._convert(typeof v == this._typename_inverse ? v : def));
+        this.atimeMs = resolveT(atimeMs, currentTime);
+        this.mtimeMs = resolveT(mtimeMs, currentTime);
+        this.ctimeMs = resolveT(ctimeMs, currentTime);
+        this.birthtimeMs = resolveT(birthtimeMs, currentTime);
+        this.uid = resolveT(uid, 0);
+        this.gid = resolveT(gid, 0);
+        this.size = this._convert(size);
+        if (mode) {
+            this.mode = this._convert(mode);
         }
-        if (typeof ctimeMs !== 'number') {
-            if (!currentTime) {
-                currentTime = Date.now();
-            }
-            ctimeMs = currentTime;
-        }
-        if (typeof birthtimeMs !== 'number') {
-            if (!currentTime) {
-                currentTime = Date.now();
-            }
-            birthtimeMs = currentTime;
-        }
-        if (typeof uid !== 'number') {
-            uid = 0;
-        }
-        if (typeof gid !== 'number') {
-            gid = 0;
-        }
-        this.atimeMs = atimeMs;
-        this.ctimeMs = ctimeMs;
-        this.mtimeMs = mtimeMs;
-        this.birthtimeMs = birthtimeMs;
-        if (!mode) {
+        else {
             switch (itemType) {
                 case FileType.FILE:
-                    this.mode = 0o644;
+                    this.mode = this._convert(0o644);
                     break;
                 case FileType.DIRECTORY:
                 default:
-                    this.mode = 0o777;
+                    this.mode = this._convert(0o777);
             }
         }
-        else {
-            this.mode = mode;
-        }
         // number of 512B blocks allocated
-        this.blocks = Math.ceil(size / 512);
-        // Check if mode also includes top-most bits, which indicate the file's
-        // type.
+        this.blocks = this._convert(Math.ceil(Number(size) / 512));
+        // Check if mode also includes top-most bits, which indicate the file's type.
         if ((this.mode & S_IFMT) == 0) {
-            this.mode |= itemType;
+            this.mode = (this.mode | this._convert(itemType));
         }
     }
-    serialize() {
-        const data = new Uint8Array(32), view = new DataView(data.buffer);
-        view.setUint32(0, this.size, true);
-        view.setUint32(4, this.mode, true);
-        view.setFloat64(8, this.atime.getTime(), true);
-        view.setFloat64(16, this.mtime.getTime(), true);
-        view.setFloat64(24, this.ctime.getTime(), true);
-        view.setUint32(32, this.uid, true);
-        view.setUint32(36, this.gid, true);
-        return data;
-    }
     /**
-     * @return [Boolean] True if this item is a file.
+     * @returns true if this item is a file.
      */
     isFile() {
         return (this.mode & S_IFMT) === S_IFREG;
     }
     /**
-     * @return [Boolean] True if this item is a directory.
+     * @returns True if this item is a directory.
      */
     isDirectory() {
         return (this.mode & S_IFMT) === S_IFDIR;
     }
     /**
-     * @return [Boolean] True if this item is a symbolic link (only valid through lstat)
+     * @returns true if this item is a symbolic link
      */
     isSymbolicLink() {
         return (this.mode & S_IFMT) === S_IFLNK;
     }
+    // Currently unsupported
+    isSocket() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
     /**
      * Checks if a given user/group has access to this item
      * @param mode The request access as 4 bits (unused, read, write, execute)
      * @param uid The requesting UID
      * @param gid The requesting GID
-     * @returns [Boolean] True if the request has access, false if the request does not
+     * @returns True if the request has access, false if the request does not
+     * @internal
      */
     hasAccess(mode, cred) {
         if (cred.euid === 0 || cred.egid === 0) {
@@ -181,46 +180,75 @@ export class Stats {
         /*
         Result = 0b0xxx (read, write, execute)
         If any bits are set that means the request does not have that permission.
-    */
+        */
         const result = uMode & gMode & wMode;
         return !result;
     }
     /**
      * Convert the current stats object into a cred object
+     * @internal
      */
-    getCred(uid = this.uid, gid = this.gid) {
-        return new Cred(uid, gid, this.uid, this.gid, uid, gid);
+    getCred(uid = Number(this.uid), gid = Number(this.gid)) {
+        return new Cred(uid, gid, Number(this.uid), Number(this.gid), uid, gid);
     }
     /**
      * Change the mode of the file. We use this helper function to prevent messing
      * up the type of the file, which is encoded in mode.
+     * @internal
      */
     chmod(mode) {
-        this.mode = (this.mode & S_IFMT) | mode;
+        this.mode = this._convert((this.mode & S_IFMT) | mode);
     }
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
+     * @internal
      */
     chown(uid, gid) {
-        if (!isNaN(+uid) && 0 <= +uid && +uid < Math.pow(2, 32)) {
-            this.uid = uid;
+        uid = Number(uid);
+        gid = Number(gid);
+        if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {
+            this.uid = this._convert(uid);
         }
-        if (!isNaN(+gid) && 0 <= +gid && +gid < Math.pow(2, 32)) {
-            this.gid = gid;
+        if (!isNaN(gid) && 0 <= gid && gid < 2 ** 32) {
+            this.gid = this._convert(gid);
         }
     }
-    // We don't support the following types of files.
-    isSocket() {
-        return false;
+}
+/**
+ * Implementation of Node's `Stats`.
+ *
+ * Attribute descriptions are from `man 2 stat'
+ * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
+ * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ */
+export class Stats extends StatsCommon {
+    constructor() {
+        super(...arguments);
+        this._isBigint = false;
     }
-    isBlockDevice() {
-        return false;
+    /**
+     * Clones the stats object.
+     */
+    static clone(s) {
+        return new Stats(s.mode & S_IFMT, s.size, s.mode & ~S_IFMT, s.atimeMs, s.mtimeMs, s.ctimeMs, s.uid, s.gid, s.birthtimeMs);
     }
-    isCharacterDevice() {
-        return false;
+}
+Stats;
+/**
+ * Stats with bigint
+ * @todo Implement with bigint instead of wrapping Stats
+ */
+export class BigIntStats extends StatsCommon {
+    constructor() {
+        super(...arguments);
+        this._isBigint = true;
     }
-    isFIFO() {
-        return false;
+    /**
+     * Clone a stats object.
+     */
+    static clone(s) {
+        return new BigIntStats(Number(s.mode) & S_IFMT, BigInt(s.size), BigInt(s.mode) & BigInt(~S_IFMT), BigInt(s.atimeMs), BigInt(s.mtimeMs), BigInt(s.ctimeMs), BigInt(s.uid), BigInt(s.gid), BigInt(s.birthtimeMs));
     }
 }
+BigIntStats;

package/dist/utils.d.ts

@@ -1,21 +1,28 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 /**
  * Grab bag of utility functions used across the code.
  */
 import { FileSystem } from './filesystem.js';
 import { Cred } from './cred.js';
-import type { BaseBackendConstructor } from './backends/backend.js';
-import type { TextEncoder as TextEncoderType, TextDecoder as TextDecoderType } from 'node:util';
+import type { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'node:util';
+declare global {
+    function setImmediate(callback: () => unknown): void;
+    function atob(data: string): string;
+    function btoa(data: string): string;
+    const TextDecoder: typeof _TextDecoder;
+    const TextEncoder: typeof _TextEncoder;
+}
 /**
  * Synchronous recursive makedir.
  * @internal
  */
 export declare function mkdirpSync(p: string, mode: number, cred: Cred, fs: FileSystem): void;
 /**
- * Checks that the given options object is valid for the file system options.
+ * Calculates levenshtein distance.
  * @internal
  */
-export declare function checkOptions(backend: BaseBackendConstructor, opts: object): Promise<void>;
+export declare function levenshtein(a: string, b: string): number;
 /** Waits n ms.  */
 export declare function wait(ms: number): Promise<void>;
 /**
@@ -26,18 +33,24 @@ export declare function toPromise(fn: (...fnArgs: unknown[]) => unknown): (...ar
 /**
  * @internal
  */
-export declare const setImmediate: (callback: () => unknown) => void;
+export declare const setImmediate: typeof globalThis.setImmediate | ((cb: any) => NodeJS.Timeout);
+/**
+ * Encodes a string into a buffer
+ * @internal
+ */
+export declare function encode(input: string, encoding?: BufferEncoding): Uint8Array;
+/**
+ * Decodes a string from a buffer
+ * @internal
+ */
+export declare function decode(input?: Uint8Array, encoding?: BufferEncoding): string;
 /**
+ * Decodes a directory listing
  * @internal
  */
-export declare const ROOT_NODE_ID: string;
-declare const textEncoder: TextEncoderType;
-export declare const encode: typeof textEncoder.encode;
-declare const textDecoder: TextDecoderType;
-export declare const decode: typeof textDecoder.decode;
+export declare function decodeDirListing(data: Uint8Array): Record<string, bigint>;
 /**
- * Generates a random ID.
+ * Encodes a directory listing
  * @internal
  */
-export declare function randomUUID(): string;
-export {};
+export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;

package/dist/utils.js

@@ -1,13 +1,4 @@
-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 { ApiError, ErrorCode } from './ApiError.js';
 import * as path from './emulation/path.js';
 /**
  * Synchronous recursive makedir.
@@ -28,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;
     }
@@ -97,88 +87,6 @@ function levenshtein(a, b) {
     }
     return dd;
 }
-/**
- * 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}`);
-                    }
-                    // 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 {
-                            yield 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 => {
@@ -209,22 +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 = '/';
-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') {
+    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
+ */
+export function decode(input, encoding = 'utf8') {
+    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);
+    }
+}
 /**
- * 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.0.12",
+  "version": "0.2.0",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",
@@ -36,14 +36,17 @@
   "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": {
-    "@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",