@zenfs/core 0.3.0 → 0.3.2

package/dist/backends/FolderAdapter.js

@@ -1,173 +0,0 @@
-var _a;
-import { BaseFileSystem } from '../filesystem.js';
-import { relative, join } from '../emulation/path.js';
-import { ApiError } from '../ApiError.js';
-import { Cred } from '../cred.js';
-import { CreateBackend } from './backend.js';
-/**
- * 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 { ...super.metadata, ...this._wrapped.metadata, supportsLinks: false };
-    }
-    /**
-     * Initialize the file system. Ensures that the wrapped file system
-     * has the given folder.
-     */
-    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;
-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 = '/' + 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] = join(this._folder, arguments[0]);
-                }
-                if (wrapSecond) {
-                    arguments[1] = 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] = join(this._folder, arguments[0]);
-                }
-                if (wrapSecond) {
-                    arguments[1] = 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/OverlayFS.d.ts

@@ -1,112 +0,0 @@
-import { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import { File, FileFlag } from '../file.js';
-import { Stats } from '../stats.js';
-import LockedFS from './Locked.js';
-import { Cred } from '../cred.js';
-import type { Backend } from './backend.js';
-export declare namespace OverlayFS {
-    /**
-     * Configuration options for OverlayFS instances.
-     */
-    interface Options {
-        /**
-         * The file system to write modified files to.
-         */
-        writable: FileSystem;
-        /**
-         * The file system that initially populates this file system.
-         */
-        readable: FileSystem;
-    }
-}
-/**
- * OverlayFS makes a read-only filesystem writable by storing writes on a second, writable file system.
- * Deletes are persisted via metadata stored on the writable file system.
- *
- * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
- *
- * @internal
- */
-export declare class UnlockedOverlayFS extends FileSystem {
-    ready(): Promise<this>;
-    private _writable;
-    private _readable;
-    private _isInitialized;
-    private _deletedFiles;
-    private _deleteLog;
-    private _deleteLogUpdatePending;
-    private _deleteLogUpdateNeeded;
-    private _deleteLogError?;
-    private _ready;
-    constructor({ writable, readable }: OverlayFS.Options);
-    get metadata(): FileSystemMetadata;
-    getOverlayedFileSystems(): OverlayFS.Options;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-    /**
-     * Called once to load up metadata stored on the writable file system.
-     * @internal
-     */
-    _initialize(): Promise<void>;
-    getDeletionLog(): string;
-    restoreDeletionLog(log: string, cred: Cred): void;
-    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;
-    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;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    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[];
-    private deletePath;
-    private updateLog;
-    private _reparseDeletionLog;
-    private checkInitialized;
-    private checkPath;
-    /**
-     * With the given path, create the needed parent directories on the writable storage
-     * should they not exist. Use modes from the read-only storage.
-     */
-    private createParentDirectoriesSync;
-    private createParentDirectories;
-    /**
-     * Helper function:
-     * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
-     * - Calls f to perform operation on writable.
-     */
-    private operateOnWritable;
-    private operateOnWritableAsync;
-    /**
-     * Copy from readable to writable storage.
-     * PRECONDITION: File does not exist on writable storage.
-     */
-    private copyToWritableSync;
-    private copyToWritable;
-}
-/**
- * OverlayFS makes a read-only filesystem writable by storing writes on a second,
- * writable file system. Deletes are persisted via metadata stored on the writable
- * file system.
- */
-export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
-    ready(): Promise<this>;
-    /**
-     * @param options The options to initialize the OverlayFS with
-     */
-    constructor(options: OverlayFS.Options);
-    getOverlayedFileSystems(): OverlayFS.Options;
-    getDeletionLog(): string;
-    resDeletionLog(): string;
-    unwrap(): UnlockedOverlayFS;
-}
-export declare const Overlay: Backend;