@zenfs/core 1.11.1 → 1.11.3

package/dist/backends/cow.js

@@ -458,8 +458,7 @@ export class CopyOnWriteFS extends FileSystem {
                 return;
             }
             const data = new Uint8Array(stats.size);
-            const readable = __addDisposableResource(env_2, await this.readable.openFile(path, 'r'), true);
-            await readable.read(data);
+            await this.readable.read(path, data, 0, stats.size);
             const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode, stats), true);
             await writable.write(data);
         }

package/dist/mixins/async.js

@@ -211,10 +211,9 @@ export function Async(FS) {
             if (!stats.isDirectory()) {
                 const env_1 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const asyncFile = __addDisposableResource(env_1, await this.openFile(path, parseFlag('r')), true);
                     const syncFile = __addDisposableResource(env_1, this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats), false);
                     const buffer = new Uint8Array(stats.size);
-                    await asyncFile.read(buffer);
+                    await this.read(path, buffer, 0, stats.size);
                     syncFile.writeSync(buffer, 0, stats.size);
                     return;
                 }
@@ -223,9 +222,7 @@ export function Async(FS) {
                     env_1.hasError = true;
                 }
                 finally {
-                    const result_1 = __disposeResources(env_1);
-                    if (result_1)
-                        await result_1;
+                    __disposeResources(env_1);
                 }
             }
             if (path !== '/') {

package/dist/vfs/promises.js

@@ -113,9 +113,8 @@ export class FileHandle {
      */
     async truncate(length) {
         length || (length = 0);
-        if (length < 0) {
+        if (length < 0)
             throw new ErrnoError(Errno.EINVAL);
-        }
         await this.file.truncate(length);
         this._emitChange();
     }
@@ -162,11 +161,10 @@ export class FileHandle {
             offset = buffer.offset;
             buffer = buffer.buffer;
         }
-        if (!Number.isSafeInteger(position)) {
-            position = this.file.position;
-        }
+        const pos = Number.isSafeInteger(position) ? position : this.file.position;
         buffer || (buffer = new Uint8Array((await this.file.stat()).size));
-        return this.file.read(buffer, offset !== null && offset !== void 0 ? offset : undefined, length !== null && length !== void 0 ? length : undefined, position !== null && position !== void 0 ? position : undefined);
+        offset !== null && offset !== void 0 ? offset : (offset = 0);
+        return this.file.read(buffer, offset, length !== null && length !== void 0 ? length : buffer.byteLength - offset, pos);
     }
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
@@ -501,11 +499,7 @@ export async function writeFile(path, data, _options) {
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
         const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
-        const _data = typeof data == 'string'
-            ? data
-            : data instanceof DataView
-                ? new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength))
-                : data;
+        const _data = typeof data == 'string' ? data : data instanceof DataView ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
             throw new ErrnoError(Errno.EINVAL, 'The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data, handle.file.path, 'writeFile');
         }

package/dist/vfs/watchers.js

@@ -2,7 +2,7 @@ import { EventEmitter } from 'eventemitter3';
 import { ErrnoError } from '../internal/error.js';
 import { isStatsEqual } from '../stats.js';
 import { normalizePath } from '../utils.js';
-import { dirname, join, relative } from './path.js';
+import { basename, dirname, join, relative } from './path.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -143,16 +143,13 @@ export function emitChange(context, eventType, filename) {
     if (context)
         filename = join((_a = context.root) !== null && _a !== void 0 ? _a : '/', filename);
     filename = normalizePath(filename);
-    // Notify watchers on parent directories if they are watching recursively
-    let parent = filename, normalizedFilename;
-    while (normalizedFilename != '/') {
-        normalizedFilename = parent;
-        parent = dirname(parent);
-        const parentWatchers = watchers.get(parent);
-        if (!parentWatchers)
+    // Notify watchers, including ones on parent directories if they are watching recursively
+    for (let path = filename; path != '/'; path = dirname(path)) {
+        const watchersForPath = watchers.get(path);
+        if (!watchersForPath)
             continue;
-        for (const watcher of parentWatchers) {
-            watcher.emit('change', eventType, relative(parent, filename));
+        for (const watcher of watchersForPath) {
+            watcher.emit('change', eventType, relative(path, filename) || basename(filename));
         }
     }
 }

package/package.json

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

package/tests/fs/watch.test.ts

@@ -13,13 +13,18 @@ await fs.promises.writeFile(testFile, 'Initial content');
  */
 await suite('Watch Features', () => {
 	test('fs.watch should emit events on file change', async () => {
+		const { promise, resolve } = Promise.withResolvers<[string, string]>();
+
 		using watcher = fs.watch(testFile, (eventType, filename) => {
-			assert.equal(eventType, 'change');
-			assert.equal(filename, 'test.txt');
+			resolve([eventType, filename]);
 		});
 
 		// Modify the file to trigger the event
 		await fs.promises.writeFile(testFile, 'Updated content');
+
+		const [eventType, filename] = await promise;
+		assert.equal(eventType, 'change');
+		assert.equal(filename, 'test.txt');
 	});
 
 	test('fs.watch should emit events on file rename (delete)', async () => {

package/types/readable-stream.d.ts

@@ -11,6 +11,7 @@ This allows us to bypass those problems.
 Warning: Do not install @types/readable-stream alongside this package!
 */
 
+/// <reference types="node" preserve="true" />
 declare module 'readable-stream' {
 	import { Readable, Writable } from 'node:stream';
 	export { Readable, Writable };