@zenfs/core 0.0.7 → 0.0.8

package/dist/emulation/path.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ParsedPath } from 'node:path';
+export declare const cwd = "/";
+export declare const sep = "/";
+export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+export declare function formatExt(ext: string): string;
+export declare function resolve(...args: string[]): string;
+export declare function normalize(path: string): string;
+export declare function isAbsolute(path: string): boolean;
+export declare function join(...args: string[]): string;
+export declare function relative(from: string, to: string): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string, suffix?: string): string;
+export declare function extname(path: string): string;
+export declare function format(pathObject: ParsedPath): string;
+export declare function parse(path: string): ParsedPath;

package/dist/emulation/path.js

@@ -0,0 +1,451 @@
+/*
+Copyright Joyent, Inc. and other Node contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+export const cwd = '/';
+export const sep = '/';
+function validateString(str, name) {
+    if (typeof str != 'string') {
+        throw new TypeError(`"${name}" is not a string`);
+    }
+}
+function validateObject(str, name) {
+    if (typeof str != 'object') {
+        throw new TypeError(`"${name}" is not an object`);
+    }
+}
+// Resolves . and .. elements in a path with directory names
+export function normalizeString(path, allowAboveRoot) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let char = '\x00';
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            char = path[i];
+        }
+        else if (char == '/') {
+            break;
+        }
+        else {
+            char = '/';
+        }
+        if (char == '/') {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (dots === 2) {
+                if (res.length < 2 || lastSegmentLength !== 2 || res.at(-1) !== '.' || res.at(-2) !== '.') {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf('/');
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? '/..' : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += '/' + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (char === '.' && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export function formatExt(ext) {
+    return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
+}
+export function resolve(...args) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? args[i] : cwd;
+        validateString(path, `paths[${i}]`);
+        // Skip empty entries
+        if (path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = path[0] === '/';
+    }
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : '.';
+}
+export function normalize(path) {
+    validateString(path, 'path');
+    if (path.length === 0)
+        return '.';
+    const isAbsolute = path[0] === '/';
+    const trailingSeparator = path.at(-1) === '/';
+    // Normalize the path
+    path = normalizeString(path, !isAbsolute);
+    if (path.length === 0) {
+        if (isAbsolute)
+            return '/';
+        return trailingSeparator ? './' : '.';
+    }
+    if (trailingSeparator)
+        path += '/';
+    return isAbsolute ? `/${path}` : path;
+}
+export function isAbsolute(path) {
+    validateString(path, 'path');
+    return path.length > 0 && path[0] === '/';
+}
+export function join(...args) {
+    if (args.length === 0)
+        return '.';
+    let joined;
+    for (let i = 0; i < args.length; ++i) {
+        const arg = args[i];
+        validateString(arg, 'path');
+        if (arg.length > 0) {
+            if (joined === undefined)
+                joined = arg;
+            else
+                joined += `/${arg}`;
+        }
+    }
+    if (joined === undefined)
+        return '.';
+    return normalize(joined);
+}
+export function relative(from, to) {
+    validateString(from, 'from');
+    validateString(to, 'to');
+    if (from === to)
+        return '';
+    // Trim leading forward slashes.
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return '';
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+    // Compare paths to find the longest common path from root
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+        const fromCode = from[fromStart + i];
+        if (fromCode !== to[toStart + i])
+            break;
+        else if (fromCode === '/')
+            lastCommonSep = i;
+    }
+    if (i === length) {
+        if (toLen > length) {
+            if (to[toStart + i] === '/') {
+                // We get here if `from` is the exact base path for `to`.
+                // For example: from='/foo/bar'; to='/foo/bar/baz'
+                return to.slice(toStart + i + 1);
+            }
+            if (i === 0) {
+                // We get here if `from` is the root
+                // For example: from='/'; to='/foo'
+                return to.slice(toStart + i);
+            }
+        }
+        else if (fromLen > length) {
+            if (from[fromStart + i] === '/') {
+                // We get here if `to` is the exact base path for `from`.
+                // For example: from='/foo/bar/baz'; to='/foo/bar'
+                lastCommonSep = i;
+            }
+            else if (i === 0) {
+                // We get here if `to` is the root.
+                // For example: from='/foo/bar'; to='/'
+                lastCommonSep = 0;
+            }
+        }
+    }
+    let out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`.
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd || from[i] === '/') {
+            out += out.length === 0 ? '..' : '/..';
+        }
+    }
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts.
+    return `${out}${to.slice(toStart + lastCommonSep)}`;
+}
+export function dirname(path) {
+    validateString(path, 'path');
+    if (path.length === 0)
+        return '.';
+    const hasRoot = path[0] === '/';
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+        if (path[i] === '/') {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            // We saw the first non-path separator
+            matchedSlash = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1)
+        return '//';
+    return path.slice(0, end);
+}
+export function basename(path, suffix) {
+    if (suffix !== undefined)
+        validateString(suffix, 'ext');
+    validateString(path, 'path');
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) {
+        if (suffix === path)
+            return '';
+        let extIdx = suffix.length - 1;
+        let firstNonSlashEnd = -1;
+        for (let i = path.length - 1; i >= 0; --i) {
+            if (path[i] === '/') {
+                // If we reached a path separator that was not part of a set of path
+                // separators at the end of the string, stop now
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else {
+                if (firstNonSlashEnd === -1) {
+                    // We saw the first non-path separator, remember this index in case
+                    // we need it if the extension ends up not matching
+                    matchedSlash = false;
+                    firstNonSlashEnd = i + 1;
+                }
+                if (extIdx >= 0) {
+                    // Try to match the explicit extension
+                    if (path[i] === suffix[extIdx]) {
+                        if (--extIdx === -1) {
+                            // We matched the extension, so mark this as the end of our path
+                            // component
+                            end = i;
+                        }
+                    }
+                    else {
+                        // Extension does not match, so our result is the entire path
+                        // component
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                    }
+                }
+            }
+        }
+        if (start === end)
+            end = firstNonSlashEnd;
+        else if (end === -1)
+            end = path.length;
+        return path.slice(start, end);
+    }
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // path component
+            matchedSlash = false;
+            end = i + 1;
+        }
+    }
+    if (end === -1)
+        return '';
+    return path.slice(start, end);
+}
+export function extname(path) {
+    validateString(path, 'path');
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (path[i] === '.') {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return '';
+    }
+    return path.slice(startDot, end);
+}
+export function format(pathObject) {
+    validateObject(pathObject, 'pathObject');
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base || `${pathObject.name || ''}${formatExt(pathObject.ext)}`;
+    if (!dir) {
+        return base;
+    }
+    return dir === pathObject.root ? `${dir}${base}` : `${dir}/${base}`;
+}
+export function parse(path) {
+    validateString(path, 'path');
+    const isAbsolute = path[0] === '/';
+    const ret = { root: isAbsolute ? '/' : '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0)
+        return ret;
+    const start = isAbsolute ? 1 : 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    // Get non-dir info
+    for (; i >= start; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (path[i] === '.') {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (end !== -1) {
+        const start = startPart === 0 && isAbsolute ? 1 : startPart;
+        if (startDot === -1 ||
+            // We saw a non-dot character immediately before the dot
+            preDotState === 0 ||
+            // The (right-most) trimmed path component is exactly '..'
+            (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+            ret.base = ret.name = path.slice(start, end);
+        }
+        else {
+            ret.name = path.slice(start, startDot);
+            ret.base = path.slice(start, end);
+            ret.ext = path.slice(startDot, end);
+        }
+    }
+    if (startPart > 0)
+        ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolute)
+        ret.dir = '/';
+    return ret;
+}

package/dist/emulation/shared.js

@@ -1,5 +1,5 @@
 // Utilities and shared data
-import { posix as path } from 'path';
+import { resolve } from './path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { Cred } from '../cred.js';
 //import { BackendConstructor } from '../backends.js';
@@ -52,7 +52,7 @@ export function normalizePath(p) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must not be empty.');
     }
     p = p.replaceAll(/\/+/g, '/');
-    return path.resolve(p);
+    return resolve(p);
 }
 export function normalizeOptions(options, defEnc, defFlag, defMode) {
     // typeof null === 'object' so special-case handing is needed.
@@ -129,7 +129,7 @@ export function mount(mountPoint, fs) {
     if (mountPoint[0] !== '/') {
         mountPoint = '/' + mountPoint;
     }
-    mountPoint = path.resolve(mountPoint);
+    mountPoint = resolve(mountPoint);
     if (mounts.has(mountPoint)) {
         throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
     }
@@ -142,7 +142,7 @@ export function umount(mountPoint) {
     if (mountPoint[0] !== '/') {
         mountPoint = `/${mountPoint}`;
     }
-    mountPoint = path.resolve(mountPoint);
+    mountPoint = resolve(mountPoint);
     if (!mounts.has(mountPoint)) {
         throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
     }

package/dist/filesystem.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a;
 import { ApiError, ErrorCode } from './ApiError.js';
 import { FileFlag, ActionType } from './file.js';
-import * as path from 'path';
+import * as path from './emulation/path.js';
 import { Buffer } from 'buffer';
 /**
  * Structure for a filesystem. **All** ZenFS FileSystems must implement

package/dist/utils.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ErrorCode, ApiError } from './ApiError.js';
-import * as path from 'path';
+import * as path from './emulation/path.js';
 import { Buffer } from 'buffer';
 /**
  * Synchronous recursive makedir.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",
@@ -53,10 +53,8 @@
     "buffer": "~5.1.0",
     "cross-env": "^7.0.3",
     "esbuild": "^0.17.18",
-    "esbuild-plugin-polyfill-node": "^0.3.0",
     "eslint": "^8.36.0",
     "jest": "^29.5.0",
-    "path": "^0.12.7",
     "prettier": "^2.8.7",
     "ts-jest": "^29.1.0",
     "typedoc": "^0.25.1",

package/{README.md → readme.md}

@@ -33,10 +33,10 @@ npm install @zenfs/core
 
 ## Usage
 
-> 🛈 The examples are written in ESM. If you are using CJS, you can `require` the package. If running in a borwser you can add a script tag to your HTML pointing to the `browser.min.js` and use ZenFS via the global `ZenFS` object.
+> 🛈 The examples are written in ESM. If you are using CJS, you can `require` the package. If running in a browser you can add a script tag to your HTML pointing to the `browser.min.js` and use ZenFS via the global `ZenFS` object.
 
 ```js
-import { fs } from '@zenfs/core';
+import fs from '@zenfs/core';
 
 fs.writeFileSync('/test.txt', 'Cool, I can do this in the browser!');
 
@@ -46,14 +46,15 @@ console.log(contents);
 
 #### Using different backends
 
-A `InMemory` backend is created by default. If you would like to use a different one, you must configure ZenFS. It is recommended to do so using the `configure` function. Here is an example using the `LocalStorage` backend from `@zenfs/fs-dom`:
+A `InMemory` backend is created by default. If you would like to use a different one, you must configure ZenFS. It is recommended to do so using the `configure` function. Here is an example using the `Storage` backend from `@zenfs/fs-dom`:
 
 ```js
-import { configure, fs } from '@zenfs/core';
-import '@zenfs/fs-dom'; // size effects are needed
+import { configure, fs, registerBackend } from '@zenfs/core';
+import { StorageFileSystem } from '@zenfs/fs-dom';
+registerBackend(StorageFileSystem);
 
 // you can also add a callback as the last parameter instead of using promises
-await configure({ fs: 'LocalStorage' });
+await configure({ fs: 'Storage' });
 
 if (!fs.existsSync('/test.txt')) {
 	fs.writeFileSync('/test.txt', 'This will persist across reloads!');
@@ -65,13 +66,14 @@ console.log(contents);
 
 #### Using multiple backends
 
-You can use multiple backends by passing an object to `configure` which maps paths to file systems. The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`, and IndexedDB browser-local storage to `/home` (note that `/` has the default in-memory backend):
+You can use multiple backends by passing an object to `configure` which maps paths to file systems. The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`, and IndexedDB storage to `/home` (note that `/` has the default in-memory backend):
 
 ```js
-import { configure } from '@zenfs/core';
-import '@zenfs/fs-dom';
-import '@zenfs/fs-zip';
+import { configure, registerBackend } from '@zenfs/core';
+import { IndexedDBFileSystem } from '@zenfs/fs-dom';
+import { ZipFS } from '@zenfs/fs-zip';
 import Buffer from 'buffer';
+registerBackend(IndexedDBFileSystem, ZipFS);
 
 const zipData = await (await fetch('mydata.zip')).arrayBuffer();
 
@@ -92,8 +94,9 @@ await configure({
 The FS promises API is exposed as `promises`.
 
 ```js
-import { configure, promises } from '@zenfs/core';
-import '@zenfs/fs-dom';
+import { configure, promises, registerBackend } from '@zenfs/core';
+import { IndexedDBFileSystem } from '@zenfs/fs-dom';
+registerBackend(IndexedDBFileSystem);
 
 await configure({ '/': 'IndexedDB' });
 
@@ -111,7 +114,8 @@ You may have noticed that attempting to use a synchronous method on an asynchron
 
 ```js
 import { configure, fs } from '@zenfs/core';
-import '@zenfs/fs-dom';
+import { IndexedDBFileSystem } from '@zenfs/fs-dom';
+registerBackend(IndexedDBFileSystem);
 
 await configure({
 	'/': { fs: 'AsyncMirror', options: { sync: { fs: 'InMemory' }, async: { fs: 'IndexedDB' } } }
@@ -161,10 +165,10 @@ fs.umount('/tmp'); // unmount /tmp
 This could be used in the "multiple backends" example like so:
 
 ```js
-import { configure, fs, ZipFS } from '@zenfs/core';
-import '@zenfs/fs-dom';
-import '@zenfs/fs-zip';
+import { IndexedDBFileSystem } from '@zenfs/fs-dom';
+import { ZipFS } from '@zenfs/fs-zip';
 import Buffer from 'buffer';
+registerBackend(IndexedDBFileSystem);
 
 await configure({
 	'/tmp': 'InMemory',
@@ -238,10 +242,10 @@ export default {
 You can use any _synchronous_ ZenFS file systems with Emscripten.
 
 ```js
-import { EmscriptenFS } from '@zenfs/fs-emscripten';
-const BFS = new EmscriptenFS(); // Create a ZenFS Emscripten FS plugin.
-FS.createFolder(FS.root, 'data', true, true); // Create the folder that we'll turn into a mount point.
-FS.mount(BFS, { root: '/' }, '/data'); // Mount BFS's root folder into the '/data' folder.
+import { EmscriptenFSPlugin } from '@zenfs/fs-emscripten';
+const BFS = new EmscriptenFSPlugin(); // Create a ZenFS Emscripten FS plugin.
+FS.createFolder(FS.root, 'data', true, true); // Create the folder to turn into a mount point.
+FS.mount(BFS, { root: '/' }, '/data'); // Mount BFS's root folder into /data.
 ```
 
 If you want to use an asynchronous backend, you must wrap it in an `AsyncMirror`.