@zenfs/core 0.0.1

package/dist/backends/FolderAdapter.js

@@ -0,0 +1,184 @@
+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';
+import * as path from 'path';
+import { ApiError } from '../ApiError';
+import { Cred } from '../cred';
+import { CreateBackend } from './backend';
+/**
+ * The FolderAdapter file system wraps a file system, and scopes all interactions to a subfolder of that file system.
+ *
+ * Example: Given a file system `foo` with folder `bar` and file `bar/baz`...
+ *
+ * ```javascript
+ * ZenFS.configure({
+ *   fs: "FolderAdapter",
+ *   options: {
+ *     folder: "bar",
+ *     wrapped: foo
+ *   }
+ * }, function(e) {
+ *   var fs = ZenFS.BFSRequire('fs');
+ *   fs.readdirSync('/'); // ['baz']
+ * });
+ * ```
+ */
+export class FolderAdapter extends BaseFileSystem {
+    static isAvailable() {
+        return true;
+    }
+    constructor({ folder, wrapped }) {
+        super();
+        this._folder = folder;
+        this._wrapped = wrapped;
+        this._ready = this._initialize();
+    }
+    get metadata() {
+        return Object.assign(Object.assign(Object.assign({}, 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;
+        });
+    }
+}
+_a = FolderAdapter;
+FolderAdapter.Name = 'FolderAdapter';
+FolderAdapter.Create = CreateBackend.bind(_a);
+FolderAdapter.Options = {
+    folder: {
+        type: 'string',
+        description: 'The folder to use as the root directory',
+    },
+    wrapped: {
+        type: 'object',
+        description: 'The file system to wrap',
+    },
+};
+/**
+ * @internal
+ */
+function translateError(folder, e) {
+    if (e !== null && typeof e === 'object') {
+        const err = e;
+        let p = err.path;
+        if (p) {
+            p = '/' + path.relative(folder, p);
+            err.message = err.message.replace(err.path, p);
+            err.path = p;
+        }
+    }
+    return e;
+}
+/**
+ * @internal
+ */
+function wrapCallback(folder, cb) {
+    if (typeof cb === 'function') {
+        return function (err) {
+            if (arguments.length > 0) {
+                arguments[0] = translateError(folder, err);
+            }
+            cb.apply(null, arguments);
+        };
+    }
+    else {
+        return cb;
+    }
+}
+/**
+ * @internal
+ */
+function wrapFunction(name, wrapFirst, wrapSecond) {
+    if (name.slice(name.length - 4) !== 'Sync') {
+        // Async function. Translate error in callback.
+        return function () {
+            if (arguments.length > 0) {
+                if (wrapFirst) {
+                    arguments[0] = path.join(this._folder, arguments[0]);
+                }
+                if (wrapSecond) {
+                    arguments[1] = path.join(this._folder, arguments[1]);
+                }
+                arguments[arguments.length - 1] = wrapCallback(this._folder, arguments[arguments.length - 1]);
+            }
+            return this._wrapped[name].apply(this._wrapped, arguments);
+        };
+    }
+    else {
+        // Sync function. Translate error in catch.
+        return function () {
+            try {
+                if (wrapFirst) {
+                    arguments[0] = path.join(this._folder, arguments[0]);
+                }
+                if (wrapSecond) {
+                    arguments[1] = path.join(this._folder, arguments[1]);
+                }
+                return this._wrapped[name].apply(this._wrapped, arguments);
+            }
+            catch (e) {
+                throw translateError(this._folder, e);
+            }
+        };
+    }
+}
+// First argument is a path.
+[
+    'diskSpace',
+    'stat',
+    'statSync',
+    'open',
+    'openSync',
+    'unlink',
+    'unlinkSync',
+    'rmdir',
+    'rmdirSync',
+    'mkdir',
+    'mkdirSync',
+    'readdir',
+    'readdirSync',
+    'exists',
+    'existsSync',
+    'realpath',
+    'realpathSync',
+    'truncate',
+    'truncateSync',
+    'readFile',
+    'readFileSync',
+    'writeFile',
+    'writeFileSync',
+    'appendFile',
+    'appendFileSync',
+    'chmod',
+    'chmodSync',
+    'chown',
+    'chownSync',
+    'utimes',
+    'utimesSync',
+    'readlink',
+    'readlinkSync',
+].forEach((name) => {
+    FolderAdapter.prototype[name] = wrapFunction(name, true, false);
+});
+// First and second arguments are paths.
+['rename', 'renameSync', 'link', 'linkSync', 'symlink', 'symlinkSync'].forEach((name) => {
+    FolderAdapter.prototype[name] = wrapFunction(name, true, true);
+});

package/dist/backends/InMemory.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { SyncKeyValueStore, SimpleSyncStore, SyncKeyValueRWTransaction, SyncKeyValueFileSystem } from './SyncStore';
+import { type BackendOptions } from './backend';
+/**
+ * A simple in-memory key-value store backed by a JavaScript object.
+ */
+export declare class InMemoryStore implements SyncKeyValueStore, SimpleSyncStore {
+    private store;
+    name(): string;
+    clear(): void;
+    beginTransaction(type: string): SyncKeyValueRWTransaction;
+    get(key: string): Buffer;
+    put(key: string, data: Buffer, overwrite: boolean): boolean;
+    del(key: string): void;
+}
+/**
+ * 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;
+    constructor();
+}

package/dist/backends/InMemory.js

@@ -0,0 +1,46 @@
+var _a;
+import { SimpleSyncRWTransaction, SyncKeyValueFileSystem } from './SyncStore';
+import { CreateBackend } from './backend';
+/**
+ * A simple in-memory key-value store backed by a JavaScript object.
+ */
+export class InMemoryStore {
+    constructor() {
+        this.store = new Map();
+    }
+    name() {
+        return InMemoryFileSystem.Name;
+    }
+    clear() {
+        this.store.clear();
+    }
+    beginTransaction(type) {
+        return new SimpleSyncRWTransaction(this);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    put(key, data, overwrite) {
+        if (!overwrite && this.store.has(key)) {
+            return false;
+        }
+        this.store.set(key, data);
+        return true;
+    }
+    del(key) {
+        this.store.delete(key);
+    }
+}
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
+export class InMemoryFileSystem extends SyncKeyValueFileSystem {
+    constructor() {
+        super({ store: new InMemoryStore() });
+    }
+}
+_a = InMemoryFileSystem;
+InMemoryFileSystem.Name = 'InMemory';
+InMemoryFileSystem.Create = CreateBackend.bind(_a);
+InMemoryFileSystem.Options = {};

package/dist/backends/Locked.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { FileContents, FileSystem, FileSystemMetadata } from '../filesystem';
+import { FileFlag } from '../file';
+import { Stats } from '../stats';
+import { File } from '../file';
+import { Cred } from '../cred';
+/**
+ * This class serializes access to an underlying async filesystem.
+ * For example, on an OverlayFS instance with an async lower
+ * directory operations like rename and rmdir may involve multiple
+ * requests involving both the upper and lower filesystems -- they
+ * are not executed in a single atomic step.  OverlayFS uses this
+ * LockedFS to avoid having to reason about the correctness of
+ * multiple requests interleaving.
+ */
+export default class LockedFS<T extends FileSystem> implements FileSystem {
+    private _fs;
+    private _mu;
+    protected _ready: Promise<this>;
+    constructor(fs: T);
+    whenReady(): 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;
+    unlink(p: string, cred: Cred): Promise<void>;
+    unlinkSync(p: string, cred: Cred): void;
+    rmdir(p: string, cred: Cred): Promise<void>;
+    rmdirSync(p: string, cred: Cred): void;
+    mkdir(p: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(p: string, mode: number, cred: Cred): void;
+    readdir(p: string, cred: Cred): Promise<string[]>;
+    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, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
+    readFileSync(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): FileContents;
+    writeFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    writeFileSync(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): void;
+    appendFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    appendFileSync(fname: string, data: FileContents, encoding: BufferEncoding, 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;
+}

package/dist/backends/Locked.js

@@ -0,0 +1,302 @@
+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';
+/**
+ * This class serializes access to an underlying async filesystem.
+ * For example, on an OverlayFS instance with an async lower
+ * directory operations like rename and rmdir may involve multiple
+ * requests involving both the upper and lower filesystems -- they
+ * are not executed in a single atomic step.  OverlayFS uses this
+ * LockedFS to avoid having to reason about the correctness of
+ * multiple requests interleaving.
+ */
+export default class LockedFS {
+    constructor(fs) {
+        this._ready = Promise.resolve(this);
+        this._fs = fs;
+        this._mu = new Mutex();
+    }
+    whenReady() {
+        return this._ready;
+    }
+    get metadata() {
+        return Object.assign(Object.assign({}, this._fs.metadata), { name: 'LockedFS<' + 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);
+        });
+    }
+    renameSync(oldPath, newPath, cred) {
+        if (this._mu.isLocked(oldPath)) {
+            throw new Error('invalid sync call');
+        }
+        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;
+        });
+    }
+    statSync(p, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        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);
+        });
+    }
+    accessSync(p, mode, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.accessSync(p, mode, 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;
+        });
+    }
+    openSync(p, flag, mode, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.openSync(p, 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);
+        });
+    }
+    unlinkSync(p, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        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);
+        });
+    }
+    rmdirSync(p, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        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);
+        });
+    }
+    mkdirSync(p, mode, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        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;
+        });
+    }
+    readdirSync(p, cred) {
+        if (this._mu.isLocked(p)) {
+            throw new Error('invalid sync call');
+        }
+        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;
+        });
+    }
+    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, encoding, flag, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._mu.lock(fname);
+            const data = yield this._fs.readFile(fname, encoding, flag, cred);
+            this._mu.unlock(fname);
+            return data;
+        });
+    }
+    readFileSync(fname, encoding, flag, cred) {
+        if (this._mu.isLocked(fname)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.readFileSync(fname, encoding, flag, cred);
+    }
+    writeFile(fname, data, encoding, flag, mode, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._mu.lock(fname);
+            yield this._fs.writeFile(fname, data, encoding, flag, mode, cred);
+            this._mu.unlock(fname);
+        });
+    }
+    writeFileSync(fname, data, encoding, flag, mode, cred) {
+        if (this._mu.isLocked(fname)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.writeFileSync(fname, data, encoding, flag, mode, cred);
+    }
+    appendFile(fname, data, encoding, flag, mode, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._mu.lock(fname);
+            yield this._fs.appendFile(fname, data, encoding, flag, mode, cred);
+            this._mu.unlock(fname);
+        });
+    }
+    appendFileSync(fname, data, encoding, flag, mode, cred) {
+        if (this._mu.isLocked(fname)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.appendFileSync(fname, data, encoding, 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);
+    }
+    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);
+        });
+    }
+    linkSync(srcpath, dstpath, cred) {
+        if (this._mu.isLocked(srcpath)) {
+            throw new Error('invalid sync call');
+        }
+        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);
+        });
+    }
+    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)) {
+            throw new Error('invalid sync call');
+        }
+        return this._fs.readlinkSync(p, cred);
+    }
+}