@zenfs/core 2.3.1 → 2.3.2

package/dist/vfs/promises.d.ts

@@ -11,6 +11,7 @@ import type { FileContents, ReaddirOptions } from './types.js';
 import { Buffer } from 'buffer';
 import '../polyfills.js';
 import { Dir, Dirent } from './dir.js';
+import { SyncHandle } from './file.js';
 import { BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
@@ -18,10 +19,6 @@ export declare class FileHandle implements promises.FileHandle {
     protected context: V_Context;
     readonly fd: number;
     protected _buffer?: Uint8Array;
-    /**
-     * Current position
-     */
-    protected _position: number;
     /**
      * Get the current file position.
      *
@@ -42,15 +39,16 @@ export declare class FileHandle implements promises.FileHandle {
      */
     protected closed: boolean;
     /** The path relative to the context's root */
-    readonly path: string;
+    get path(): string;
     /** The internal FS associated with the handle */
-    protected readonly fs: FileSystem;
+    protected get fs(): FileSystem;
     /** The path relative to the `FileSystem`'s root */
-    readonly internalPath: string;
+    get internalPath(): string;
     /** The flag the handle was opened with */
-    readonly flag: number;
+    get flag(): number;
     /** Stats for the handle */
-    readonly inode: InodeLike;
+    get inode(): InodeLike;
+    protected _sync: SyncHandle;
     constructor(context: V_Context, fd: number);
     private get _isSync();
     private _emitChange;

package/dist/vfs/promises.js

@@ -52,7 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { Buffer } from 'buffer';
 import { Exception, rethrow, setUVMessage, UV } from 'kerium';
-import { decodeUTF8, pick } from 'utilium';
+import { decodeUTF8 } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
@@ -73,10 +73,6 @@ export class FileHandle {
     context;
     fd;
     _buffer;
-    /**
-     * Current position
-     */
-    _position = 0;
     /**
      * Get the current file position.
      *
@@ -87,10 +83,10 @@ export class FileHandle {
      * @returns The current file position.
      */
     get position() {
-        return this.flag & constants.O_APPEND ? this.inode.size : this._position;
+        return this._sync.position;
     }
     set position(value) {
-        this._position = value;
+        this._sync.position = value;
     }
     /**
      * Whether the file has changes which have not been written to the FS
@@ -101,20 +97,30 @@ export class FileHandle {
      */
     closed = false;
     /** The path relative to the context's root */
-    path;
+    get path() {
+        return this._sync.path;
+    }
     /** The internal FS associated with the handle */
-    fs;
+    get fs() {
+        return this._sync.fs;
+    }
     /** The path relative to the `FileSystem`'s root */
-    internalPath;
+    get internalPath() {
+        return this._sync.internalPath;
+    }
     /** The flag the handle was opened with */
-    flag;
+    get flag() {
+        return this._sync.flag;
+    }
     /** Stats for the handle */
-    inode;
+    get inode() {
+        return this._sync.inode;
+    }
+    _sync;
     constructor(context, fd) {
         this.context = context;
         this.fd = fd;
-        const sync = fromFD(context, fd);
-        Object.assign(this, pick(sync, 'path', 'fs', 'internalPath', 'flag', 'inode'));
+        this._sync = fromFD(context, fd);
     }
     get _isSync() {
         return !!(this.flag & constants.O_SYNC || this.inode.flags & InodeFlags.Sync);
@@ -246,7 +252,7 @@ export class FileHandle {
         if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
             end = position + Math.max(this.inode.size - position, 0);
         }
-        this._position = end;
+        this._sync.position = end;
         const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
         await this.fs.read(this.internalPath, uint8.subarray(offset, offset + length), position, end);
         if (this._isSync)
@@ -348,7 +354,7 @@ export class FileHandle {
             this.inode.size = end;
         this.inode.mtimeMs = Date.now();
         this.inode.ctimeMs = Date.now();
-        this._position = position + slice.byteLength;
+        this._sync.position = position + slice.byteLength;
         await this.fs.write(this.internalPath, slice, position);
         if (this._isSync)
             await this.sync();

package/package.json

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

package/scripts/test.js

@@ -40,13 +40,14 @@ if (options.help) {
 Paths: The setup files to run tests on
 
 Behavior:
-    -a, --auto          Automatically detect setup files
-    -b, --build         Run the npm build script prior to running tests
-    -c, --common        Also run tests not specific to any backend
-    -e, --exit-on-fail  If any tests suites fail, exit immediately
-    -t, --test <glob>   Which FS test suite(s) to run
-    -f, --force         Whether to use --test-force-exit
-    -I, --inspect       Use the inspector for debugging
+    -a, --auto            Automatically detect setup files
+    -b, --build           Run the npm build script prior to running tests
+    -c, --common          Also run tests not specific to any backend
+    -e, --exit-on-fail    If any tests suites fail, exit immediately
+    -t, --test <glob>     Which FS test suite(s) to run
+    -f, --force           Whether to use --test-force-exit
+    -I, --inspect         Use the inspector for debugging
+	-s, --skip <pattern>  Skip tests with names matching the given pattern.
 
 Output:
     -h, --help          Outputs this help message
@@ -215,7 +216,7 @@ for (const setupFile of positionals) {
 				'--test --experimental-test-coverage',
 				options.force ? '--test-force-exit' : '',
 				options.skip ? `--test-skip-pattern=${options.skip}` : '',
-				testsGlob,
+				`'${testsGlob.replaceAll("'", "\\'")}'`,
 				process.env.CMD,
 			].join(' '),
 			{

package/tests/fs/read.test.ts

@@ -1,7 +1,9 @@
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
+import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { promisify } from 'node:util';
+import { fs, type Callback } from '../common.js';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
@@ -65,4 +67,25 @@ suite('read', () => {
 		assert.equal(buffer.subarray(10, buffer.length).toString(), expected);
 		assert.equal(bytesRead, expected.length);
 	});
+
+	test('read using callback API', async () => {
+		// @zenfs/core#239
+		const path = '/text.txt';
+
+		fs.writeFileSync(path, 'hello world');
+		const fd: number = (await promisify<PathLike, OpenMode, number | string>(fs.open)(path, 0, 0)) as any;
+
+		const read = promisify(fs.read);
+
+		const buf = Buffer.alloc(1024);
+		const n0 = await read(fd, buf, 0, 1024, undefined);
+		assert.equal(n0, 11);
+		assert.equal(buf.subarray(0, n0).toString('utf8'), 'hello world');
+
+		const n1 = await read(fd, buf, 0, 1024, undefined);
+		assert.equal(n1, 0);
+		assert.equal(buf.subarray(0, n1).toString('utf8'), '');
+
+		await promisify(fs.close)(fd);
+	});
 });