@zenfs/core 0.16.4 → 0.17.0

package/dist/backends/locked.js

@@ -1,487 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        function next() {
-            while (env.stack.length) {
-                var rec = env.stack.pop();
-                try {
-                    var result = rec.dispose && rec.dispose.call(rec.value);
-                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { Errno, ErrnoError } from '../error.js';
-import { FileSystem } from '../filesystem.js';
-import '../polyfills.js';
-/**
- * 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.
- * @internal
- */
-export class LockedFS {
-    constructor(fs) {
-        this.fs = fs;
-        /**
-         * The current locks
-         */
-        this.locks = new Map();
-    }
-    addLock(path) {
-        const lock = {
-            ...Promise.withResolvers(),
-            [Symbol.dispose]: () => {
-                this.unlock(path);
-            },
-        };
-        this.locks.set(path, lock);
-        return lock;
-    }
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, waits for it to be unlocked.
-     * @internal
-     */
-    async lock(path) {
-        if (this.locks.has(path)) {
-            // Non-null assertion: we already checked locks has path
-            await this.locks.get(path).promise;
-        }
-        return this.addLock(path);
-    }
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, an error will be thrown
-     * @internal
-     */
-    lockSync(path) {
-        if (this.locks.has(path)) {
-            // Non-null assertion: we already checked locks has path
-            throw ErrnoError.With('EBUSY', path, 'lockSync');
-        }
-        return this.addLock(path);
-    }
-    /**
-     * Unlocks a path
-     * @param path The path to lock
-     * @param noThrow If true, an error will not be thrown if the path is already unlocked
-     * @returns Whether the path was unlocked
-     * @internal
-     */
-    unlock(path, noThrow = false) {
-        if (!this.locks.has(path)) {
-            if (noThrow) {
-                return false;
-            }
-            throw new ErrnoError(Errno.EPERM, 'Can not unlock an already unlocked path', path);
-        }
-        // Non-null assertion: we already checked locks has path
-        this.locks.get(path).resolve();
-        this.locks.delete(path);
-        return true;
-    }
-    /**
-     * Whether `path` is locked
-     * @internal
-     */
-    isLocked(path) {
-        return this.locks.has(path);
-    }
-    async ready() {
-        await this.fs.ready();
-    }
-    metadata() {
-        return {
-            ...this.fs.metadata(),
-            name: 'Locked<' + this.fs.metadata().name + '>',
-        };
-    }
-    async rename(oldPath, newPath, cred) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_1, await this.lock(oldPath), false);
-            await this.fs.rename(oldPath, newPath, cred);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    renameSync(oldPath, newPath, cred) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_2, this.lockSync(oldPath), false);
-            return this.fs.renameSync(oldPath, newPath, cred);
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            __disposeResources(env_2);
-        }
-    }
-    async stat(path, cred) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_3, await this.lock(path), false);
-            return await this.fs.stat(path, cred);
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    }
-    statSync(path, cred) {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_4, this.lockSync(path), false);
-            return this.fs.statSync(path, cred);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            __disposeResources(env_4);
-        }
-    }
-    async openFile(path, flag, cred) {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_5, await this.lock(path), false);
-            return await this.fs.openFile(path, flag, cred);
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            __disposeResources(env_5);
-        }
-    }
-    openFileSync(path, flag, cred) {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_6, this.lockSync(path), false);
-            return this.fs.openFileSync(path, flag, cred);
-        }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            __disposeResources(env_6);
-        }
-    }
-    async createFile(path, flag, mode, cred) {
-        const env_7 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_7, await this.lock(path), false);
-            return await this.fs.createFile(path, flag, mode, cred);
-        }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
-        }
-        finally {
-            __disposeResources(env_7);
-        }
-    }
-    createFileSync(path, flag, mode, cred) {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_8, this.lockSync(path), false);
-            return this.fs.createFileSync(path, flag, mode, cred);
-        }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            __disposeResources(env_8);
-        }
-    }
-    async unlink(path, cred) {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_9, await this.lock(path), false);
-            await this.fs.unlink(path, cred);
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
-        }
-        finally {
-            __disposeResources(env_9);
-        }
-    }
-    unlinkSync(path, cred) {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_10, this.lockSync(path), false);
-            return this.fs.unlinkSync(path, cred);
-        }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
-        }
-        finally {
-            __disposeResources(env_10);
-        }
-    }
-    async rmdir(path, cred) {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_11, await this.lock(path), false);
-            await this.fs.rmdir(path, cred);
-        }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
-        }
-        finally {
-            __disposeResources(env_11);
-        }
-    }
-    rmdirSync(path, cred) {
-        const env_12 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_12, this.lockSync(path), false);
-            return this.fs.rmdirSync(path, cred);
-        }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
-        }
-        finally {
-            __disposeResources(env_12);
-        }
-    }
-    async mkdir(path, mode, cred) {
-        const env_13 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_13, await this.lock(path), false);
-            await this.fs.mkdir(path, mode, cred);
-        }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
-        }
-        finally {
-            __disposeResources(env_13);
-        }
-    }
-    mkdirSync(path, mode, cred) {
-        const env_14 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_14, this.lockSync(path), false);
-            return this.fs.mkdirSync(path, mode, cred);
-        }
-        catch (e_14) {
-            env_14.error = e_14;
-            env_14.hasError = true;
-        }
-        finally {
-            __disposeResources(env_14);
-        }
-    }
-    async readdir(path, cred) {
-        const env_15 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_15, await this.lock(path), false);
-            return await this.fs.readdir(path, cred);
-        }
-        catch (e_15) {
-            env_15.error = e_15;
-            env_15.hasError = true;
-        }
-        finally {
-            __disposeResources(env_15);
-        }
-    }
-    readdirSync(path, cred) {
-        const env_16 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_16, this.lockSync(path), false);
-            return this.fs.readdirSync(path, cred);
-        }
-        catch (e_16) {
-            env_16.error = e_16;
-            env_16.hasError = true;
-        }
-        finally {
-            __disposeResources(env_16);
-        }
-    }
-    async exists(path, cred) {
-        const env_17 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_17, await this.lock(path), false);
-            return await this.fs.exists(path, cred);
-        }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
-        }
-        finally {
-            __disposeResources(env_17);
-        }
-    }
-    existsSync(path, cred) {
-        const env_18 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_18, this.lockSync(path), false);
-            return this.fs.existsSync(path, cred);
-        }
-        catch (e_18) {
-            env_18.error = e_18;
-            env_18.hasError = true;
-        }
-        finally {
-            __disposeResources(env_18);
-        }
-    }
-    async link(srcpath, dstpath, cred) {
-        const env_19 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_19, await this.lock(srcpath), false);
-            await this.fs.link(srcpath, dstpath, cred);
-        }
-        catch (e_19) {
-            env_19.error = e_19;
-            env_19.hasError = true;
-        }
-        finally {
-            __disposeResources(env_19);
-        }
-    }
-    linkSync(srcpath, dstpath, cred) {
-        const env_20 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_20, this.lockSync(srcpath), false);
-            return this.fs.linkSync(srcpath, dstpath, cred);
-        }
-        catch (e_20) {
-            env_20.error = e_20;
-            env_20.hasError = true;
-        }
-        finally {
-            __disposeResources(env_20);
-        }
-    }
-    async sync(path, data, stats) {
-        const env_21 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_21, await this.lock(path), false);
-            await this.fs.sync(path, data, stats);
-        }
-        catch (e_21) {
-            env_21.error = e_21;
-            env_21.hasError = true;
-        }
-        finally {
-            __disposeResources(env_21);
-        }
-    }
-    syncSync(path, data, stats) {
-        const env_22 = { stack: [], error: void 0, hasError: false };
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _ = __addDisposableResource(env_22, this.lockSync(path), false);
-            return this.fs.syncSync(path, data, stats);
-        }
-        catch (e_22) {
-            env_22.error = e_22;
-            env_22.hasError = true;
-        }
-        finally {
-            __disposeResources(env_22);
-        }
-    }
-}
-export const Locked = {
-    name: 'Locked',
-    options: {
-        fs: {
-            type: 'object',
-            required: true,
-            description: '',
-            validator(fs) {
-                if (!(fs instanceof FileSystem)) {
-                    throw new ErrnoError(Errno.EINVAL, 'fs passed to LockedFS must be a FileSystem');
-                }
-            },
-        },
-    },
-    isAvailable() {
-        return true;
-    },
-    create({ fs }) {
-        return new LockedFS(fs);
-    },
-};

package/src/backends/index/index.ts

@@ -1,104 +0,0 @@
-import { isJSON } from 'utilium';
-import { Errno, ErrnoError } from '../../error.js';
-import type { StatsLike } from '../../stats.js';
-import { Stats } from '../../stats.js';
-import { encode } from '../../utils.js';
-import { basename, dirname } from '../../emulation/path.js';
-
-/**
- * An Index in JSON form
- * @internal
- */
-export interface IndexData {
-	version: 1;
-	entries: Record<string, StatsLike<number>>;
-}
-
-export const version = 1;
-
-/**
- * An index of files
- * @internal
- */
-export class Index extends Map<string, Stats> {
-	public constructor() {
-		super();
-	}
-
-	/**
-	 * Convience method
-	 */
-	public files(): Map<string, Stats> {
-		const files = new Map<string, Stats>();
-		for (const [path, stats] of this) {
-			if (stats.isFile()) {
-				files.set(path, stats);
-			}
-		}
-		return files;
-	}
-
-	/**
-	 * Converts the index to JSON
-	 */
-	public toJSON(): IndexData {
-		return {
-			version,
-			entries: Object.fromEntries(this),
-		};
-	}
-
-	/**
-	 * Converts the index to a string
-	 */
-	public toString(): string {
-		return JSON.stringify(this.toJSON());
-	}
-
-	/**
-	 * Returns the files in the directory `dir`.
-	 * This is expensive so it is only called once per directory.
-	 */
-	protected dirEntries(dir: string): string[] {
-		const entries = [];
-		for (const entry of this.keys()) {
-			if (dirname(entry) == dir) {
-				entries.push(basename(entry));
-			}
-		}
-		return entries;
-	}
-
-	/**
-	 * Loads the index from JSON data
-	 */
-	public fromJSON(json: IndexData): void {
-		if (json.version != version) {
-			throw new ErrnoError(Errno.EINVAL, 'Index version mismatch');
-		}
-
-		this.clear();
-
-		for (const [path, data] of Object.entries(json.entries)) {
-			const stats = new Stats(data);
-			if (stats.isDirectory()) {
-				stats.fileData = encode(JSON.stringify(this.dirEntries(path)));
-			}
-			this.set(path, stats);
-		}
-	}
-
-	/**
-	 * Parses an index from a string
-	 */
-	public static parse(data: string): Index {
-		if (!isJSON(data)) {
-			throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
-		}
-
-		const json = JSON.parse(data) as IndexData;
-		const index = new Index();
-		index.fromJSON(json);
-		return index;
-	}
-}