@zenfs/core 0.3.4 → 0.4.0

package/dist/stats.js

@@ -10,7 +10,8 @@ export var FileType;
     FileType[FileType["SYMLINK"] = S_IFLNK] = "SYMLINK";
 })(FileType = FileType || (FileType = {}));
 /**
- * Common code used by both Stats and BigIntStats
+ * Provides information about a particular entry in the file system.
+ * Common code used by both Stats and BigIntStats.
  */
 export class StatsCommon {
     get _typename() {
@@ -47,19 +48,9 @@ export class StatsCommon {
         this.birthtimeMs = this._convert(value.getTime());
     }
     /**
-     * Provides information about a particular entry in the file system.
-     * @param itemType Type of the item (FILE, DIRECTORY, SYMLINK, or SOCKET)
-     * @param size Size of the item in bytes. For directories/symlinks,
-     *   this is normally the size of the struct that represents the item.
-     * @param mode Unix-style file mode (e.g. 0o644)
-     * @param atimeMs time of last access, in milliseconds since epoch
-     * @param mtimeMs time of last modification, in milliseconds since epoch
-     * @param ctimeMs time of last time file status was changed, in milliseconds since epoch
-     * @param uid the id of the user that owns the file
-     * @param gid the id of the group that owns the file
-     * @param birthtimeMs time of file creation, in milliseconds since epoch
+     * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
-    constructor(itemType = FileType.FILE, size = -1, mode, atimeMs, mtimeMs, ctimeMs, uid, gid, birthtimeMs) {
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode } = {}) {
         /**
          * ID of device containing file
          */
@@ -93,7 +84,7 @@ export class StatsCommon {
          */
         this.fileData = null;
         const currentTime = Date.now();
-        const resolveT = (v, def) => (typeof v == this._typename ? v : this._convert(typeof v == this._typename_inverse ? v : def));
+        const resolveT = (val, _default) => (typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val : _default));
         this.atimeMs = resolveT(atimeMs, currentTime);
         this.mtimeMs = resolveT(mtimeMs, currentTime);
         this.ctimeMs = resolveT(ctimeMs, currentTime);
@@ -101,6 +92,7 @@ export class StatsCommon {
         this.uid = resolveT(uid, 0);
         this.gid = resolveT(gid, 0);
         this.size = this._convert(size);
+        const itemType = Number(mode) & S_IFMT || FileType.FILE;
         if (mode) {
             this.mode = this._convert(mode);
         }
@@ -229,9 +221,10 @@ export class Stats extends StatsCommon {
     }
     /**
      * Clones the stats object.
+     * @deprecated use `new Stats(stats)`
      */
-    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);
+    static clone(stats) {
+        return new Stats(stats);
     }
 }
 Stats;
@@ -246,9 +239,10 @@ export class BigIntStats extends StatsCommon {
     }
     /**
      * Clone a stats object.
+     * @deprecated use `new BigIntStats(stats)`
      */
-    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));
+    static clone(stats) {
+        return new BigIntStats(stats);
     }
 }
 BigIntStats;

package/dist/utils.d.ts

@@ -7,23 +7,18 @@ declare global {
 }
 /**
  * Synchronous recursive makedir.
- * @internal
+ * @hidden
  */
 export declare function mkdirpSync(p: string, mode: number, cred: Cred, fs: FileSystem): void;
 /**
  * Calculates levenshtein distance.
- * @internal
+ * @hidden
  */
 export declare function levenshtein(a: string, b: string): number;
 /** Waits n ms.  */
 export declare function wait(ms: number): Promise<void>;
 /**
- * Converts a callback into a promise. Assumes last parameter is the callback
- * @todo Look at changing resolve value from cbArgs[0] to include other callback arguments?
- */
-export declare function toPromise(fn: (...fnArgs: unknown[]) => unknown): (...args: unknown[]) => Promise<unknown>;
-/**
- * @internal
+ * @hidden
  */
 export declare const setImmediate: (callback: () => unknown) => void;
 /**

package/dist/utils.js

@@ -1,25 +1,21 @@
 import { ApiError, ErrorCode } from './ApiError.js';
-import * as path from './emulation/path.js';
+import { dirname } from './emulation/path.js';
 /**
  * Synchronous recursive makedir.
- * @internal
+ * @hidden
  */
 export function mkdirpSync(p, mode, cred, fs) {
     if (!fs.existsSync(p, cred)) {
-        mkdirpSync(path.dirname(p), mode, cred, fs);
+        mkdirpSync(dirname(p), mode, cred, fs);
         fs.mkdirSync(p, mode, cred);
     }
 }
-/*
- * Levenshtein distance, from the `js-levenshtein` NPM module.
- * Copied here to avoid complexity of adding another CommonJS module dependency.
- */
 function _min(d0, d1, d2, bx, ay) {
     return Math.min(d0 + 1, d1 + 1, d2 + 1, bx === ay ? d1 : d1 + 1);
 }
 /**
  * Calculates levenshtein distance.
- * @internal
+ * @hidden
  */
 export function levenshtein(a, b) {
     if (a === b) {
@@ -94,26 +90,7 @@ export function wait(ms) {
     });
 }
 /**
- * Converts a callback into a promise. Assumes last parameter is the callback
- * @todo Look at changing resolve value from cbArgs[0] to include other callback arguments?
- */
-export function toPromise(fn) {
-    return function (...args) {
-        return new Promise((resolve, reject) => {
-            args.push((e, ...cbArgs) => {
-                if (e) {
-                    reject(e);
-                }
-                else {
-                    resolve(cbArgs[0]);
-                }
-            });
-            fn(...args);
-        });
-    };
-}
-/**
- * @internal
+ * @hidden
  */
 export const setImmediate = typeof globalThis.setImmediate == 'function' ? globalThis.setImmediate : cb => setTimeout(cb, 0);
 /**
@@ -121,21 +98,45 @@ export const setImmediate = typeof globalThis.setImmediate == 'function' ? globa
  * @internal
  */
 export function encode(input, encoding = 'utf8') {
+    if (typeof input != 'string') {
+        throw new ApiError(ErrorCode.EINVAL, 'Can not encode a non-string');
+    }
     switch (encoding) {
         case 'ascii':
-            return new globalThis.TextEncoder().encode(input).map(v => v & 0x7f);
         case 'latin1':
         case 'binary':
+            return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
         case 'utf8':
         case 'utf-8':
+            return new Uint8Array(Array.from(input).flatMap(char => {
+                const code = char.charCodeAt(0);
+                if (code < 0x80) {
+                    return code;
+                }
+                const a = (code & 0x3f) | 0x80;
+                if (code < 0x800) {
+                    return [(code >> 6) | 0xc0, a];
+                }
+                const b = ((code >> 6) & 0x3f) | 0x80;
+                if (code < 0x10000) {
+                    return [(code >> 12) | 0xe0, b, a];
+                }
+                return [(code >> 18) | 0xf0, ((code >> 12) & 0x3f) | 0x80, b, a];
+            }));
         case 'base64':
+            return encode(atob(input), 'utf-8');
         case 'base64url':
+            return encode(input.replace('_', '/').replace('-', '+'), 'base64');
         case 'hex':
-            return new globalThis.TextEncoder().encode(input);
+            return new Uint8Array(input.match(/.{1,2}/g).map(e => parseInt(e, 16)));
         case 'utf16le':
         case 'ucs2':
         case 'ucs-2':
-            return new globalThis.TextEncoder().encode(input).slice(0, -1);
+            const u16 = new Uint16Array(new ArrayBuffer(input.length * 2));
+            for (let i = 0; i < input.length; i++) {
+                u16[i] = input.charCodeAt(i);
+            }
+            return new Uint8Array(u16.buffer);
         default:
             throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
     }
@@ -145,14 +146,36 @@ export function encode(input, encoding = 'utf8') {
  * @internal
  */
 export function decode(input, encoding = 'utf8') {
+    if (!(input instanceof Uint8Array)) {
+        throw new ApiError(ErrorCode.EINVAL, 'Can not decode a non-Uint8Array');
+    }
     switch (encoding) {
         case 'ascii':
-        case 'utf8':
-        case 'utf-8':
-            return new globalThis.TextDecoder().decode(input);
         case 'latin1':
         case 'binary':
-            return new globalThis.TextDecoder('latin1').decode(input);
+            return Array.from(input)
+                .map(char => String.fromCharCode(char))
+                .join('');
+        case 'utf8':
+        case 'utf-8':
+            let utf8String = '';
+            for (let i = 0; i < input.length; i++) {
+                let code;
+                if (input[i] < 0x80) {
+                    code = input[i];
+                }
+                else if (input[i] < 0xe0) {
+                    code = ((input[i] & 0x1f) << 6) | (input[++i] & 0x3f);
+                }
+                else if (input[i] < 0xf0) {
+                    code = ((input[i] & 0x0f) << 12) | ((input[++i] & 0x3f) << 6) | (input[++i] & 0x3f);
+                }
+                else {
+                    code = ((input[i] & 0x07) << 18) | ((input[++i] & 0x3f) << 12) | ((input[++i] & 0x3f) << 6) | (input[++i] & 0x3f);
+                }
+                utf8String += String.fromCharCode(code);
+            }
+            return utf8String;
         case 'utf16le':
         case 'ucs2':
         case 'ucs-2':
@@ -163,14 +186,12 @@ export function decode(input, encoding = 'utf8') {
             }
             return utf16leString;
         case 'base64':
-            return btoa(Array.from(input)
-                .map(v => String.fromCharCode(v))
-                .join(''));
+            return btoa(decode(input, 'utf-8'));
         case 'base64url':
             return decode(input, 'base64').replace('/', '_').replace('+', '-');
         case 'hex':
             return Array.from(input)
-                .map(e => e.toString(16))
+                .map(e => e.toString(16).padStart(2, '0'))
                 .join('');
         default:
             throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",
@@ -9,6 +9,9 @@
     "node",
     "storage"
   ],
+  "bin": {
+    "make-index": "./scripts/make-index.js"
+  },
   "type": "module",
   "homepage": "https://github.com/zen-fs/core",
   "author": "James P. <jp@drvortex.dev> (https://drvortex.dev)",
@@ -46,6 +49,7 @@
   "dependencies": {
     "@types/node": "^14.0.0",
     "@types/readable-stream": "^4.0.10",
+    "minimatch": "^9.0.3",
     "readable-stream": "^4.5.2"
   },
   "devDependencies": {

package/readme.md

@@ -15,7 +15,7 @@ ZenFS is highly extensible, and includes a few built-in backends:
 
 More backends can be defined by separate libraries, as long as they implement `FileSystem`.
 
-ZenFS supports a number of other backends (many are provided as seperate packages under `@zenfs`).
+ZenFS supports a number of other backends. Many are provided as seperate packages under `@zenfs`.
 
 For more information, see the [API documentation for ZenFS](https://zen-fs.github.io/core).
 
@@ -39,7 +39,7 @@ const contents = fs.readFileSync('/test.txt', 'utf-8');
 console.log(contents);
 ```
 
-#### Using different and/or different backends
+#### Using different and/or multiple backends
 
 A single `InMemory` backend is created by default, mounted on `/`.
 
@@ -50,7 +50,7 @@ You can use multiple backends by passing an object to `configure` which maps pat
 The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`, and IndexedDB to `/home`. Note that `/` has the default in-memory backend.
 
 ```js
-import { configure } from '@zenfs/core';
+import { configure, InMemory } from '@zenfs/core';
 import { IndexedDB } from '@zenfs/dom';
 import { Zip } from '@zenfs/zip';
 
@@ -58,13 +58,17 @@ const zipData = await (await fetch('mydata.zip')).arrayBuffer();
 
 await configure({
 	'/mnt/zip': { backend: Zip, zipData },
-	'/tmp': 'InMemory',
+	'/tmp': InMemory,
 	'/home': IndexedDB,
 };
 ```
 
 > [!TIP]
-> When configuring a mount point, you can pass in 1. A string that maps to a built-in backend 2. A `Backend` object, if the backend has no required options 3. An object that has a `backend` property which is a `Backend` or a string that maps to a built-in backend and the options accepted by the backend
+> When configuring a mount point, you can pass in
+>
+> 1. A string that maps to a built-in backend
+> 2. A `Backend` object, if the backend has no required options
+> 3. An object that has the options accepted by the backend and a `backend` property which is (1) or (2)
 
 Here is an example that mounts the `Storage` backend from `@zenfs/dom` on `/`:
 
@@ -109,13 +113,13 @@ if (!exists) {
 You may have noticed that attempting to use a synchronous function on an asynchronous backend (e.g. `IndexedDB`) results in a "not supplied" error (`ENOTSUP`). If you would like to use an asynchronous backend synchronously you need to wrap it in an `AsyncMirror`:
 
 ```js
-import { configure, fs } from '@zenfs/core';
+import { configure, fs, AsyncMirror, InMemory } from '@zenfs/core';
 import { IndexedDB } from '@zenfs/dom';
 
 await configure({
 	'/': {
-		backend: 'AsyncMirror',
-		sync: 'InMemory',
+		backend: AsyncMirror,
+		sync: InMemory,
 		async: IndexedDB,
 	},
 });
@@ -130,12 +134,12 @@ If you would like to create backends without configure (e.g. to do something dyn
 You can then mount and unmount the backend instance by using `mount` and `umount`.
 
 ```js
-import { configure, createBackend } from '@zenfs/core';
+import { configure, createBackend, InMemory } from '@zenfs/core';
 import { IndexedDB  } from '@zenfs/dom';
 import { Zip } from '@zenfs/zip';
 
 await configure({
-	'/tmp': 'InMemory',
+	'/tmp': InMemory,
 	'/home': IndexedDB,
 };
 

package/scripts/make-index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { parseArgs } from 'util';
+import { statSync, readdirSync, writeFileSync } from 'fs';
+import { join } from 'path/posix';
+import { resolve } from 'path';
+import { minimatch } from 'minimatch';
+
+const {
+	values: options,
+	positionals: [root],
+} = parseArgs({
+	options: {
+		help: { short: 'h', type: 'boolean', default: false },
+		ignore: { short: 'i', type: 'string', multiple: true, default: [] },
+		output: { short: 'o', type: 'string', default: 'index.json' },
+		quiet: { short: 'q', type: 'boolean', default: false },
+		verbose: { type: 'boolean', default: false },
+	},
+	allowPositionals: true,
+	strict: true,
+});
+
+if (options.help) {
+	console.log(`make-index <path> [...options]
+	path: The path to create a listing for
+
+	options:
+		--help, -h				Outputs this help message
+		--quiet, -q 			Do not output messages about individual files
+		--verbose				Output verbose messages
+
+		--output, -o <path>		Path to the output file. Defaults to listing.
+		--ignore, -i <pattern>	Ignores files which match the glob <pattern>. Can be passed multiple times.
+	`);
+	process.exit();
+}
+
+if (options.quiet && options.verbose) {
+	console.log('Can not use both --verbose and --quiet.');
+	process.exit();
+}
+
+function pathToPosix(path) {
+	return path.replaceAll('\\', '/');
+}
+
+const colors = {
+	reset: 0,
+	black: 30,
+	red: 31,
+	green: 32,
+	yellow: 33,
+	blue: 34,
+	magenta: 35,
+	cyan: 36,
+	white: 37,
+	bright_black: 90,
+	bright_red: 91,
+	bright_green: 92,
+	bright_yellow: 93,
+	bright_blue: 94,
+	bright_magenta: 95,
+	bright_cyan: 96,
+	bright_white: 97,
+};
+
+function color(color, text) {
+	return `\x1b[${colors[color]}m${text}\x1b[0m`;
+}
+
+function makeListing(path, seen = new Set()) {
+	try {
+		const stats = statSync(path);
+
+		if (stats.isFile()) {
+			return null;
+		}
+
+		let entries = {};
+		for (const file of readdirSync(path)) {
+			const full = join(path, file);
+			if (options.ignore.some(pattern => minimatch(full, pattern))) {
+				if (!options.quiet) console.log(`${color('yellow', 'skip')} ${full}`);
+				continue;
+			}
+
+			entries[file] = makeListing(full, seen);
+		}
+		return entries;
+	} catch (e) {
+		if (!options.quiet) {
+			console.log(`${color('red', 'fail')} ${path}: ${e.message}`);
+		}
+	}
+}
+
+const listing = makeListing(pathToPosix(root));
+if (!options.quiet) console.log('Generated listing for ' + pathToPosix(resolve(root)));
+
+writeFileSync(options.output, JSON.stringify(listing));

package/dist/backends/index.d.ts

@@ -1,10 +0,0 @@
-import { AsyncMirror } from './AsyncMirror.js';
-import { InMemory } from './InMemory.js';
-import { Overlay } from './Overlay.js';
-import { Backend } from './backend.js';
-export declare const backends: {
-    [backend: string]: Backend;
-};
-export default backends;
-export { AsyncMirror, InMemory, Overlay };
-export declare function registerBackend(..._backends: Backend[]): void;

package/dist/backends/index.js

@@ -1,12 +0,0 @@
-import { AsyncMirror } from './AsyncMirror.js';
-import { InMemory } from './InMemory.js';
-import { Overlay } from './Overlay.js';
-export const backends = {};
-export default backends;
-export { AsyncMirror, InMemory, Overlay };
-export function registerBackend(..._backends) {
-    for (const backend of _backends) {
-        backends[backend.name] = backend;
-    }
-}
-registerBackend(AsyncMirror, InMemory, Overlay);