@zenfs/dom 0.0.1

package/dist/backends/IndexedDB.js

@@ -0,0 +1,234 @@
+var _a;
+import { AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { Buffer } from 'buffer';
+import { CreateBackend } from '@zenfs/core/backends/backend.js';
+/**
+ * Get the indexedDB constructor for the current browser.
+ * @hidden
+ */
+const indexedDB = (() => {
+    try {
+        return globalThis.indexedDB || globalThis.mozIndexedDB || globalThis.webkitIndexedDB || globalThis.msIndexedDB;
+    }
+    catch (_b) {
+        return null;
+    }
+})();
+/**
+ * Converts a DOMException or a DOMError from an IndexedDB event into a
+ * standardized ZenFS API error.
+ * @hidden
+ */
+function convertError(e, message = e.toString()) {
+    switch (e.name) {
+        case 'NotFoundError':
+            return new ApiError(ErrorCode.ENOENT, message);
+        case 'QuotaExceededError':
+            return new ApiError(ErrorCode.ENOSPC, message);
+        default:
+            // The rest do not seem to map cleanly to standard error codes.
+            return new ApiError(ErrorCode.EIO, message);
+    }
+}
+/**
+ * Produces a new onerror handler for IDB. Our errors are always fatal, so we
+ * handle them generically: Call the user-supplied callback with a translated
+ * version of the error, and let the error bubble up.
+ * @hidden
+ */
+function onErrorHandler(cb, code = ErrorCode.EIO, message = null) {
+    return function (e) {
+        // Prevent the error from canceling the transaction.
+        e.preventDefault();
+        cb(new ApiError(code, message !== null ? message : undefined));
+    };
+}
+/**
+ * @hidden
+ */
+export class IndexedDBROTransaction {
+    constructor(tx, store) {
+        this.tx = tx;
+        this.store = store;
+    }
+    get(key) {
+        return new Promise((resolve, reject) => {
+            try {
+                const r = this.store.get(key);
+                r.onerror = onErrorHandler(reject);
+                r.onsuccess = event => {
+                    // IDB returns the value 'undefined' when you try to get keys that
+                    // don't exist. The caller expects this behavior.
+                    const result = event.target.result;
+                    if (result === undefined) {
+                        resolve(result);
+                    }
+                    else {
+                        // IDB data is stored as an ArrayBuffer
+                        resolve(Buffer.from(result));
+                    }
+                };
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+}
+/**
+ * @hidden
+ */
+export class IndexedDBRWTransaction extends IndexedDBROTransaction {
+    constructor(tx, store) {
+        super(tx, store);
+    }
+    /**
+     * @todo return false when add has a key conflict (no error)
+     */
+    put(key, data, overwrite) {
+        return new Promise((resolve, reject) => {
+            try {
+                const r = overwrite ? this.store.put(data, key) : this.store.add(data, key);
+                r.onerror = onErrorHandler(reject);
+                r.onsuccess = () => {
+                    resolve(true);
+                };
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+    del(key) {
+        return new Promise((resolve, reject) => {
+            try {
+                const r = this.store.delete(key);
+                r.onerror = onErrorHandler(reject);
+                r.onsuccess = () => {
+                    resolve();
+                };
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+    commit() {
+        return new Promise(resolve => {
+            // Return to the event loop to commit the transaction.
+            setTimeout(resolve, 0);
+        });
+    }
+    abort() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.tx.abort();
+                resolve();
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+}
+export class IndexedDBStore {
+    static Create(storeName, indexedDB) {
+        return new Promise((resolve, reject) => {
+            const openReq = indexedDB.open(storeName, 1);
+            openReq.onupgradeneeded = event => {
+                const db = event.target.result;
+                // Huh. This should never happen; we're at version 1. Why does another
+                // database exist?
+                if (db.objectStoreNames.contains(storeName)) {
+                    db.deleteObjectStore(storeName);
+                }
+                db.createObjectStore(storeName);
+            };
+            openReq.onsuccess = event => {
+                resolve(new IndexedDBStore(event.target.result, storeName));
+            };
+            openReq.onerror = onErrorHandler(reject, ErrorCode.EACCES);
+        });
+    }
+    constructor(db, storeName) {
+        this.db = db;
+        this.storeName = storeName;
+    }
+    name() {
+        return IndexedDBFileSystem.Name + ' - ' + this.storeName;
+    }
+    clear() {
+        return new Promise((resolve, reject) => {
+            try {
+                const tx = this.db.transaction(this.storeName, 'readwrite'), objectStore = tx.objectStore(this.storeName), r = objectStore.clear();
+                r.onsuccess = () => {
+                    // Use setTimeout to commit transaction.
+                    setTimeout(resolve, 0);
+                };
+                r.onerror = onErrorHandler(reject);
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+    beginTransaction(type = 'readonly') {
+        const tx = this.db.transaction(this.storeName, type), objectStore = tx.objectStore(this.storeName);
+        if (type === 'readwrite') {
+            return new IndexedDBRWTransaction(tx, objectStore);
+        }
+        else if (type === 'readonly') {
+            return new IndexedDBROTransaction(tx, objectStore);
+        }
+        else {
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid transaction type.');
+        }
+    }
+}
+/**
+ * A file system that uses the IndexedDB key value file system.
+ */
+export class IndexedDBFileSystem extends AsyncKeyValueFileSystem {
+    static isAvailable(idbFactory = globalThis.indexedDB) {
+        try {
+            if (!(idbFactory instanceof IDBFactory)) {
+                return false;
+            }
+            const req = indexedDB.open('__zenfs_test__');
+            if (!req) {
+                return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    constructor({ cacheSize = 100, storeName = 'zenfs', idbFactory = globalThis.indexedDB }) {
+        super(cacheSize);
+        this._ready = IndexedDBStore.Create(storeName, idbFactory).then(store => {
+            this.init(store);
+            return this;
+        });
+    }
+}
+_a = IndexedDBFileSystem;
+IndexedDBFileSystem.Name = 'IndexedDB';
+IndexedDBFileSystem.Create = CreateBackend.bind(_a);
+IndexedDBFileSystem.Options = {
+    storeName: {
+        type: 'string',
+        optional: true,
+        description: 'The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.',
+    },
+    cacheSize: {
+        type: 'number',
+        optional: true,
+        description: 'The size of the inode cache. Defaults to 100. A size of 0 or below disables caching.',
+    },
+    idbFactory: {
+        type: 'object',
+        optional: true,
+        description: 'The IDBFactory to use. Defaults to globalThis.indexedDB.',
+    },
+};

package/dist/backends/Storage.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
+import { SyncKeyValueStore, SimpleSyncStore, SyncKeyValueFileSystem, SyncKeyValueRWTransaction } from '@zenfs/core/backends/SyncStore.js';
+import { type BackendOptions } from '@zenfs/core/backends/backend.js';
+/**
+ * A synchronous key-value store backed by Storage.
+ */
+export declare class StorageStore implements SyncKeyValueStore, SimpleSyncStore {
+    protected _storage: any;
+    name(): string;
+    constructor(_storage: any);
+    clear(): void;
+    beginTransaction(type: string): SyncKeyValueRWTransaction;
+    get(key: string): Buffer | undefined;
+    put(key: string, data: Buffer, overwrite: boolean): boolean;
+    del(key: string): void;
+}
+export declare namespace StorageFileSystem {
+    /**
+     * Options to pass to the StorageFileSystem
+     */
+    interface Options {
+        /**
+         * The Storage to use. Defaults to globalThis.localStorage.
+         */
+        storage: Storage;
+    }
+}
+/**
+ * A synchronous file system backed by a `Storage` (e.g. localStorage).
+ */
+export declare class StorageFileSystem extends SyncKeyValueFileSystem {
+    static readonly Name = "Storage";
+    static Create: any;
+    static readonly Options: BackendOptions;
+    static isAvailable(storage?: Storage): boolean;
+    /**
+     * Creates a new Storage file system using the contents of `Storage`.
+     */
+    constructor({ storage }: StorageFileSystem.Options);
+}

package/dist/backends/Storage.js

@@ -0,0 +1,75 @@
+var _a;
+import { SyncKeyValueFileSystem, SimpleSyncRWTransaction } from '@zenfs/core/backends/SyncStore.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { CreateBackend } from '@zenfs/core/backends/backend.js';
+import { Buffer } from 'buffer';
+/**
+ * A synchronous key-value store backed by Storage.
+ */
+export class StorageStore {
+    name() {
+        return StorageFileSystem.Name;
+    }
+    constructor(_storage) {
+        this._storage = _storage;
+    }
+    clear() {
+        this._storage.clear();
+    }
+    beginTransaction(type) {
+        // No need to differentiate.
+        return new SimpleSyncRWTransaction(this);
+    }
+    get(key) {
+        const data = this._storage.getItem(key);
+        if (typeof data != 'string') {
+            return;
+        }
+        return Buffer.from(data);
+    }
+    put(key, data, overwrite) {
+        try {
+            if (!overwrite && this._storage.getItem(key) !== null) {
+                // Don't want to overwrite the key!
+                return false;
+            }
+            this._storage.setItem(key, data.toString());
+            return true;
+        }
+        catch (e) {
+            throw new ApiError(ErrorCode.ENOSPC, 'Storage is full.');
+        }
+    }
+    del(key) {
+        try {
+            this._storage.removeItem(key);
+        }
+        catch (e) {
+            throw new ApiError(ErrorCode.EIO, 'Unable to delete key ' + key + ': ' + e);
+        }
+    }
+}
+/**
+ * A synchronous file system backed by a `Storage` (e.g. localStorage).
+ */
+export class StorageFileSystem extends SyncKeyValueFileSystem {
+    static isAvailable(storage = globalThis.localStorage) {
+        return storage instanceof Storage;
+    }
+    /**
+     * Creates a new Storage file system using the contents of `Storage`.
+     */
+    constructor({ storage = globalThis.localStorage }) {
+        super({ store: new StorageStore(storage) });
+    }
+}
+_a = StorageFileSystem;
+StorageFileSystem.Name = 'Storage';
+StorageFileSystem.Create = CreateBackend.bind(_a);
+StorageFileSystem.Options = {
+    storage: {
+        type: 'object',
+        optional: true,
+        description: 'The Storage to use. Defaults to globalThis.localStorage.',
+    },
+};

package/dist/backends/Worker.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" resolution-mode="require"/>
+import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { File, FileFlag } from '@zenfs/core/file.js';
+import { Stats } from '@zenfs/core/stats.js';
+import { Cred } from '@zenfs/core/cred.js';
+import { type BackendOptions } from '@zenfs/core/backends/backend.js';
+export declare namespace WorkerFS {
+    interface Options {
+        /**
+         * The target worker that you want to connect to, or the current worker if in a worker context.
+         */
+        worker: Worker;
+    }
+}
+/**
+ * WorkerFS lets you access a ZenFS instance that is running in a different
+ * JavaScript context (e.g. access ZenFS in one of your WebWorkers, or
+ * access ZenFS running on the main page from a WebWorker).
+ *
+ * For example, to have a WebWorker access files in the main browser thread,
+ * do the following:
+ *
+ * MAIN BROWSER THREAD:
+ *
+ * ```javascript
+ *   // Listen for remote file system requests.
+ *   ZenFS.Backend.WorkerFS.attachRemoteListener(webWorkerObject);
+ * ```
+ *
+ * WEBWORKER THREAD:
+ *
+ * ```javascript
+ *   // Set the remote file system as the root file system.
+ *   ZenFS.configure({ fs: "WorkerFS", options: { worker: self }}, function(e) {
+ *     // Ready!
+ *   });
+ * ```
+ *
+ * Note that synchronous operations are not permitted on the WorkerFS, regardless
+ * of the configuration option of the remote FS.
+ */
+export declare class WorkerFS extends BaseFileSystem {
+    static readonly Name = "WorkerFS";
+    static Create: any;
+    static readonly Options: BackendOptions;
+    static isAvailable(): boolean;
+    private _worker;
+    private _currentID;
+    private _requests;
+    private _isInitialized;
+    private _metadata;
+    /**
+     * Constructs a new WorkerFS instance that connects with ZenFS running on
+     * the specified worker.
+     */
+    constructor({ worker }: WorkerFS.Options);
+    get metadata(): FileSystemMetadata;
+    private _rpc;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    stat(p: string, cred: Cred): Promise<Stats>;
+    open(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    unlink(p: string, cred: Cred): Promise<void>;
+    rmdir(p: string, cred: Cred): Promise<void>;
+    mkdir(p: string, mode: number, cred: Cred): Promise<void>;
+    readdir(p: string, cred: Cred): Promise<string[]>;
+    exists(p: string, cred: Cred): Promise<boolean>;
+    realpath(p: string, cred: Cred): Promise<string>;
+    truncate(p: string, len: number, cred: Cred): Promise<void>;
+    readFile(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
+    writeFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    appendFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    chmod(p: string, mode: number, cred: Cred): Promise<void>;
+    chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
+    utimes(p: string, atime: Date, mtime: Date, cred: Cred): Promise<void>;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    symlink(srcpath: string, dstpath: string, type: string, cred: Cred): Promise<void>;
+    readlink(p: string, cred: Cred): Promise<string>;
+    syncClose(method: string, fd: File): Promise<void>;
+}

package/dist/backends/Worker.js

@@ -0,0 +1,169 @@
+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());
+    });
+};
+var _a;
+import { BaseFileSystem } from '@zenfs/core/filesystem.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { CreateBackend } from '@zenfs/core/backends/backend.js';
+function isRPCMessage(arg) {
+    return typeof arg == 'object' && 'isBFS' in arg && !!arg.isBFS;
+}
+/**
+ * WorkerFS lets you access a ZenFS instance that is running in a different
+ * JavaScript context (e.g. access ZenFS in one of your WebWorkers, or
+ * access ZenFS running on the main page from a WebWorker).
+ *
+ * For example, to have a WebWorker access files in the main browser thread,
+ * do the following:
+ *
+ * MAIN BROWSER THREAD:
+ *
+ * ```javascript
+ *   // Listen for remote file system requests.
+ *   ZenFS.Backend.WorkerFS.attachRemoteListener(webWorkerObject);
+ * ```
+ *
+ * WEBWORKER THREAD:
+ *
+ * ```javascript
+ *   // Set the remote file system as the root file system.
+ *   ZenFS.configure({ fs: "WorkerFS", options: { worker: self }}, function(e) {
+ *     // Ready!
+ *   });
+ * ```
+ *
+ * Note that synchronous operations are not permitted on the WorkerFS, regardless
+ * of the configuration option of the remote FS.
+ */
+export class WorkerFS extends BaseFileSystem {
+    static isAvailable() {
+        return typeof importScripts !== 'undefined' || typeof Worker !== 'undefined';
+    }
+    /**
+     * Constructs a new WorkerFS instance that connects with ZenFS running on
+     * the specified worker.
+     */
+    constructor({ worker }) {
+        super();
+        this._currentID = 0;
+        this._requests = new Map();
+        this._isInitialized = false;
+        this._worker = worker;
+        this._worker.onmessage = (event) => {
+            if (!isRPCMessage(event.data)) {
+                return;
+            }
+            const { id, method, value } = event.data;
+            if (method === 'metadata') {
+                this._metadata = value;
+                this._isInitialized = true;
+                return;
+            }
+            const { resolve, reject } = this._requests.get(id);
+            this._requests.delete(id);
+            if (value instanceof Error || value instanceof ApiError) {
+                reject(value);
+                return;
+            }
+            resolve(value);
+        };
+    }
+    get metadata() {
+        return Object.assign(Object.assign(Object.assign({}, super.metadata), this._metadata), { name: _a.Name, synchronous: false });
+    }
+    _rpc(method, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const id = this._currentID++;
+                this._requests.set(id, { resolve, reject });
+                this._worker.postMessage({
+                    isBFS: true,
+                    id,
+                    method,
+                    args,
+                });
+            });
+        });
+    }
+    rename(oldPath, newPath, cred) {
+        return this._rpc('rename', oldPath, newPath, cred);
+    }
+    stat(p, cred) {
+        return this._rpc('stat', p, cred);
+    }
+    open(p, flag, mode, cred) {
+        return this._rpc('open', p, flag, mode, cred);
+    }
+    unlink(p, cred) {
+        return this._rpc('unlink', p, cred);
+    }
+    rmdir(p, cred) {
+        return this._rpc('rmdir', p, cred);
+    }
+    mkdir(p, mode, cred) {
+        return this._rpc('mkdir', p, mode, cred);
+    }
+    readdir(p, cred) {
+        return this._rpc('readdir', p, cred);
+    }
+    exists(p, cred) {
+        return this._rpc('exists', p, cred);
+    }
+    realpath(p, cred) {
+        return this._rpc('realpath', p, cred);
+    }
+    truncate(p, len, cred) {
+        return this._rpc('truncate', p, len, cred);
+    }
+    readFile(fname, encoding, flag, cred) {
+        return this._rpc('readFile', fname, encoding, flag, cred);
+    }
+    writeFile(fname, data, encoding, flag, mode, cred) {
+        return this._rpc('writeFile', fname, data, encoding, flag, mode, cred);
+    }
+    appendFile(fname, data, encoding, flag, mode, cred) {
+        return this._rpc('appendFile', fname, data, encoding, flag, mode, cred);
+    }
+    chmod(p, mode, cred) {
+        return this._rpc('chmod', p, mode, cred);
+    }
+    chown(p, new_uid, new_gid, cred) {
+        return this._rpc('chown', p, new_uid, new_gid, cred);
+    }
+    utimes(p, atime, mtime, cred) {
+        return this._rpc('utimes', p, atime, mtime, cred);
+    }
+    link(srcpath, dstpath, cred) {
+        return this._rpc('link', srcpath, dstpath, cred);
+    }
+    symlink(srcpath, dstpath, type, cred) {
+        return this._rpc('symlink', srcpath, dstpath, type, cred);
+    }
+    readlink(p, cred) {
+        return this._rpc('readlink', p, cred);
+    }
+    syncClose(method, fd) {
+        return this._rpc('syncClose', method, fd);
+    }
+}
+_a = WorkerFS;
+WorkerFS.Name = 'WorkerFS';
+WorkerFS.Create = CreateBackend.bind(_a);
+WorkerFS.Options = {
+    worker: {
+        type: 'object',
+        description: 'The target worker that you want to connect to, or the current worker if in a worker context.',
+        validator: (v) => __awaiter(void 0, void 0, void 0, function* () {
+            // Check for a `postMessage` function.
+            if (typeof (v === null || v === void 0 ? void 0 : v.postMessage) != 'function') {
+                throw new ApiError(ErrorCode.EINVAL, `option must be a Web Worker instance.`);
+            }
+        }),
+    },
+};