@zenfs/core 0.18.0 → 0.18.1

package/dist/backends/overlay.d.ts

@@ -88,11 +88,9 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     private copyToWritableSync;
     private copyToWritable;
 }
-declare const OverlayFS_base: import("../mixins/shared.js").Mixin<typeof UnmutexedOverlayFS, {
-    lock(path: string, syscall: string): Promise<import("../mixins/mutexed.js").MutexLock>;
-    lockSync(path: string): import("../mixins/mutexed.js").MutexLock;
-    isLocked(path: string): boolean;
-}>;
+declare const OverlayFS_base: {
+    new (): import("../mixins/mutexed.js").__MutexedFS<UnmutexedOverlayFS>;
+} & (new (args_0: OverlayOptions) => import("../mixins/mutexed.js").__MutexedFS<UnmutexedOverlayFS>);
 /**
  * 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

package/dist/backends/overlay.js

@@ -376,26 +376,26 @@ export class UnmutexedOverlayFS extends FileSystem {
      * should they not exist. Use modes from the read-only storage.
      */
     createParentDirectoriesSync(path) {
-        let parent = dirname(path), toCreate = [];
+        let parent = dirname(path);
+        const toCreate = [];
         while (!this.writable.existsSync(parent)) {
             toCreate.push(parent);
             parent = dirname(parent);
         }
-        toCreate = toCreate.reverse();
-        for (const p of toCreate) {
-            this.writable.mkdirSync(p, this.statSync(p).mode);
+        for (const path of toCreate.reverse()) {
+            this.writable.mkdirSync(path, this.statSync(path).mode);
         }
     }
     async createParentDirectories(path) {
-        let parent = dirname(path), toCreate = [];
+        let parent = dirname(path);
+        const toCreate = [];
         while (!(await this.writable.exists(parent))) {
             toCreate.push(parent);
             parent = dirname(parent);
         }
-        toCreate = toCreate.reverse();
-        for (const p of toCreate) {
-            const stats = await this.stat(p);
-            await this.writable.mkdir(p, stats.mode);
+        for (const path of toCreate.reverse()) {
+            const stats = await this.stat(path);
+            await this.writable.mkdir(path, stats.mode);
         }
     }
     /**

package/dist/backends/port/fs.d.ts

@@ -17,9 +17,8 @@ interface FileRequest<TMethod extends FileMethod = FileMethod> extends RPC.Reque
     args: Parameters<FileMethods[TMethod]>;
 }
 export declare class PortFile extends File {
-    readonly fs: PortFS;
+    fs: PortFS;
     readonly fd: number;
-    readonly path: string;
     position: number;
     constructor(fs: PortFS, fd: number, path: string, position: number);
     rpc<const T extends FileMethod>(method: T, ...args: Parameters<FileMethods[T]>): Promise<Awaited<ReturnType<FileMethods[T]>>>;

package/dist/backends/port/fs.js

@@ -8,10 +8,9 @@ import { InMemory } from '../memory.js';
 import * as RPC from './rpc.js';
 export class PortFile extends File {
     constructor(fs, fd, path, position) {
-        super();
+        super(fs, path);
         this.fs = fs;
         this.fd = fd;
-        this.path = path;
         this.position = position;
     }
     rpc(method, ...args) {
@@ -23,7 +22,7 @@ export class PortFile extends File {
         }, this.fs.options);
     }
     _throwNoSync(syscall) {
-        throw new ErrnoError(Errno.ENOTSUP, 'Syncrohnous operations not support on PortFile', this.path, syscall);
+        throw new ErrnoError(Errno.ENOTSUP, 'Synchronous operations not supported on PortFile', this.path, syscall);
     }
     async stat() {
         return new Stats(await this.rpc('stat'));