@zenfs/core 1.11.4 → 2.1.0

package/dist/internal/devices.js

@@ -1,203 +1,22 @@
 /*
 This is a great resource: https://www.kernel.org/doc/html/latest/admin-guide/devices.html
 */
-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, inner;
-        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 (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        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;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            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 { canary } from 'utilium';
+import { withErrno } from 'kerium';
+import { debug, err, info } from 'kerium/log';
+import { decodeUTF8, omit } from 'utilium';
 import { InMemoryStore } from '../backends/memory.js';
 import { StoreFS } from '../backends/store/fs.js';
-import { Stats } from '../stats.js';
-import { decodeUTF8 } from '../utils.js';
-import { S_IFBLK, S_IFCHR } from '../vfs/constants.js';
-import { basename, dirname } from '../vfs/path.js';
-import { Errno, ErrnoError } from './error.js';
-import { File } from './file.js';
+import { basename, dirname } from '../path.js';
+import { S_IFCHR } from '../vfs/constants.js';
 import { Inode } from './inode.js';
-import { alert, debug, err, info, log_deprecated } from './log.js';
-/**
- * The base class for device files
- * This class only does some simple things:
- * It implements `truncate` using `write` and it has non-device methods throw.
- * It is up to device drivers to implement the rest of the functionality.
- * @category Internals
- * @internal
- */
-export class DeviceFile extends File {
-    constructor(fs, path, device) {
-        super(fs, path);
-        this.fs = fs;
-        this.device = device;
-        this.position = 0;
-        this.stats = new Inode({
-            mode: (this.driver.isBuffered ? S_IFBLK : S_IFCHR) | 0o666,
-        });
-    }
-    get driver() {
-        return this.device.driver;
-    }
-    async stat() {
-        return Promise.resolve(new Stats(this.stats));
-    }
-    statSync() {
-        return new Stats(this.stats);
-    }
-    readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        this.stats.atimeMs = Date.now();
-        const end = position + length;
-        this.position = end;
-        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        this.driver.readD(this.device, uint8.subarray(offset, length), position, end);
-        return length;
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async read(buffer, offset, length) {
-        return { bytesRead: this.readSync(buffer, offset, length), buffer };
-    }
-    writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        const end = position + length;
-        if (end > this.stats.size)
-            this.stats.size = end;
-        this.stats.mtimeMs = Date.now();
-        this.position = end;
-        const data = buffer.subarray(offset, offset + length);
-        this.driver.writeD(this.device, data, position);
-        return length;
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async write(buffer, offset, length, position) {
-        return this.writeSync(buffer, offset, length, position);
-    }
-    async truncate(length) {
-        const { size } = await this.stat();
-        const buffer = new Uint8Array(length > size ? length - size : 0);
-        await this.write(buffer, 0, buffer.length, length > size ? size : length);
-    }
-    truncateSync(length) {
-        const { size } = this.statSync();
-        const buffer = new Uint8Array(length > size ? length - size : 0);
-        this.writeSync(buffer, 0, buffer.length, length > size ? size : length);
-    }
-    closeSync() {
-        var _a, _b;
-        (_b = (_a = this.driver).close) === null || _b === void 0 ? void 0 : _b.call(_a, this);
-    }
-    close() {
-        this.closeSync();
-        return Promise.resolve();
-    }
-    syncSync() {
-        var _a, _b;
-        (_b = (_a = this.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, this);
-    }
-    sync() {
-        this.syncSync();
-        return Promise.resolve();
-    }
-    chown() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'chown');
-    }
-    chownSync() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'chown');
-    }
-    chmod() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'chmod');
-    }
-    chmodSync() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'chmod');
-    }
-    utimes() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'utimes');
-    }
-    utimesSync() {
-        throw ErrnoError.With('ENOTSUP', this.path, 'utimes');
-    }
-}
 /**
  * A temporary file system that manages and interfaces with devices
  * @category Internals
  */
 export class DeviceFS extends StoreFS {
-    /* node:coverage disable */
-    /**
-     * Creates a new device at `path` relative to the `DeviceFS` root.
-     * @deprecated
-     */
-    createDevice(path, driver, options = {}) {
-        var _a;
-        log_deprecated('DeviceFS#createDevice');
-        if (this.existsSync(path)) {
-            throw ErrnoError.With('EEXIST', path, 'mknod');
-        }
-        let ino = 1;
-        const silence = canary(ErrnoError.With('EDEADLK', path, 'mknod'));
-        while (this.store.has(ino))
-            ino++;
-        silence();
-        const dev = {
-            driver,
-            ino,
-            data: {},
-            minor: 0,
-            major: 0,
-            ...(_a = driver.init) === null || _a === void 0 ? void 0 : _a.call(driver, ino, options),
-        };
-        this.devices.set(path, dev);
-        return dev;
-    }
-    /* node:coverage enable */
     devicesWithDriver(driver, forceIdentity) {
         if (forceIdentity && typeof driver == 'string') {
-            throw err(new ErrnoError(Errno.EINVAL, 'Can not fetch devices using only a driver name'), { fs: this });
+            throw err(withErrno('EINVAL', 'Can not fetch devices using only a driver name'));
         }
         const devs = [];
         for (const device of this.devices.values()) {
@@ -215,19 +34,24 @@ export class DeviceFS extends StoreFS {
     _createDevice(driver, options = {}) {
         var _a;
         let ino = 1;
-        while (this.store.has(ino))
+        const lastDev = Array.from(this.devices.values()).at(-1);
+        while (this.store.has(ino) || (lastDev === null || lastDev === void 0 ? void 0 : lastDev.inode.ino) == ino)
             ino++;
+        const init = (_a = driver.init) === null || _a === void 0 ? void 0 : _a.call(driver, ino, options);
         const dev = {
-            driver,
-            ino,
             data: {},
             minor: 0,
             major: 0,
-            ...(_a = driver.init) === null || _a === void 0 ? void 0 : _a.call(driver, ino, options),
+            ...omit(init !== null && init !== void 0 ? init : {}, 'metadata'),
+            driver,
+            inode: new Inode({
+                mode: S_IFCHR | 0o666,
+                ...init === null || init === void 0 ? void 0 : init.metadata,
+            }),
         };
         const path = '/' + (dev.name || driver.name) + (driver.singleton ? '' : this.devicesWithDriver(driver).length);
         if (this.existsSync(path))
-            throw ErrnoError.With('EEXIST', path, 'mknod');
+            throw withErrno('EEXIST');
         this.devices.set(path, dev);
         info('Initialized device: ' + this._mountPoint + path);
         return dev;
@@ -250,93 +74,63 @@ export class DeviceFS extends StoreFS {
         this.devices = new Map();
     }
     async rename(oldPath, newPath) {
-        if (this.devices.has(oldPath)) {
-            throw ErrnoError.With('EPERM', oldPath, 'rename');
-        }
-        if (this.devices.has(newPath)) {
-            throw ErrnoError.With('EEXIST', newPath, 'rename');
-        }
+        if (this.devices.has(oldPath))
+            throw withErrno('EPERM');
+        if (this.devices.has(newPath))
+            throw withErrno('EEXIST');
         return super.rename(oldPath, newPath);
     }
     renameSync(oldPath, newPath) {
-        if (this.devices.has(oldPath)) {
-            throw ErrnoError.With('EPERM', oldPath, 'rename');
-        }
-        if (this.devices.has(newPath)) {
-            throw ErrnoError.With('EEXIST', newPath, 'rename');
-        }
+        if (this.devices.has(oldPath))
+            throw withErrno('EPERM');
+        if (this.devices.has(newPath))
+            throw withErrno('EEXIST');
         return super.renameSync(oldPath, newPath);
     }
     async stat(path) {
-        if (this.devices.has(path)) {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const file = __addDisposableResource(env_1, await this.openFile(path, 'r'), true);
-                return file.stat();
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
-            }
-        }
+        const dev = this.devices.get(path);
+        if (dev)
+            return dev.inode;
         return super.stat(path);
     }
     statSync(path) {
-        if (this.devices.has(path)) {
-            const env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const file = __addDisposableResource(env_2, this.openFileSync(path, 'r'), false);
-                return file.statSync();
-            }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
-            }
-        }
+        const dev = this.devices.get(path);
+        if (dev)
+            return dev.inode;
         return super.statSync(path);
     }
-    async openFile(path, flag) {
-        if (this.devices.has(path)) {
-            return new DeviceFile(this, path, this.devices.get(path));
-        }
-        return await super.openFile(path, flag);
-    }
-    openFileSync(path, flag) {
-        if (this.devices.has(path)) {
-            return new DeviceFile(this, path, this.devices.get(path));
-        }
-        return super.openFileSync(path, flag);
-    }
-    async createFile(path, flag, mode, options) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EEXIST', path, 'createFile');
-        }
-        return super.createFile(path, flag, mode, options);
-    }
-    createFileSync(path, flag, mode, options) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EEXIST', path, 'createFile');
-        }
-        return super.createFileSync(path, flag, mode, options);
+    async touch(path, metadata) {
+        const dev = this.devices.get(path);
+        if (dev)
+            dev.inode.update(metadata);
+        else
+            await super.touch(path, metadata);
+    }
+    touchSync(path, metadata) {
+        const dev = this.devices.get(path);
+        if (dev)
+            dev.inode.update(metadata);
+        else
+            super.touchSync(path, metadata);
+    }
+    async createFile(path, options) {
+        if (this.devices.has(path))
+            throw withErrno('EEXIST');
+        return super.createFile(path, options);
+    }
+    createFileSync(path, options) {
+        if (this.devices.has(path))
+            throw withErrno('EEXIST');
+        return super.createFileSync(path, options);
     }
     async unlink(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EPERM', path, 'unlink');
-        }
+        if (this.devices.has(path))
+            throw withErrno('EPERM');
         return super.unlink(path);
     }
     unlinkSync(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EPERM', path, 'unlink');
-        }
+        if (this.devices.has(path))
+            throw withErrno('EPERM');
         return super.unlinkSync(path);
     }
     async rmdir(path) {
@@ -345,17 +139,15 @@ export class DeviceFS extends StoreFS {
     rmdirSync(path) {
         return super.rmdirSync(path);
     }
-    async mkdir(path, mode, options) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
-        }
-        return super.mkdir(path, mode, options);
+    async mkdir(path, options) {
+        if (this.devices.has(path))
+            throw withErrno('EEXIST');
+        return super.mkdir(path, options);
     }
-    mkdirSync(path, mode, options) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
-        }
-        return super.mkdirSync(path, mode, options);
+    mkdirSync(path, options) {
+        if (this.devices.has(path))
+            throw withErrno('EEXIST');
+        return super.mkdirSync(path, options);
     }
     async readdir(path) {
         const entries = await super.readdir(path);
@@ -376,34 +168,32 @@ export class DeviceFS extends StoreFS {
         return entries;
     }
     async link(target, link) {
-        if (this.devices.has(target)) {
-            throw ErrnoError.With('EPERM', target, 'rmdir');
-        }
-        if (this.devices.has(link)) {
-            throw ErrnoError.With('EEXIST', link, 'link');
-        }
+        if (this.devices.has(target))
+            throw withErrno('EPERM');
+        if (this.devices.has(link))
+            throw withErrno('EEXIST');
         return super.link(target, link);
     }
     linkSync(target, link) {
-        if (this.devices.has(target)) {
-            throw ErrnoError.With('EPERM', target, 'rmdir');
-        }
-        if (this.devices.has(link)) {
-            throw ErrnoError.With('EEXIST', link, 'link');
-        }
+        if (this.devices.has(target))
+            throw withErrno('EPERM');
+        if (this.devices.has(link))
+            throw withErrno('EEXIST');
         return super.linkSync(target, link);
     }
-    async sync(path, data, stats) {
-        if (this.devices.has(path)) {
-            throw alert(new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync'), { fs: this });
+    async sync() {
+        var _a, _b;
+        for (const device of this.devices.values()) {
+            (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
         }
-        return super.sync(path, data, stats);
+        return super.sync();
     }
-    syncSync(path, data, stats) {
-        if (this.devices.has(path)) {
-            throw alert(new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync'), { fs: this });
+    syncSync() {
+        var _a, _b;
+        for (const device of this.devices.values()) {
+            (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
         }
-        return super.syncSync(path, data, stats);
+        return super.syncSync();
     }
     async read(path, buffer, offset, end) {
         const device = this.devices.get(path);
@@ -411,7 +201,7 @@ export class DeviceFS extends StoreFS {
             await super.read(path, buffer, offset, end);
             return;
         }
-        device.driver.readD(device, buffer, offset, end);
+        device.driver.read(device, buffer, offset, end);
     }
     readSync(path, buffer, offset, end) {
         const device = this.devices.get(path);
@@ -419,26 +209,23 @@ export class DeviceFS extends StoreFS {
             super.readSync(path, buffer, offset, end);
             return;
         }
-        device.driver.readD(device, buffer, offset, end);
+        device.driver.read(device, buffer, offset, end);
     }
     async write(path, data, offset) {
         const device = this.devices.get(path);
         if (!device) {
             return await super.write(path, data, offset);
         }
-        device.driver.writeD(device, data, offset);
+        device.driver.write(device, data, offset);
     }
     writeSync(path, data, offset) {
         const device = this.devices.get(path);
         if (!device) {
             return super.writeSync(path, data, offset);
         }
-        device.driver.writeD(device, data, offset);
+        device.driver.write(device, data, offset);
     }
 }
-function defaultWrite(device, data, offset) {
-    return;
-}
 const emptyBuffer = new Uint8Array();
 /**
  * Simulates the `/dev/null` device.
@@ -454,12 +241,11 @@ export const nullDevice = {
         return { major: 1, minor: 3 };
     },
     read() {
-        return 0;
-    },
-    readD() {
         return emptyBuffer;
     },
-    writeD: defaultWrite,
+    write() {
+        return;
+    },
 };
 /**
  * Simulates the `/dev/zero` device
@@ -478,10 +264,12 @@ export const zeroDevice = {
     init() {
         return { major: 1, minor: 5 };
     },
-    readD(device, buffer, offset, end) {
+    read(device, buffer, offset, end) {
         buffer.fill(0, offset, end);
     },
-    writeD: defaultWrite,
+    write() {
+        return;
+    },
 };
 /**
  * Simulates the `/dev/full` device.
@@ -496,14 +284,11 @@ export const fullDevice = {
     init() {
         return { major: 1, minor: 7 };
     },
-    readD(device, buffer, offset, end) {
+    read(device, buffer, offset, end) {
         buffer.fill(0, offset, end);
     },
-    write(file) {
-        throw ErrnoError.With('ENOSPC', file.path, 'write');
-    },
-    writeD() {
-        throw ErrnoError.With('ENOSPC', undefined, 'write');
+    write() {
+        throw withErrno('ENOSPC');
     },
 };
 /**
@@ -519,12 +304,14 @@ export const randomDevice = {
     init() {
         return { major: 1, minor: 8 };
     },
-    readD(device, buffer) {
+    read(device, buffer) {
         for (let i = 0; i < buffer.length; i++) {
             buffer[i] = Math.floor(Math.random() * 256);
         }
     },
-    writeD: defaultWrite,
+    write() {
+        return;
+    },
 };
 /**
  * Simulates the `/dev/console` device.
@@ -537,10 +324,10 @@ const consoleDevice = {
     init(ino, { output = text => console.log(text) } = {}) {
         return { major: 5, minor: 1, data: { output } };
     },
-    readD() {
+    read() {
         return emptyBuffer;
     },
-    writeD(device, buffer, offset) {
+    write(device, buffer, offset) {
         const text = decodeUTF8(buffer);
         device.data.output(text, offset);
     },