@zenfs/core 1.11.4 → 2.1.0

package/dist/mixins/mutexed.js

@@ -50,8 +50,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { ErrnoError } from '../internal/error.js';
-import { err } from '../internal/log.js';
+import { withErrno } from 'kerium';
+import { err } from 'kerium/log';
 import '../polyfills.js';
 /**
  * @category Internals
@@ -84,8 +84,8 @@ export class MutexLock {
  * @category Internals
  */
 export class _MutexedFS {
-    get id() {
-        return this._fs.id;
+    get type() {
+        return this._fs.type;
     }
     get name() {
         return this._fs.name;
@@ -99,15 +99,21 @@ export class _MutexedFS {
     get attributes() {
         return this._fs.attributes;
     }
+    get _uuid() {
+        return this._fs._uuid;
+    }
+    set _uuid(value) {
+        this._fs._uuid = value;
+    }
+    get uuid() {
+        return this._fs.uuid;
+    }
     async ready() {
         return await this._fs.ready();
     }
     usage() {
         return this._fs.usage();
     }
-    metadata() {
-        return this._fs.metadata();
-    }
     /**
      * Adds a lock for a path
      */
@@ -121,15 +127,15 @@ export class _MutexedFS {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    async lock(path, syscall) {
+    async lock() {
         const previous = this.currentLock;
         const lock = this.addLock();
         const stack = new Error().stack;
         setTimeout(() => {
             if (lock.isLocked) {
-                const error = ErrnoError.With('EDEADLK', path, syscall);
+                const error = withErrno('EDEADLK');
                 error.stack += stack === null || stack === void 0 ? void 0 : stack.slice('Error'.length);
-                throw err(error, { fs: this });
+                throw err(error);
             }
         }, 5000);
         await (previous === null || previous === void 0 ? void 0 : previous.done());
@@ -140,10 +146,10 @@ export class _MutexedFS {
      * If the path is currently locked, an error will be thrown
      * @internal
      */
-    lockSync(path, syscall) {
+    lockSync() {
         var _a;
         if ((_a = this.currentLock) === null || _a === void 0 ? void 0 : _a.isLocked) {
-            throw err(ErrnoError.With('EBUSY', path, syscall), { fs: this });
+            throw err(withErrno('EBUSY'));
         }
         return this.addLock();
     }
@@ -159,7 +165,7 @@ export class _MutexedFS {
     async rename(oldPath, newPath) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_1, await this.lock(oldPath, 'rename'), false);
+            const _ = __addDisposableResource(env_1, await this.lock(), false);
             await this._fs.rename(oldPath, newPath);
         }
         catch (e_1) {
@@ -173,7 +179,7 @@ export class _MutexedFS {
     renameSync(oldPath, newPath) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_2, this.lockSync(oldPath, 'rename'), false);
+            const _ = __addDisposableResource(env_2, this.lockSync(), false);
             return this._fs.renameSync(oldPath, newPath);
         }
         catch (e_2) {
@@ -187,7 +193,7 @@ export class _MutexedFS {
     async stat(path) {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_3, await this.lock(path, 'stat'), false);
+            const _ = __addDisposableResource(env_3, await this.lock(), false);
             return await this._fs.stat(path);
         }
         catch (e_3) {
@@ -201,7 +207,7 @@ export class _MutexedFS {
     statSync(path) {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_4, this.lockSync(path, 'stat'), false);
+            const _ = __addDisposableResource(env_4, this.lockSync(), false);
             return this._fs.statSync(path);
         }
         catch (e_4) {
@@ -212,13 +218,11 @@ export class _MutexedFS {
             __disposeResources(env_4);
         }
     }
-    async openFile(path, flag) {
+    async touch(path, metadata) {
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_5, await this.lock(path, 'openFile'), false);
-            const file = await this._fs.openFile(path, flag);
-            file.fs = this;
-            return file;
+            const _ = __addDisposableResource(env_5, await this.lock(), false);
+            await this._fs.touch(path, metadata);
         }
         catch (e_5) {
             env_5.error = e_5;
@@ -228,13 +232,11 @@ export class _MutexedFS {
             __disposeResources(env_5);
         }
     }
-    openFileSync(path, flag) {
+    touchSync(path, metadata) {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_6, this.lockSync(path, 'openFile'), false);
-            const file = this._fs.openFileSync(path, flag);
-            file.fs = this;
-            return file;
+            const _ = __addDisposableResource(env_6, this.lockSync(), false);
+            this._fs.touchSync(path, metadata);
         }
         catch (e_6) {
             env_6.error = e_6;
@@ -244,13 +246,11 @@ export class _MutexedFS {
             __disposeResources(env_6);
         }
     }
-    async createFile(path, flag, mode, options) {
+    async createFile(path, options) {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_7, await this.lock(path, 'createFile'), false);
-            const file = await this._fs.createFile(path, flag, mode, options);
-            file.fs = this;
-            return file;
+            const _ = __addDisposableResource(env_7, await this.lock(), false);
+            return await this._fs.createFile(path, options);
         }
         catch (e_7) {
             env_7.error = e_7;
@@ -260,13 +260,11 @@ export class _MutexedFS {
             __disposeResources(env_7);
         }
     }
-    createFileSync(path, flag, mode, options) {
+    createFileSync(path, options) {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_8, this.lockSync(path, 'createFile'), false);
-            const file = this._fs.createFileSync(path, flag, mode, options);
-            file.fs = this;
-            return file;
+            const _ = __addDisposableResource(env_8, this.lockSync(), false);
+            return this._fs.createFileSync(path, options);
         }
         catch (e_8) {
             env_8.error = e_8;
@@ -279,7 +277,7 @@ export class _MutexedFS {
     async unlink(path) {
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_9, await this.lock(path, 'unlink'), false);
+            const _ = __addDisposableResource(env_9, await this.lock(), false);
             await this._fs.unlink(path);
         }
         catch (e_9) {
@@ -293,7 +291,7 @@ export class _MutexedFS {
     unlinkSync(path) {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_10, this.lockSync(path, 'unlink'), false);
+            const _ = __addDisposableResource(env_10, this.lockSync(), false);
             return this._fs.unlinkSync(path);
         }
         catch (e_10) {
@@ -307,7 +305,7 @@ export class _MutexedFS {
     async rmdir(path) {
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_11, await this.lock(path, 'rmdir'), false);
+            const _ = __addDisposableResource(env_11, await this.lock(), false);
             await this._fs.rmdir(path);
         }
         catch (e_11) {
@@ -321,7 +319,7 @@ export class _MutexedFS {
     rmdirSync(path) {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_12, this.lockSync(path, 'rmdir'), false);
+            const _ = __addDisposableResource(env_12, this.lockSync(), false);
             return this._fs.rmdirSync(path);
         }
         catch (e_12) {
@@ -332,11 +330,11 @@ export class _MutexedFS {
             __disposeResources(env_12);
         }
     }
-    async mkdir(path, mode, options) {
+    async mkdir(path, options) {
         const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_13, await this.lock(path, 'mkdir'), false);
-            await this._fs.mkdir(path, mode, options);
+            const _ = __addDisposableResource(env_13, await this.lock(), false);
+            return await this._fs.mkdir(path, options);
         }
         catch (e_13) {
             env_13.error = e_13;
@@ -346,11 +344,11 @@ export class _MutexedFS {
             __disposeResources(env_13);
         }
     }
-    mkdirSync(path, mode, options) {
+    mkdirSync(path, options) {
         const env_14 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_14, this.lockSync(path, 'mkdir'), false);
-            return this._fs.mkdirSync(path, mode, options);
+            const _ = __addDisposableResource(env_14, this.lockSync(), false);
+            return this._fs.mkdirSync(path, options);
         }
         catch (e_14) {
             env_14.error = e_14;
@@ -363,7 +361,7 @@ export class _MutexedFS {
     async readdir(path) {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_15, await this.lock(path, 'readdir'), false);
+            const _ = __addDisposableResource(env_15, await this.lock(), false);
             return await this._fs.readdir(path);
         }
         catch (e_15) {
@@ -377,7 +375,7 @@ export class _MutexedFS {
     readdirSync(path) {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_16, this.lockSync(path, 'readdir'), false);
+            const _ = __addDisposableResource(env_16, this.lockSync(), false);
             return this._fs.readdirSync(path);
         }
         catch (e_16) {
@@ -391,7 +389,7 @@ export class _MutexedFS {
     async exists(path) {
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_17, await this.lock(path, 'exists'), false);
+            const _ = __addDisposableResource(env_17, await this.lock(), false);
             return await this._fs.exists(path);
         }
         catch (e_17) {
@@ -405,7 +403,7 @@ export class _MutexedFS {
     existsSync(path) {
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_18, this.lockSync(path, 'exists'), false);
+            const _ = __addDisposableResource(env_18, this.lockSync(), false);
             return this._fs.existsSync(path);
         }
         catch (e_18) {
@@ -419,7 +417,7 @@ export class _MutexedFS {
     async link(srcpath, dstpath) {
         const env_19 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_19, await this.lock(srcpath, 'link'), false);
+            const _ = __addDisposableResource(env_19, await this.lock(), false);
             await this._fs.link(srcpath, dstpath);
         }
         catch (e_19) {
@@ -433,7 +431,7 @@ export class _MutexedFS {
     linkSync(srcpath, dstpath) {
         const env_20 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_20, this.lockSync(srcpath, 'link'), false);
+            const _ = __addDisposableResource(env_20, this.lockSync(), false);
             return this._fs.linkSync(srcpath, dstpath);
         }
         catch (e_20) {
@@ -444,11 +442,11 @@ export class _MutexedFS {
             __disposeResources(env_20);
         }
     }
-    async sync(path, data, stats) {
+    async sync() {
         const env_21 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_21, await this.lock(path, 'sync'), false);
-            await this._fs.sync(path, data, stats);
+            const _ = __addDisposableResource(env_21, await this.lock(), false);
+            await this._fs.sync();
         }
         catch (e_21) {
             env_21.error = e_21;
@@ -458,11 +456,11 @@ export class _MutexedFS {
             __disposeResources(env_21);
         }
     }
-    syncSync(path, data, stats) {
+    syncSync() {
         const env_22 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_22, this.lockSync(path, 'sync'), false);
-            return this._fs.syncSync(path, data, stats);
+            const _ = __addDisposableResource(env_22, this.lockSync(), false);
+            return this._fs.syncSync();
         }
         catch (e_22) {
             env_22.error = e_22;
@@ -475,7 +473,7 @@ export class _MutexedFS {
     async read(path, buffer, offset, end) {
         const env_23 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_23, await this.lock(path, 'read'), false);
+            const _ = __addDisposableResource(env_23, await this.lock(), false);
             return await this._fs.read(path, buffer, offset, end);
         }
         catch (e_23) {
@@ -489,7 +487,7 @@ export class _MutexedFS {
     readSync(path, buffer, offset, end) {
         const env_24 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_24, this.lockSync(path, 'read'), false);
+            const _ = __addDisposableResource(env_24, this.lockSync(), false);
             return this._fs.readSync(path, buffer, offset, end);
         }
         catch (e_24) {
@@ -503,7 +501,7 @@ export class _MutexedFS {
     async write(path, buffer, offset) {
         const env_25 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_25, await this.lock(path, 'write'), false);
+            const _ = __addDisposableResource(env_25, await this.lock(), false);
             return await this._fs.write(path, buffer, offset);
         }
         catch (e_25) {
@@ -517,7 +515,7 @@ export class _MutexedFS {
     writeSync(path, buffer, offset) {
         const env_26 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_26, this.lockSync(path, 'write'), false);
+            const _ = __addDisposableResource(env_26, this.lockSync(), false);
             return this._fs.writeSync(path, buffer, offset);
         }
         catch (e_26) {
@@ -531,7 +529,7 @@ export class _MutexedFS {
     streamRead(path, options) {
         const env_27 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_27, this.lockSync(path, 'streamRead'), false);
+            const _ = __addDisposableResource(env_27, this.lockSync(), false);
             return this._fs.streamRead(path, options);
         }
         catch (e_27) {
@@ -545,7 +543,7 @@ export class _MutexedFS {
     streamWrite(path, options) {
         const env_28 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_28, this.lockSync(path, 'streamWrite'), false);
+            const _ = __addDisposableResource(env_28, this.lockSync(), false);
             return this._fs.streamWrite(path, options);
         }
         catch (e_28) {

package/dist/mixins/readonly.d.ts

@@ -1,11 +1,10 @@
-import type { FileSystem, FileSystemMetadata } from '../internal/filesystem.js';
-import type { StatsLike } from '../stats.js';
+import type { FileSystem } from '../internal/filesystem.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { Mixin } from './shared.js';
 /**
  * @internal
  */
 export interface ReadonlyMixin {
-    metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string): Promise<never>;
     renameSync(oldPath: string, newPath: string): never;
     createFile(path: string, flag: string, mode: number): Promise<never>;
@@ -18,10 +17,12 @@ export interface ReadonlyMixin {
     mkdirSync(path: string, mode: number): never;
     link(srcpath: string, dstpath: string): Promise<never>;
     linkSync(srcpath: string, dstpath: string): never;
-    sync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): Promise<never>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): never;
+    touch(path: string, metadata: Readonly<InodeLike>): Promise<never>;
+    touchSync(path: string, metadata: Readonly<InodeLike>): never;
+    sync(): Promise<never>;
+    syncSync(): never;
     write(path: string, buffer: Uint8Array, offset: number): Promise<never>;
-    writeSync(path: string, buffer: Uint8Array, offset: number): Promise<never>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): never;
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`

package/dist/mixins/readonly.js

@@ -1,4 +1,4 @@
-import { Errno, ErrnoError } from '../internal/error.js';
+import { withErrno } from 'kerium';
 /**
  * Implements the non-readonly methods to throw `EROFS`
  * @category Internals
@@ -11,55 +11,61 @@ export function Readonly(FS) {
             this.attributes.set('no_write');
         }
         async rename() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         renameSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async createFile() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         createFileSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async unlink() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         unlinkSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async rmdir() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         rmdirSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async mkdir() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         mkdirSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async link() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         linkSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
+        }
+        async touch() {
+            throw withErrno('EROFS');
+        }
+        touchSync() {
+            throw withErrno('EROFS');
         }
         async sync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         syncSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         async write() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         writeSync() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
         streamWrite() {
-            throw new ErrnoError(Errno.EROFS);
+            throw withErrno('EROFS');
         }
     }
     return ReadonlyFS;

package/dist/mixins/sync.js

@@ -14,11 +14,11 @@ export function Sync(FS) {
         async stat(path) {
             return this.statSync(path);
         }
-        async createFile(path, flag, mode, options) {
-            return this.createFileSync(path, flag, mode, options);
+        async touch(path, metadata) {
+            return this.touchSync(path, metadata);
         }
-        async openFile(path, flag) {
-            return this.openFileSync(path, flag);
+        async createFile(path, options) {
+            return this.createFileSync(path, options);
         }
         async unlink(path) {
             return this.unlinkSync(path);
@@ -26,8 +26,8 @@ export function Sync(FS) {
         async rmdir(path) {
             return this.rmdirSync(path);
         }
-        async mkdir(path, mode, options) {
-            return this.mkdirSync(path, mode, options);
+        async mkdir(path, options) {
+            return this.mkdirSync(path, options);
         }
         async readdir(path) {
             return this.readdirSync(path);
@@ -35,8 +35,8 @@ export function Sync(FS) {
         async link(srcpath, dstpath) {
             return this.linkSync(srcpath, dstpath);
         }
-        async sync(path, data, stats) {
-            return this.syncSync(path, data, stats);
+        async sync() {
+            return this.syncSync();
         }
         async read(path, buffer, offset, end) {
             return this.readSync(path, buffer, offset, end);

package/dist/{vfs/path.d.ts → path.d.ts}

@@ -1,15 +1,14 @@
 import type { ParsedPath } from 'node:path';
+import type { V_Context } from './context.js';
 export type AbsolutePath = `/${string}`;
-export declare let cwd: string;
-export declare function cd(path: string): void;
 export declare const sep = "/";
 export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
 export declare function formatExt(ext: string): string;
-export declare function resolve(...parts: string[]): AbsolutePath;
+export declare function resolve(this: V_Context, ...parts: (string | undefined)[]): AbsolutePath;
 export declare function normalize(path: string): string;
 export declare function isAbsolute(path: string): path is AbsolutePath;
 export declare function join(...parts: string[]): string;
-export declare function relative(from: string, to: string): string;
+export declare function relative(this: V_Context, from: string, to: string): string;
 export declare function dirname(path: string): string;
 export declare function basename(path: string, suffix?: string): string;
 export declare function extname(path: string): string;

package/dist/{vfs/path.js → path.js}

@@ -20,10 +20,7 @@ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-export let cwd = '/';
-export function cd(path) {
-    cwd = resolve(cwd, path);
-}
+import { defaultContext } from './internal/contexts.js';
 export const sep = '/';
 function validateObject(str, name) {
     if (typeof str != 'object') {
@@ -103,11 +100,11 @@ export function formatExt(ext) {
     return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
 }
 export function resolve(...parts) {
+    var _a;
     let resolved = '';
-    for (const part of [...parts.reverse(), cwd]) {
-        if (!part.length) {
+    for (const part of [...parts.reverse(), (_a = this === null || this === void 0 ? void 0 : this.pwd) !== null && _a !== void 0 ? _a : defaultContext.pwd]) {
+        if (!(part === null || part === void 0 ? void 0 : part.length))
             continue;
-        }
         resolved = `${part}/${resolved}`;
         if (part.startsWith('/')) {
             break;
@@ -154,8 +151,8 @@ export function relative(from, to) {
     if (from === to)
         return '';
     // Trim leading forward slashes.
-    from = resolve(from);
-    to = resolve(to);
+    from = resolve.call(this, from);
+    to = resolve.call(this, to);
     if (from === to)
         return '';
     const fromStart = 1;

package/dist/polyfills.js

@@ -1,6 +1,6 @@
 /* node:coverage disable */
 var _a, _b, _c;
-import { warn } from './internal/log.js';
+import { warn } from 'kerium/log';
 // eslint-disable-next-line @typescript-eslint/unbound-method
 (_a = Promise.withResolvers) !== null && _a !== void 0 ? _a : (Promise.withResolvers = (warn('Using a polyfill of Promise.withResolvers'),
     function () {