@zenfs/dom 0.0.6 → 0.1.0

package/dist/FileSystemAccess.d.ts

@@ -0,0 +1,55 @@
+import { FileFlag, PreloadFile } from '@zenfs/core/file.js';
+import { FileSystem, type FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { Stats } from '@zenfs/core/stats.js';
+import type { Backend } from '@zenfs/core/backends/backend.js';
+declare global {
+    interface FileSystemDirectoryHandle {
+        [Symbol.iterator](): IterableIterator<[string, FileSystemHandle]>;
+        entries(): IterableIterator<[string, FileSystemHandle]>;
+        keys(): IterableIterator<string>;
+        values(): IterableIterator<FileSystemHandle>;
+    }
+}
+interface FileSystemAccessOptions {
+    handle: FileSystemDirectoryHandle;
+}
+export declare class FileSystemAccessFile extends PreloadFile<FileSystemAccessFS> {
+    constructor(_fs: FileSystemAccessFS, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
+    syncSync(): void;
+    sync(): Promise<void>;
+    close(): Promise<void>;
+    closeSync(): void;
+}
+declare const FileSystemAccessFS_base: (abstract new (...args: any[]) => {
+    metadata(): FileSystemMetadata;
+    renameSync(oldPath: string, newPath: string, cred: import("@zenfs/core/cred.js").Cred): void;
+    statSync(path: string, cred: import("@zenfs/core/cred.js").Cred): Stats;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: import("@zenfs/core/cred.js").Cred): import("@zenfs/core/file.js").File;
+    openFileSync(path: string, flag: FileFlag, cred: import("@zenfs/core/cred.js").Cred): import("@zenfs/core/file.js").File;
+    unlinkSync(path: string, cred: import("@zenfs/core/cred.js").Cred): void;
+    rmdirSync(path: string, cred: import("@zenfs/core/cred.js").Cred): void;
+    mkdirSync(path: string, mode: number, cred: import("@zenfs/core/cred.js").Cred): void;
+    readdirSync(path: string, cred: import("@zenfs/core/cred.js").Cred): string[];
+    linkSync(srcpath: string, dstpath: string, cred: import("@zenfs/core/cred.js").Cred): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}) & typeof FileSystem;
+export declare class FileSystemAccessFS extends FileSystemAccessFS_base {
+    private _handles;
+    ready(): Promise<this>;
+    constructor({ handle }: FileSystemAccessOptions);
+    metadata(): FileSystemMetadata;
+    sync(p: string, data: Uint8Array, stats: Stats): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    writeFile(fname: string, data: Uint8Array): Promise<void>;
+    createFile(path: string, flag: FileFlag): Promise<FileSystemAccessFile>;
+    stat(path: string): Promise<Stats>;
+    openFile(path: string, flag: FileFlag): Promise<FileSystemAccessFile>;
+    unlink(path: string): Promise<void>;
+    link(): Promise<void>;
+    rmdir(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    protected getHandle(path: string): Promise<FileSystemHandle>;
+}
+export declare const FileSystemAccess: Backend;
+export {};

package/dist/FileSystemAccess.js

@@ -0,0 +1,216 @@
+import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { PreloadFile } from '@zenfs/core/file.js';
+import { FileSystem, Async } from '@zenfs/core/filesystem.js';
+import { Stats, FileType } from '@zenfs/core/stats.js';
+const handleError = (path = '', error) => {
+    if (error.name === 'NotFoundError') {
+        throw ApiError.ENOENT(path);
+    }
+    throw error;
+};
+export class FileSystemAccessFile extends PreloadFile {
+    constructor(_fs, _path, _flag, _stat, contents) {
+        super(_fs, _path, _flag, _stat, contents);
+    }
+    syncSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    async sync() {
+        if (this.isDirty()) {
+            await this.fs.sync(this.path, this.buffer, this.stats);
+            this.resetDirty();
+        }
+    }
+    async close() {
+        await this.sync();
+    }
+    closeSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+}
+export class FileSystemAccessFS extends Async(FileSystem) {
+    async ready() {
+        return this;
+    }
+    constructor({ handle }) {
+        super();
+        this._handles = new Map();
+        this._handles.set('/', handle);
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            name: 'FileSystemAccess',
+        };
+    }
+    async sync(p, data, stats) {
+        const currentStats = await this.stat(p);
+        if (stats.mtime !== currentStats.mtime) {
+            await this.writeFile(p, data);
+        }
+    }
+    async rename(oldPath, newPath) {
+        try {
+            const handle = await this.getHandle(oldPath);
+            if (handle instanceof FileSystemDirectoryHandle) {
+                const files = await this.readdir(oldPath);
+                await this.mkdir(newPath);
+                if (files.length == 0) {
+                    await this.unlink(oldPath);
+                }
+                else {
+                    for (const file of files) {
+                        await this.rename(join(oldPath, file), join(newPath, file));
+                        await this.unlink(oldPath);
+                    }
+                }
+            }
+            if (!(handle instanceof FileSystemFileHandle)) {
+                return;
+            }
+            const oldFile = await handle.getFile(), destFolder = await this.getHandle(dirname(newPath));
+            if (!(destFolder instanceof FileSystemDirectoryHandle)) {
+                return;
+            }
+            const newFile = await destFolder.getFileHandle(basename(newPath), { create: true });
+            const writable = await newFile.createWritable();
+            const buffer = await oldFile.arrayBuffer();
+            await writable.write(buffer);
+            writable.close();
+            await this.unlink(oldPath);
+        }
+        catch (err) {
+            handleError(oldPath, err);
+        }
+    }
+    async writeFile(fname, data) {
+        const handle = await this.getHandle(dirname(fname));
+        if (!(handle instanceof FileSystemDirectoryHandle)) {
+            return;
+        }
+        const file = await handle.getFileHandle(basename(fname), { create: true });
+        const writable = await file.createWritable();
+        await writable.write(data);
+        await writable.close();
+    }
+    async createFile(path, flag) {
+        await this.writeFile(path, new Uint8Array());
+        return this.openFile(path, flag);
+    }
+    async stat(path) {
+        const handle = await this.getHandle(path);
+        if (!handle) {
+            throw ApiError.OnPath(ErrorCode.ENOENT, path);
+        }
+        if (handle instanceof FileSystemDirectoryHandle) {
+            return new Stats(FileType.DIRECTORY, 4096);
+        }
+        if (handle instanceof FileSystemFileHandle) {
+            const { lastModified, size } = await handle.getFile();
+            return new Stats(FileType.FILE, size, null, Date.now(), lastModified);
+        }
+    }
+    async openFile(path, flag) {
+        const handle = await this.getHandle(path);
+        if (handle instanceof FileSystemFileHandle) {
+            const file = await handle.getFile();
+            const data = new Uint8Array(await file.arrayBuffer());
+            const stats = new Stats(FileType.FILE, file.size, null, Date.now(), file.lastModified);
+            return new FileSystemAccessFile(this, path, flag, stats, data);
+        }
+    }
+    async unlink(path) {
+        const handle = await this.getHandle(dirname(path));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            try {
+                await handle.removeEntry(basename(path), { recursive: true });
+            }
+            catch (e) {
+                handleError(path, e);
+            }
+        }
+    }
+    async link() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    async rmdir(path) {
+        return this.unlink(path);
+    }
+    async mkdir(path) {
+        const existingHandle = await this.getHandle(path);
+        if (existingHandle) {
+            throw ApiError.EEXIST(path);
+        }
+        const handle = await this.getHandle(dirname(path));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            await handle.getDirectoryHandle(basename(path), { create: true });
+        }
+    }
+    async readdir(path) {
+        const handle = await this.getHandle(path);
+        if (!(handle instanceof FileSystemDirectoryHandle)) {
+            throw ApiError.ENOTDIR(path);
+        }
+        const _keys = [];
+        for await (const key of handle.keys()) {
+            _keys.push(join(path, key));
+        }
+        return _keys;
+    }
+    async getHandle(path) {
+        if (this._handles.has(path)) {
+            return this._handles.get(path);
+        }
+        let walkedPath = '/';
+        const [, ...pathParts] = path.split('/');
+        const getHandleParts = async ([pathPart, ...remainingPathParts]) => {
+            const walkingPath = join(walkedPath, pathPart);
+            const continueWalk = (handle) => {
+                walkedPath = walkingPath;
+                this._handles.set(walkedPath, handle);
+                if (remainingPathParts.length === 0) {
+                    return this._handles.get(path);
+                }
+                getHandleParts(remainingPathParts);
+            };
+            const handle = this._handles.get(walkedPath);
+            try {
+                return continueWalk(await handle.getDirectoryHandle(pathPart));
+            }
+            catch (error) {
+                if (error.name === 'TypeMismatchError') {
+                    try {
+                        return continueWalk(await handle.getFileHandle(pathPart));
+                    }
+                    catch (err) {
+                        handleError(walkingPath, err);
+                    }
+                }
+                else if (error.message === 'Name is not allowed.') {
+                    throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
+                }
+                else {
+                    handleError(walkingPath, error);
+                }
+            }
+        };
+        return await getHandleParts(pathParts);
+    }
+}
+export const FileSystemAccess = {
+    name: 'FileSystemAccess',
+    options: {
+        handle: {
+            type: 'object',
+            required: true,
+            description: 'The directory handle to use for the root',
+        },
+    },
+    isAvailable() {
+        return typeof FileSystemHandle == 'function';
+    },
+    create(options) {
+        return new FileSystemAccessFS(options);
+    },
+};

package/dist/IndexedDB.d.ts

@@ -0,0 +1,56 @@
+import { AsyncROTransaction, AsyncRWTransaction, AsyncStore } from '@zenfs/core/backends/AsyncStore.js';
+import type { Backend } from '@zenfs/core/backends/backend.js';
+import type { Ino } from '@zenfs/core/inode.js';
+/**
+ * @hidden
+ */
+export declare class IndexedDBROTransaction implements AsyncROTransaction {
+    tx: IDBTransaction;
+    store: IDBObjectStore;
+    constructor(tx: IDBTransaction, store: IDBObjectStore);
+    get(key: Ino): Promise<Uint8Array>;
+}
+/**
+ * @hidden
+ */
+export declare class IndexedDBRWTransaction extends IndexedDBROTransaction implements AsyncRWTransaction, AsyncROTransaction {
+    constructor(tx: IDBTransaction, store: IDBObjectStore);
+    /**
+     * @todo return false when add has a key conflict (no error)
+     */
+    put(key: Ino, data: Uint8Array, overwrite: boolean): Promise<boolean>;
+    remove(key: Ino): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}
+export declare class IndexedDBStore implements AsyncStore {
+    protected db: IDBDatabase;
+    protected storeName: string;
+    static create(storeName: string, indexedDB: IDBFactory): Promise<IndexedDBStore>;
+    constructor(db: IDBDatabase, storeName: string);
+    get name(): string;
+    clear(): Promise<void>;
+    beginTransaction(type: 'readonly'): AsyncROTransaction;
+    beginTransaction(type: 'readwrite'): AsyncRWTransaction;
+}
+/**
+ * Configuration options for the IndexedDB file system.
+ */
+export interface IndexedDBOptions {
+    /**
+     * 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 const IndexedDB: Backend;

package/dist/IndexedDB.js

@@ -0,0 +1,200 @@
+import { AsyncStoreFS } from '@zenfs/core/backends/AsyncStore.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.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);
+    }
+}
+/**
+ * @hidden
+ */
+export class IndexedDBROTransaction {
+    constructor(tx, store) {
+        this.tx = tx;
+        this.store = store;
+    }
+    get(key) {
+        return new Promise((resolve, reject) => {
+            try {
+                const req = this.store.get(key.toString());
+                req.onerror = e => {
+                    e.preventDefault();
+                    reject(new ApiError(ErrorCode.EIO));
+                };
+                req.onsuccess = () => {
+                    // IDB returns the value 'undefined' when you try to get keys that
+                    // don't exist. The caller expects this behavior.
+                    const result = req.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 req = overwrite ? this.store.put(data, key.toString()) : this.store.add(data, key.toString());
+                req.onerror = e => {
+                    e.preventDefault();
+                    reject(new ApiError(ErrorCode.EIO));
+                };
+                req.onsuccess = () => resolve(true);
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+    remove(key) {
+        return new Promise((resolve, reject) => {
+            try {
+                const req = this.store.delete(key.toString());
+                req.onerror = e => {
+                    e.preventDefault();
+                    reject(new ApiError(ErrorCode.EIO));
+                };
+                req.onsuccess = () => resolve;
+            }
+            catch (e) {
+                reject(convertError(e));
+            }
+        });
+    }
+    commit() {
+        return new Promise(resolve => setTimeout(resolve, 0));
+    }
+    async abort() {
+        try {
+            this.tx.abort();
+        }
+        catch (e) {
+            throw convertError(e);
+        }
+    }
+}
+export class IndexedDBStore {
+    static create(storeName, indexedDB) {
+        return new Promise((resolve, reject) => {
+            const req = indexedDB.open(storeName, 1);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                // 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);
+            };
+            req.onsuccess = () => resolve(new IndexedDBStore(req.result, storeName));
+            req.onerror = e => {
+                e.preventDefault();
+                reject(new ApiError(ErrorCode.EACCES));
+            };
+        });
+    }
+    constructor(db, storeName) {
+        this.db = db;
+        this.storeName = storeName;
+    }
+    get name() {
+        return IndexedDB.name + ':' + this.storeName;
+    }
+    clear() {
+        return new Promise((resolve, reject) => {
+            try {
+                const req = this.db.transaction(this.storeName, 'readwrite').objectStore(this.storeName).clear();
+                req.onsuccess = () => setTimeout(resolve, 0);
+                req.onerror = e => {
+                    e.preventDefault();
+                    reject(new ApiError(ErrorCode.EIO));
+                };
+            }
+            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);
+        }
+        if (type === 'readonly') {
+            return new IndexedDBROTransaction(tx, objectStore);
+        }
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid transaction type.');
+    }
+}
+/**
+ * A file system that uses the IndexedDB key value file system.
+ */
+export const IndexedDB = {
+    name: 'IndexedDB',
+    options: {
+        storeName: {
+            type: 'string',
+            required: false,
+            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',
+            required: false,
+            description: 'The size of the inode cache. Defaults to 100. A size of 0 or below disables caching.',
+        },
+        idbFactory: {
+            type: 'object',
+            required: false,
+            description: 'The IDBFactory to use. Defaults to globalThis.indexedDB.',
+        },
+    },
+    isAvailable(idbFactory = globalThis.indexedDB) {
+        try {
+            if (!(idbFactory instanceof IDBFactory)) {
+                return false;
+            }
+            const req = idbFactory.open('__zenfs_test');
+            if (!req) {
+                return false;
+            }
+            req.onsuccess = () => idbFactory.deleteDatabase('__zenfs_test');
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    create({ cacheSize = 100, storeName = 'zenfs', idbFactory = globalThis.indexedDB }) {
+        const store = IndexedDBStore.create(storeName, idbFactory);
+        const fs = new AsyncStoreFS({ cacheSize, store });
+        return fs;
+    },
+};

package/dist/Storage.d.ts

@@ -0,0 +1,29 @@
+import { SyncStore, SimpleSyncStore, SyncRWTransaction } from '@zenfs/core/backends/SyncStore.js';
+import { type Backend } from '@zenfs/core/backends/backend.js';
+import type { Ino } from '@zenfs/core/inode.js';
+/**
+ * A synchronous key-value store backed by Storage.
+ */
+export declare class StorageStore implements SyncStore, SimpleSyncStore {
+    protected _storage: Storage;
+    get name(): string;
+    constructor(_storage: Storage);
+    clear(): void;
+    beginTransaction(): SyncRWTransaction;
+    get(key: Ino): Uint8Array | undefined;
+    put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
+    remove(key: Ino): void;
+}
+/**
+ * Options to pass to the StorageFileSystem
+ */
+export interface StorageOptions {
+    /**
+     * The Storage to use. Defaults to globalThis.localStorage.
+     */
+    storage: Storage;
+}
+/**
+ * A synchronous file system backed by a `Storage` (e.g. localStorage).
+ */
+export declare const Storage: Backend;

package/dist/Storage.js

@@ -0,0 +1,68 @@
+import { SimpleSyncRWTransaction, SyncStoreFS } from '@zenfs/core/backends/SyncStore.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { decode, encode } from '@zenfs/core/utils.js';
+/**
+ * A synchronous key-value store backed by Storage.
+ */
+export class StorageStore {
+    get name() {
+        return Storage.name;
+    }
+    constructor(_storage) {
+        this._storage = _storage;
+    }
+    clear() {
+        this._storage.clear();
+    }
+    beginTransaction() {
+        // No need to differentiate.
+        return new SimpleSyncRWTransaction(this);
+    }
+    get(key) {
+        const data = this._storage.getItem(key.toString());
+        if (typeof data != 'string') {
+            return;
+        }
+        return encode(data);
+    }
+    put(key, data, overwrite) {
+        try {
+            if (!overwrite && this._storage.getItem(key.toString()) !== null) {
+                // Don't want to overwrite the key!
+                return false;
+            }
+            this._storage.setItem(key.toString(), decode(data));
+            return true;
+        }
+        catch (e) {
+            throw new ApiError(ErrorCode.ENOSPC, 'Storage is full.');
+        }
+    }
+    remove(key) {
+        try {
+            this._storage.removeItem(key.toString());
+        }
+        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 const Storage = {
+    name: 'Storage',
+    options: {
+        storage: {
+            type: 'object',
+            required: false,
+            description: 'The Storage to use. Defaults to globalThis.localStorage.',
+        },
+    },
+    isAvailable(storage = globalThis.localStorage) {
+        return storage instanceof globalThis.Storage;
+    },
+    create({ storage = globalThis.localStorage }) {
+        return new SyncStoreFS({ store: new StorageStore(storage) });
+    },
+};