@zenfs/core 0.0.12 → 0.2.0

package/dist/backends/FolderAdapter.js

@@ -1,12 +1,3 @@
-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 '../filesystem.js';
 import { relative, join } from '../emulation/path.js';
@@ -42,21 +33,19 @@ export class FolderAdapter extends BaseFileSystem {
         this._ready = this._initialize();
     }
     get metadata() {
-        return Object.assign(Object.assign(Object.assign({}, super.metadata), this._wrapped.metadata), { supportsLinks: false });
+        return { ...super.metadata, ...this._wrapped.metadata, supportsLinks: false };
     }
     /**
      * Initialize the file system. Ensures that the wrapped file system
      * has the given folder.
      */
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exists = yield this._wrapped.exists(this._folder, Cred.Root);
-            if (!exists && this._wrapped.metadata.readonly) {
-                throw ApiError.ENOENT(this._folder);
-            }
-            yield this._wrapped.mkdir(this._folder, 0o777, Cred.Root);
-            return this;
-        });
+    async _initialize() {
+        const exists = await this._wrapped.exists(this._folder, Cred.Root);
+        if (!exists && this._wrapped.metadata.readonly) {
+            throw ApiError.ENOENT(this._folder);
+        }
+        await this._wrapped.mkdir(this._folder, 0o777, Cred.Root);
+        return this;
     }
 }
 _a = FolderAdapter;

package/dist/backends/InMemory.d.ts

@@ -1,24 +1,27 @@
-import { SyncKeyValueStore, SimpleSyncStore, SyncKeyValueRWTransaction, SyncKeyValueFileSystem } from './SyncStore.js';
-import { type BackendOptions } from './backend.js';
+import type { Ino } from '../inode.js';
+import { SyncStore, SimpleSyncStore, SyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
+import { type Backend } from './backend.js';
 /**
- * A simple in-memory key-value store backed by a JavaScript object.
+ * A simple in-memory store
  */
-export declare class InMemoryStore implements SyncKeyValueStore, SimpleSyncStore {
+export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
+    name: string;
     private store;
-    name(): string;
+    constructor(name?: string);
     clear(): void;
-    beginTransaction(type: string): SyncKeyValueRWTransaction;
-    get(key: string): Uint8Array;
-    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
-    del(key: string): void;
+    beginTransaction(): SyncRWTransaction;
+    get(key: Ino): Uint8Array;
+    put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
+    remove(key: Ino): void;
 }
+export declare const InMemory: Backend;
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export declare class InMemoryFileSystem extends SyncKeyValueFileSystem {
-    static readonly Name = "InMemory";
-    static Create: any;
-    static readonly Options: BackendOptions;
+export declare class _InMemory extends SyncStoreFileSystem {
+    static isAvailable(): boolean;
+    static create: any;
+    static readonly options: {};
     constructor();
 }

package/dist/backends/InMemory.js

@@ -1,20 +1,18 @@
 var _a;
-import { SimpleSyncRWTransaction, SyncKeyValueFileSystem } from './SyncStore.js';
-import { CreateBackend } from './backend.js';
+import { SimpleSyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
+import { createBackend } from './backend.js';
 /**
- * A simple in-memory key-value store backed by a JavaScript object.
+ * A simple in-memory store
  */
 export class InMemoryStore {
-    constructor() {
+    constructor(name = 'tmp') {
+        this.name = name;
         this.store = new Map();
     }
-    name() {
-        return InMemoryFileSystem.Name;
-    }
     clear() {
         this.store.clear();
     }
-    beginTransaction(type) {
+    beginTransaction() {
         return new SimpleSyncRWTransaction(this);
     }
     get(key) {
@@ -27,20 +25,37 @@ export class InMemoryStore {
         this.store.set(key, data);
         return true;
     }
-    del(key) {
+    remove(key) {
         this.store.delete(key);
     }
 }
+export const InMemory = {
+    name: 'InMemory',
+    isAvailable() {
+        return true;
+    },
+    options: {
+        name: {
+            type: 'string',
+            description: 'The name of the store',
+        },
+    },
+    create({ name }) {
+        return new SyncStoreFileSystem({ store: new InMemoryStore(name) });
+    },
+};
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export class InMemoryFileSystem extends SyncKeyValueFileSystem {
+export class _InMemory extends SyncStoreFileSystem {
+    static isAvailable() {
+        return true;
+    }
     constructor() {
         super({ store: new InMemoryStore() });
     }
 }
-_a = InMemoryFileSystem;
-InMemoryFileSystem.Name = 'InMemory';
-InMemoryFileSystem.Create = CreateBackend.bind(_a);
-InMemoryFileSystem.Options = {};
+_a = _InMemory;
+_InMemory.create = createBackend.bind(_a);
+_InMemory.options = {};

package/dist/backends/Locked.d.ts

@@ -13,21 +13,19 @@ import { Cred } from '../cred.js';
  * multiple requests interleaving.
  */
 export default class LockedFS<T extends FileSystem> implements FileSystem {
-    private _fs;
+    readonly fs: T;
     private _mu;
-    protected _ready: Promise<this>;
     constructor(fs: T);
-    whenReady(): Promise<this>;
+    ready(): Promise<this>;
     get metadata(): FileSystemMetadata;
-    get fs(): T;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     stat(p: string, cred: Cred): Promise<Stats>;
     statSync(p: string, cred: Cred): Stats;
-    access(p: string, mode: number, cred: Cred): Promise<void>;
-    accessSync(p: string, mode: number, cred: Cred): void;
-    open(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
-    openSync(p: string, flag: FileFlag, mode: number, cred: Cred): File;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
     unlink(p: string, cred: Cred): Promise<void>;
     unlinkSync(p: string, cred: Cred): void;
     rmdir(p: string, cred: Cred): Promise<void>;
@@ -38,26 +36,8 @@ export default class LockedFS<T extends FileSystem> implements FileSystem {
     readdirSync(p: string, cred: Cred): string[];
     exists(p: string, cred: Cred): Promise<boolean>;
     existsSync(p: string, cred: Cred): boolean;
-    realpath(p: string, cred: Cred): Promise<string>;
-    realpathSync(p: string, cred: Cred): string;
-    truncate(p: string, len: number, cred: Cred): Promise<void>;
-    truncateSync(p: string, len: number, cred: Cred): void;
-    readFile(fname: string, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
-    readFileSync(fname: string, flag: FileFlag, cred: Cred): Uint8Array;
-    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    writeFileSync(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): void;
-    appendFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    appendFileSync(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): void;
-    chmod(p: string, mode: number, cred: Cred): Promise<void>;
-    chmodSync(p: string, mode: number, cred: Cred): void;
-    chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
-    chownSync(p: string, new_uid: number, new_gid: number, cred: Cred): void;
-    utimes(p: string, atime: Date, mtime: Date, cred: Cred): Promise<void>;
-    utimesSync(p: string, atime: Date, mtime: Date, cred: Cred): void;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    symlink(srcpath: string, dstpath: string, type: string, cred: Cred): Promise<void>;
-    symlinkSync(srcpath: string, dstpath: string, type: string, cred: Cred): void;
-    readlink(p: string, cred: Cred): Promise<string>;
-    readlinkSync(p: string, cred: Cred): string;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }

package/dist/backends/Locked.js

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import Mutex from '../mutex.js';
 /**
  * This class serializes access to an underlying async filesystem.
@@ -19,284 +10,143 @@ import Mutex from '../mutex.js';
  */
 export default class LockedFS {
     constructor(fs) {
-        this._ready = Promise.resolve(this);
-        this._fs = fs;
+        this.fs = fs;
         this._mu = new Mutex();
     }
-    whenReady() {
-        return this._ready;
+    async ready() {
+        await this.fs.ready();
+        return this;
     }
     get metadata() {
-        return Object.assign(Object.assign({}, this._fs.metadata), { name: 'LockedFS<' + this._fs.metadata.name + '>' });
+        return {
+            ...this.fs.metadata,
+            name: 'Locked<' + this.fs.metadata.name + '>',
+        };
     }
-    get fs() {
-        return this._fs;
-    }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(oldPath);
-            yield this._fs.rename(oldPath, newPath, cred);
-            this._mu.unlock(oldPath);
-        });
+    async rename(oldPath, newPath, cred) {
+        await this._mu.lock(oldPath);
+        await this.fs.rename(oldPath, newPath, cred);
+        this._mu.unlock(oldPath);
     }
     renameSync(oldPath, newPath, cred) {
         if (this._mu.isLocked(oldPath)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.renameSync(oldPath, newPath, cred);
+        return this.fs.renameSync(oldPath, newPath, cred);
     }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const stats = yield this._fs.stat(p, cred);
-            this._mu.unlock(p);
-            return stats;
-        });
+    async stat(p, cred) {
+        await this._mu.lock(p);
+        const stats = await this.fs.stat(p, cred);
+        this._mu.unlock(p);
+        return stats;
     }
     statSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.statSync(p, cred);
+        return this.fs.statSync(p, cred);
     }
-    access(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.access(p, mode, cred);
-            this._mu.unlock(p);
-        });
+    async openFile(path, flag, cred) {
+        await this._mu.lock(path);
+        const fd = await this.fs.openFile(path, flag, cred);
+        this._mu.unlock(path);
+        return fd;
     }
-    accessSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
+    openFileSync(path, flag, cred) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.accessSync(p, mode, cred);
+        return this.fs.openFileSync(path, flag, cred);
     }
-    open(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const fd = yield this._fs.open(p, flag, mode, cred);
-            this._mu.unlock(p);
-            return fd;
-        });
+    async createFile(path, flag, mode, cred) {
+        await this._mu.lock(path);
+        const fd = await this.fs.createFile(path, flag, mode, cred);
+        this._mu.unlock(path);
+        return fd;
     }
-    openSync(p, flag, mode, cred) {
-        if (this._mu.isLocked(p)) {
+    createFileSync(path, flag, mode, cred) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.openSync(p, flag, mode, cred);
+        return this.fs.createFileSync(path, flag, mode, cred);
     }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.unlink(p, cred);
-            this._mu.unlock(p);
-        });
+    async unlink(p, cred) {
+        await this._mu.lock(p);
+        await this.fs.unlink(p, cred);
+        this._mu.unlock(p);
     }
     unlinkSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.unlinkSync(p, cred);
+        return this.fs.unlinkSync(p, cred);
     }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.rmdir(p, cred);
-            this._mu.unlock(p);
-        });
+    async rmdir(p, cred) {
+        await this._mu.lock(p);
+        await this.fs.rmdir(p, cred);
+        this._mu.unlock(p);
     }
     rmdirSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.rmdirSync(p, cred);
+        return this.fs.rmdirSync(p, cred);
     }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.mkdir(p, mode, cred);
-            this._mu.unlock(p);
-        });
+    async mkdir(p, mode, cred) {
+        await this._mu.lock(p);
+        await this.fs.mkdir(p, mode, cred);
+        this._mu.unlock(p);
     }
     mkdirSync(p, mode, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.mkdirSync(p, mode, cred);
+        return this.fs.mkdirSync(p, mode, cred);
     }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const files = yield this._fs.readdir(p, cred);
-            this._mu.unlock(p);
-            return files;
-        });
+    async readdir(p, cred) {
+        await this._mu.lock(p);
+        const files = await this.fs.readdir(p, cred);
+        this._mu.unlock(p);
+        return files;
     }
     readdirSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.readdirSync(p, cred);
+        return this.fs.readdirSync(p, cred);
     }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const exists = yield this._fs.exists(p, cred);
-            this._mu.unlock(p);
-            return exists;
-        });
+    async exists(p, cred) {
+        await this._mu.lock(p);
+        const exists = await this.fs.exists(p, cred);
+        this._mu.unlock(p);
+        return exists;
     }
     existsSync(p, cred) {
         if (this._mu.isLocked(p)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.existsSync(p, cred);
-    }
-    realpath(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const resolvedPath = yield this._fs.realpath(p, cred);
-            this._mu.unlock(p);
-            return resolvedPath;
-        });
-    }
-    realpathSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.realpathSync(p, cred);
-    }
-    truncate(p, len, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.truncate(p, len, cred);
-            this._mu.unlock(p);
-        });
-    }
-    truncateSync(p, len, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.truncateSync(p, len, cred);
-    }
-    readFile(fname, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            const data = yield this._fs.readFile(fname, flag, cred);
-            this._mu.unlock(fname);
-            return data;
-        });
-    }
-    readFileSync(fname, flag, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.readFileSync(fname, flag, cred);
-    }
-    writeFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            yield this._fs.writeFile(fname, data, flag, mode, cred);
-            this._mu.unlock(fname);
-        });
-    }
-    writeFileSync(fname, data, flag, mode, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.writeFileSync(fname, data, flag, mode, cred);
-    }
-    appendFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            yield this._fs.appendFile(fname, data, flag, mode, cred);
-            this._mu.unlock(fname);
-        });
-    }
-    appendFileSync(fname, data, flag, mode, cred) {
-        if (this._mu.isLocked(fname)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.appendFileSync(fname, data, flag, mode, cred);
-    }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.chmod(p, mode, cred);
-            this._mu.unlock(p);
-        });
-    }
-    chmodSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.chmodSync(p, mode, cred);
-    }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.chown(p, new_uid, new_gid, cred);
-            this._mu.unlock(p);
-        });
-    }
-    chownSync(p, new_uid, new_gid, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.chownSync(p, new_uid, new_gid, cred);
+        return this.fs.existsSync(p, cred);
     }
-    utimes(p, atime, mtime, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.utimes(p, atime, mtime, cred);
-            this._mu.unlock(p);
-        });
-    }
-    utimesSync(p, atime, mtime, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.utimesSync(p, atime, mtime, cred);
-    }
-    link(srcpath, dstpath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(srcpath);
-            yield this._fs.link(srcpath, dstpath, cred);
-            this._mu.unlock(srcpath);
-        });
+    async link(srcpath, dstpath, cred) {
+        await this._mu.lock(srcpath);
+        await this.fs.link(srcpath, dstpath, cred);
+        this._mu.unlock(srcpath);
     }
     linkSync(srcpath, dstpath, cred) {
         if (this._mu.isLocked(srcpath)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.linkSync(srcpath, dstpath, cred);
+        return this.fs.linkSync(srcpath, dstpath, cred);
     }
-    symlink(srcpath, dstpath, type, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(srcpath);
-            yield this._fs.symlink(srcpath, dstpath, type, cred);
-            this._mu.unlock(srcpath);
-        });
+    async sync(path, data, stats) {
+        await this._mu.lock(path);
+        await this.fs.sync(path, data, stats);
+        this._mu.unlock(path);
     }
-    symlinkSync(srcpath, dstpath, type, cred) {
-        if (this._mu.isLocked(srcpath)) {
-            throw new Error('invalid sync call');
-        }
-        return this._fs.symlinkSync(srcpath, dstpath, type, cred);
-    }
-    readlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const linkString = yield this._fs.readlink(p, cred);
-            this._mu.unlock(p);
-            return linkString;
-        });
-    }
-    readlinkSync(p, cred) {
-        if (this._mu.isLocked(p)) {
+    syncSync(path, data, stats) {
+        if (this._mu.isLocked(path)) {
             throw new Error('invalid sync call');
         }
-        return this._fs.readlinkSync(p, cred);
+        return this.fs.syncSync(path, data, stats);
     }
 }