@zenfs/core 1.11.4 → 2.1.0

package/dist/mixins/async.js

@@ -1,61 +1,9 @@
-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 { withErrno } from 'kerium';
+import { crit, debug, err } from 'kerium/log';
 import { getAllPrototypes } from 'utilium';
 import { StoreFS } from '../backends/store/fs.js';
-import { Errno, ErrnoError } from '../internal/error.js';
-import { LazyFile, parseFlag } from '../internal/file.js';
-import { crit, debug, err } from '../internal/log.js';
-import { join } from '../vfs/path.js';
+import { isDirectory } from '../internal/inode.js';
+import { join } from '../path.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -87,8 +35,8 @@ export function Async(FS) {
         }
         async ready() {
             await super.ready();
-            await this.queueDone();
-            if (this._isInitialized || this.attributes.has('no_async'))
+            await this._promise;
+            if (this._isInitialized || this.attributes.has('no_async_preload'))
                 return;
             this.checkSync();
             await this._sync.ready();
@@ -111,83 +59,84 @@ export function Async(FS) {
             }
             catch (e) {
                 this._isInitialized = false;
-                throw crit(e, { fs: this });
+                throw crit(e);
             }
         }
-        checkSync(path, syscall) {
-            if (this.attributes.has('no_async')) {
-                throw crit(new ErrnoError(Errno.ENOTSUP, 'Sync preloading has been disabled for this async file system', path, syscall), {
-                    fs: this,
-                });
+        checkSync() {
+            if (this.attributes.has('no_async_preload')) {
+                throw withErrno('ENOTSUP', 'Sync preloading has been disabled for this async file system');
             }
             if (!this._sync) {
-                throw crit(new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall), { fs: this });
+                throw crit(withErrno('ENOTSUP', 'No sync cache is attached to this async file system'));
             }
         }
         renameSync(oldPath, newPath) {
-            this.checkSync(oldPath, 'rename');
+            this.checkSync();
             this._sync.renameSync(oldPath, newPath);
             this._async(this.rename(oldPath, newPath));
         }
         statSync(path) {
-            this.checkSync(path, 'stat');
+            this.checkSync();
             return this._sync.statSync(path);
         }
-        createFileSync(path, flag, mode, options) {
-            this.checkSync(path, 'createFile');
-            const file = this._sync.createFileSync(path, flag, mode, options);
-            this._async(this.createFile(path, flag, mode, options));
-            return new LazyFile(this, path, flag, file.statSync());
+        touchSync(path, metadata) {
+            this.checkSync();
+            this._sync.touchSync(path, metadata);
+            this._async(this.touch(path, metadata));
         }
-        openFileSync(path, flag) {
-            this.checkSync(path, 'openFile');
-            const stats = this._sync.statSync(path);
-            return new LazyFile(this, path, flag, stats);
+        createFileSync(path, options) {
+            this.checkSync();
+            this._async(this.createFile(path, options));
+            return this._sync.createFileSync(path, options);
         }
         unlinkSync(path) {
-            this.checkSync(path, 'unlinkSync');
+            this.checkSync();
             this._sync.unlinkSync(path);
             this._async(this.unlink(path));
         }
         rmdirSync(path) {
-            this.checkSync(path, 'rmdir');
+            this.checkSync();
             this._sync.rmdirSync(path);
             this._async(this.rmdir(path));
         }
-        mkdirSync(path, mode, options) {
-            this.checkSync(path, 'mkdir');
-            this._sync.mkdirSync(path, mode, options);
-            this._async(this.mkdir(path, mode, options));
+        mkdirSync(path, options) {
+            this.checkSync();
+            this._async(this.mkdir(path, options));
+            return this._sync.mkdirSync(path, options);
         }
         readdirSync(path) {
-            this.checkSync(path, 'readdir');
+            this.checkSync();
             return this._sync.readdirSync(path);
         }
         linkSync(srcpath, dstpath) {
-            this.checkSync(srcpath, 'link');
+            this.checkSync();
             this._sync.linkSync(srcpath, dstpath);
             this._async(this.link(srcpath, dstpath));
         }
-        syncSync(path, data, stats) {
-            this.checkSync(path, 'sync');
-            this._sync.syncSync(path, data, stats);
-            this._async(this.sync(path, data, stats));
+        async sync() {
+            this.checkSync();
+            this._sync.syncSync();
+            await this._promise;
+        }
+        syncSync() {
+            this.checkSync();
+            this._sync.syncSync();
         }
         existsSync(path) {
-            this.checkSync(path, 'exists');
+            this.checkSync();
             return this._sync.existsSync(path);
         }
         readSync(path, buffer, offset, end) {
-            this.checkSync(path, 'read');
+            this.checkSync();
             this._sync.readSync(path, buffer, offset, end);
         }
         writeSync(path, buffer, offset) {
-            this.checkSync(path, 'write');
+            this.checkSync();
             this._sync.writeSync(path, buffer, offset);
             this._async(this.write(path, buffer, offset));
         }
         streamWrite(path, options) {
-            this.checkSync(path, 'streamWrite');
+            this.checkSync();
             const sync = this._sync.streamWrite(path, options).getWriter();
             const async = super.streamWrite(path, options).getWriter();
             return new WritableStream({
@@ -206,28 +155,19 @@ export function Async(FS) {
          * @internal
          */
         async crossCopy(path) {
-            this.checkSync(path, 'crossCopy');
+            this.checkSync();
             const stats = await this.stat(path);
-            if (!stats.isDirectory()) {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const syncFile = __addDisposableResource(env_1, this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats), false);
-                    const buffer = new Uint8Array(stats.size);
-                    await this.read(path, buffer, 0, stats.size);
-                    syncFile.writeSync(buffer, 0, stats.size);
-                    return;
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_1);
-                }
+            if (!isDirectory(stats)) {
+                this._sync.createFileSync(path, stats);
+                const buffer = new Uint8Array(stats.size);
+                await this.read(path, buffer, 0, stats.size);
+                this._sync.writeSync(path, buffer, 0);
+                this._sync.touchSync(path, stats);
+                return;
             }
             if (path !== '/') {
-                const stats = await this.stat(path);
-                this._sync.mkdirSync(path, stats.mode, stats);
+                this._sync.mkdirSync(path, stats);
+                this._sync.touchSync(path, stats);
             }
             const promises = [];
             for (const file of await this.readdir(path)) {
@@ -263,7 +203,7 @@ export function Async(FS) {
                         (_c = (_b = this._sync) === null || _b === void 0 ? void 0 : _b[`${key}Sync`]) === null || _c === void 0 ? void 0 : _c.call(_b, ...args);
                     }
                     catch (e) {
-                        throw err(new ErrnoError(e.errno, e.message + ' (Out of sync!)', e.path, key), { fs: this });
+                        throw err(withErrno(e.errno, e.message + ' (Out of sync!)'));
                     }
                     return result;
                 };

package/dist/mixins/mutexed.d.ts

@@ -1,8 +1,7 @@
-import type { File } from '../internal/file.js';
-import type { CreationOptions, FileSystem, FileSystemMetadata, StreamOptions, UsageInfo } from '../internal/filesystem.js';
+import type { UUID } from 'node:crypto';
+import type { Concrete } from 'utilium';
+import type { CreationOptions, FileSystem, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
-import type { Stats } from '../stats.js';
-import type { Concrete } from '../utils.js';
 import '../polyfills.js';
 /**
  * @category Internals
@@ -27,14 +26,16 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
      * @internal
      */
     _fs: T;
-    get id(): number;
+    get type(): number;
     get name(): string;
     get label(): string | undefined;
     set label(value: string | undefined);
     get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void> & Map<string, any>;
+    get _uuid(): UUID;
+    set _uuid(value: UUID);
+    get uuid(): UUID;
     ready(): Promise<void>;
     usage(): UsageInfo;
-    metadata(): FileSystemMetadata;
     /**
      * The current locks
      */
@@ -48,13 +49,13 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    lock(path: string, syscall: string): Promise<MutexLock>;
+    lock(): Promise<MutexLock>;
     /**
      * Locks `path` asynchronously.
      * If the path is currently locked, an error will be thrown
      * @internal
      */
-    lockSync(path: string, syscall: string): MutexLock;
+    lockSync(): MutexLock;
     /**
      * Whether `path` is locked
      * @internal
@@ -62,26 +63,26 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     get isLocked(): boolean;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string): Promise<File>;
-    openFileSync(path: string, flag: string): File;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    stat(path: string): Promise<InodeLike>;
+    statSync(path: string): InodeLike;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
+    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
+    createFileSync(path: string, options: CreationOptions): InodeLike;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     exists(path: string): Promise<boolean>;
     existsSync(path: string): boolean;
     link(srcpath: string, dstpath: string): Promise<void>;
     linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): Promise<void>;
-    syncSync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): void;
+    sync(): Promise<void>;
+    syncSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;