@zenfs/core 1.10.2 → 1.10.4

package/dist/backends/cow.d.ts

@@ -3,6 +3,7 @@ import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { Stats } from '../stats.js';
 import { FileSystem } from '../internal/filesystem.js';
+import { EventEmitter } from 'eventemitter3';
 /**
  * Configuration options for CoW.
  * @category Backends and Configuration
@@ -12,22 +13,13 @@ export interface CopyOnWriteOptions {
     readable: FileSystem;
     /** The file system to write modified files to. */
     writable: FileSystem;
-    /** Options for the journal */
-    journal?: JournalOptions;
+    /** @see {@link Journal} */
+    journal?: Journal;
 }
 /**
  *  @hidden @deprecated use `CopyOnWriteOptions`
  */
 export type OverlayOptions = CopyOnWriteOptions;
-/**
- * Configuration options for the journal used by CoW.
- * @category Backends and Configuration
- * @internal
- */
-export interface JournalOptions {
-    /** The contents of the journal */
-    contents?: string | JournalEntry[];
-}
 declare const journalOperations: readonly ["delete"];
 /**
  * @internal
@@ -44,15 +36,16 @@ export interface JournalEntry {
  * Tracks various operations for the CoW backend
  * @internal
  */
-export declare class Journal {
-    readonly fs: CopyOnWriteFS;
-    entries: JournalEntry[];
-    constructor(fs: CopyOnWriteFS);
+export declare class Journal extends EventEmitter<{
+    update: [op: JournalOperation, path: string];
+    delete: [path: string];
+}> {
+    protected entries: JournalEntry[];
     toString(): string;
     /**
      * Parse a journal from a string
      */
-    fromString(value: string): void;
+    fromString(value: string): this;
     add(op: JournalOperation, path: string): void;
     has(op: JournalOperation, path: string): boolean;
     isDeleted(path: string): boolean;
@@ -62,25 +55,20 @@ export declare class Journal {
  * @internal
  */
 export declare class CopyOnWriteFS extends FileSystem {
-    /**
-     * The file system that initially populates this file system.
-     */
+    /** The file system that initially populates this file system. */
     readonly readable: FileSystem;
-    /**
-     * The file system to write modified files to.
-     */
+    /** The file system to write modified files to. */
     readonly writable: FileSystem;
-    ready(): Promise<void>;
+    /** The journal to use for persisting deletions */
     readonly journal: Journal;
+    ready(): Promise<void>;
     constructor(
-    /**
-     * The file system that initially populates this file system.
-     */
+    /** The file system that initially populates this file system. */
     readable: FileSystem, 
-    /**
-     * The file system to write modified files to.
-     */
-    writable: FileSystem);
+    /** The file system to write modified files to. */
+    writable: FileSystem, 
+    /** The journal to use for persisting deletions */
+    journal?: Journal);
     isDeleted(path: string): boolean;
     /**
      * @todo Consider trying to track information on the writable as well

package/dist/backends/cow.js

@@ -56,6 +56,7 @@ import { LazyFile } from '../internal/file.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { debug, err, warn } from '../internal/log.js';
 import { dirname, join } from '../vfs/path.js';
+import { EventEmitter } from 'eventemitter3';
 const journalOperations = ['delete'];
 /** Because TS doesn't work right w/o it */
 function isJournalOp(op) {
@@ -67,9 +68,9 @@ const journalMagicString = '#journal@v0\n';
  * Tracks various operations for the CoW backend
  * @internal
  */
-export class Journal {
-    constructor(fs) {
-        this.fs = fs;
+export class Journal extends EventEmitter {
+    constructor() {
+        super(...arguments);
         this.entries = [];
     }
     toString() {
@@ -91,9 +92,12 @@ export class Journal {
             }
             this.entries.push({ op, path });
         }
+        return this;
     }
     add(op, path) {
         this.entries.push({ op, path });
+        this.emit('update', op, path);
+        this.emit(op, path);
     }
     has(op, path) {
         const test = JSON.stringify({ op, path });
@@ -125,18 +129,16 @@ export class CopyOnWriteFS extends FileSystem {
         await this.writable.ready();
     }
     constructor(
-    /**
-     * The file system that initially populates this file system.
-     */
+    /** The file system that initially populates this file system. */
     readable, 
-    /**
-     * The file system to write modified files to.
-     */
-    writable) {
+    /** The file system to write modified files to. */
+    writable, 
+    /** The journal to use for persisting deletions */
+    journal = new Journal()) {
         super(0x62756c6c, readable.name);
         this.readable = readable;
         this.writable = writable;
-        this.journal = new Journal(this);
+        this.journal = journal;
         if (writable.attributes.has('no_write')) {
             throw err(new ErrnoError(Errno.EINVAL, 'Writable file system can not be written to'));
         }
@@ -477,14 +479,7 @@ const _CopyOnWrite = {
         journal: { type: 'object', required: false },
     },
     create(options) {
-        const fs = new CopyOnWriteFS(options.readable, options.writable);
-        if (typeof options.journal == 'string') {
-            fs.journal.fromString(options.journal);
-        }
-        if (Array.isArray(options.journal)) {
-            fs.journal.entries.push(...options.journal);
-        }
-        return fs;
+        return new CopyOnWriteFS(options.readable, options.writable, options.journal);
     },
 };
 /**

package/dist/internal/file.js

@@ -3,7 +3,7 @@ import { _chown, Stats } from '../stats.js';
 import { config } from '../vfs/config.js';
 import * as c from '../vfs/constants.js';
 import { Errno, ErrnoError } from './error.js';
-import { log_deprecated } from './log.js';
+import { err, log_deprecated } from './log.js';
 import '../polyfills.js';
 const maxByteLength = 0xffff; // 64 KiB
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
@@ -191,11 +191,10 @@ export class PreloadFile extends File {
             This invariant is *not* maintained once the file starts getting modified.
             It only actually matters if file is readable, as writeable modes may truncate/append to file.
         */
-        if (this.stats.size == _buffer.byteLength) {
+        if (this.stats.size == _buffer.byteLength)
             return;
-        }
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EIO, `Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`, path);
+            throw err(new ErrnoError(Errno.EIO, `Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`, path));
         }
         this.stats.size = _buffer.byteLength;
         this.dirty = true;
@@ -515,7 +514,6 @@ export class LazyFile extends File {
          * Whether the file is open or closed
          */
         this.closed = false;
-        this.dirty = true;
     }
     async sync() {
         if (this.closed)

package/dist/vfs/promises.js

@@ -64,6 +64,7 @@ import { dirname, join, parse, resolve } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
+import { _throw } from 'utilium';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(fdOrFile, context) {
@@ -677,11 +678,8 @@ mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = await realpath.call(this, path);
-    const handleError = (e) => {
-        throw fixError(e, { [resolved]: path });
-    };
     const { fs, path: resolved } = resolveMount(path, this);
-    const stats = await fs.stat(resolved).catch(handleError);
+    const stats = await fs.stat(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
     }
@@ -691,12 +689,18 @@ export async function readdir(path, options) {
     if (!stats.isDirectory()) {
         throw ErrnoError.With('ENOTDIR', path, 'readdir');
     }
-    const entries = await fs.readdir(resolved).catch(handleError);
+    const entries = await fs.readdir(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
     const values = [];
     const addEntry = async (entry) => {
         let entryStats;
         if ((options === null || options === void 0 ? void 0 : options.recursive) || (options === null || options === void 0 ? void 0 : options.withFileTypes)) {
-            entryStats = await fs.stat(join(resolved, entry)).catch(handleError);
+            entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
+                if (e.code == 'ENOENT')
+                    return;
+                throw fixError(e, { [resolved]: path });
+            });
+            if (!entryStats)
+                return;
         }
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStats));

package/dist/vfs/sync.js

@@ -499,7 +499,13 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = fs.statSync(join(resolved, entry));
+        let entryStat;
+        try {
+            entryStat = fs.statSync(join(resolved, entry));
+        }
+        catch {
+            continue;
+        }
         if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.10.2",
+	"version": "1.10.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",