@zenfs/dom 0.0.6 → 0.1.1

package/dist/backends/IndexedDB.d.ts

@@ -1,63 +0,0 @@
-import { AsyncKeyValueROTransaction, AsyncKeyValueRWTransaction, AsyncKeyValueStore, AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
-import { type BackendOptions } from '@zenfs/core/backends/backend.js';
-/**
- * @hidden
- */
-export declare class IndexedDBROTransaction implements AsyncKeyValueROTransaction {
-    tx: IDBTransaction;
-    store: IDBObjectStore;
-    constructor(tx: IDBTransaction, store: IDBObjectStore);
-    get(key: string): Promise<Uint8Array>;
-}
-/**
- * @hidden
- */
-export declare class IndexedDBRWTransaction extends IndexedDBROTransaction implements AsyncKeyValueRWTransaction, AsyncKeyValueROTransaction {
-    constructor(tx: IDBTransaction, store: IDBObjectStore);
-    /**
-     * @todo return false when add has a key conflict (no error)
-     */
-    put(key: string, data: Uint8Array, overwrite: boolean): Promise<boolean>;
-    del(key: string): Promise<void>;
-    commit(): Promise<void>;
-    abort(): Promise<void>;
-}
-export declare class IndexedDBStore implements AsyncKeyValueStore {
-    private db;
-    private storeName;
-    static Create(storeName: string, indexedDB: IDBFactory): Promise<IndexedDBStore>;
-    constructor(db: IDBDatabase, storeName: string);
-    name(): string;
-    clear(): Promise<void>;
-    beginTransaction(type: 'readonly'): AsyncKeyValueROTransaction;
-    beginTransaction(type: 'readwrite'): AsyncKeyValueRWTransaction;
-}
-export declare namespace IndexedDBFileSystem {
-    /**
-     * Configuration options for the IndexedDB file system.
-     */
-    interface Options {
-        /**
-         * The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.
-         */
-        storeName?: string;
-        /**
-         * The size of the inode cache. Defaults to 100. A size of 0 or below disables caching.
-         */
-        cacheSize?: number;
-        /**
-         * The IDBFactory to use. Defaults to `globalThis.indexedDB`.
-         */
-        idbFactory?: IDBFactory;
-    }
-}
-/**
- * A file system that uses the IndexedDB key value file system.
- */
-export declare class IndexedDBFileSystem extends AsyncKeyValueFileSystem {
-    static readonly Name = "IndexedDB";
-    static Create: any;
-    static readonly Options: BackendOptions;
-    static isAvailable(idbFactory?: IDBFactory): boolean;
-    constructor({ cacheSize, storeName, idbFactory }: IndexedDBFileSystem.Options);
-}

package/dist/backends/IndexedDB.js

@@ -1,221 +0,0 @@
-var _a;
-import { AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
-import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
-import { CreateBackend } from '@zenfs/core/backends/backend.js';
-/**
- * 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 ArrayUint8Array
-                        resolve(Uint8Array.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 = idbFactory.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

@@ -1,39 +0,0 @@
-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: Storage;
-    name(): string;
-    constructor(_storage: Storage);
-    clear(): void;
-    beginTransaction(type: string): SyncKeyValueRWTransaction;
-    get(key: string): Uint8Array | undefined;
-    put(key: string, data: Uint8Array, 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

@@ -1,75 +0,0 @@
-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 { decode, encode } from '@zenfs/core/utils.js';
-/**
- * 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 encode(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, decode(data));
-            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

@@ -1,78 +0,0 @@
-import { BaseFileSystem, 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, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
-    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    appendFile(fname: string, data: Uint8Array, 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

@@ -1,163 +0,0 @@
-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 {
-            ...super.metadata,
-            ...this._metadata,
-            name: _a.Name,
-            synchronous: false,
-        };
-    }
-    async _rpc(method, ...args) {
-        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, flag, cred) {
-        return this._rpc('readFile', fname, flag, cred);
-    }
-    writeFile(fname, data, flag, mode, cred) {
-        return this._rpc('writeFile', fname, data, flag, mode, cred);
-    }
-    appendFile(fname, data, flag, mode, cred) {
-        return this._rpc('appendFile', fname, data, 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(worker) {
-            // Check for a `postMessage` function.
-            if (typeof worker?.postMessage != 'function') {
-                throw new ApiError(ErrorCode.EINVAL, 'option must be a Web Worker instance.');
-            }
-        },
-    },
-};

package/dist/fetch.d.ts

@@ -1,16 +0,0 @@
-export declare const fetchIsAvailable: boolean;
-/**
- * Asynchronously download a file as a buffer or a JSON object.
- * Note that the third function signature with a non-specialized type is
- * invalid, but TypeScript requires it when you specialize string arguments to
- * constants.
- * @hidden
- */
-export declare function fetchFile(p: string, type: 'buffer'): Promise<Uint8Array>;
-export declare function fetchFile(p: string, type: 'json'): Promise<any>;
-export declare function fetchFile(p: string, type: 'buffer' | 'json'): Promise<any>;
-/**
- * Asynchronously retrieves the size of the given file in bytes.
- * @hidden
- */
-export declare function fetchFileSize(p: string): Promise<number>;

package/dist/fetch.js

@@ -1,37 +0,0 @@
-/**
- * Contains utility methods for network I/O (using fetch)
- */
-import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
-export const fetchIsAvailable = typeof fetch !== 'undefined' && fetch !== null;
-/**
- * @hidden
- */
-function convertError(e) {
-    throw new ApiError(ErrorCode.EIO, e.message);
-}
-export async function fetchFile(p, type) {
-    const response = await fetch(p).catch(convertError);
-    if (!response.ok) {
-        throw new ApiError(ErrorCode.EIO, `fetch error: response returned code ${response.status}`);
-    }
-    switch (type) {
-        case 'buffer':
-            const arrayBuffer = await response.arrayBuffer().catch(convertError);
-            return new Uint8Array(arrayBuffer);
-        case 'json':
-            return response.json().catch(convertError);
-        default:
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid download type: ' + type);
-    }
-}
-/**
- * Asynchronously retrieves the size of the given file in bytes.
- * @hidden
- */
-export async function fetchFileSize(p) {
-    const response = await fetch(p, { method: 'HEAD' }).catch(convertError);
-    if (!response.ok) {
-        throw new ApiError(ErrorCode.EIO, `fetch HEAD error: response returned code ${response.status}`);
-    }
-    return parseInt(response.headers.get('Content-Length') || '-1', 10);
-}