@zenfs/core 1.8.0 → 1.8.2

package/dist/utils.js

@@ -160,3 +160,36 @@ export function canary(path, syscall) {
 export function _throw(e) {
     throw e;
 }
+/**
+ * Grows a buffer if it isn't large enough
+ * @returns The original buffer if resized successfully, or a newly created buffer
+ * @internal Not for external use!
+ */
+export function growBuffer(buffer, newByteLength) {
+    if (buffer.byteLength >= newByteLength)
+        return buffer;
+    if (ArrayBuffer.isView(buffer)) {
+        const newBuffer = growBuffer(buffer.buffer, newByteLength);
+        return new buffer.constructor(newBuffer, buffer.byteOffset, newByteLength);
+    }
+    const isShared = buffer instanceof SharedArrayBuffer;
+    // Note: If true, the buffer must be resizable/growable because of the first check.
+    if (buffer.maxByteLength > newByteLength) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        isShared ? buffer.grow(newByteLength) : buffer.resize(newByteLength);
+        return buffer;
+    }
+    if (isShared) {
+        const newBuffer = new SharedArrayBuffer(newByteLength);
+        new Uint8Array(newBuffer).set(new Uint8Array(buffer));
+        return newBuffer;
+    }
+    try {
+        return buffer.transfer(newByteLength);
+    }
+    catch {
+        const newBuffer = new ArrayBuffer(newByteLength);
+        new Uint8Array(newBuffer).set(new Uint8Array(buffer));
+        return newBuffer;
+    }
+}

package/dist/vfs/async.js

@@ -431,7 +431,7 @@ export function createReadStream(path, options) {
             try {
                 handle || (handle = await promises.open.call(context, path, 'r', options === null || options === void 0 ? void 0 : options.mode));
                 const result = await handle.read(new Uint8Array(size), 0, size, handle.file.position);
-                stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead));
+                stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
                 handle.file.position += result.bytesRead;
                 if (!result.bytesRead) {
                     await handle.close();

package/dist/vfs/promises.js

@@ -197,7 +197,7 @@ export class FileHandle {
                         controller.close();
                         return;
                     }
-                    controller.enqueue(result.buffer.slice(0, result.bytesRead));
+                    controller.enqueue(result.buffer.subarray(0, result.bytesRead));
                     position += result.bytesRead;
                     if (++i >= maxChunks) {
                         throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
@@ -333,7 +333,7 @@ export class FileHandle {
             read: async (size) => {
                 try {
                     const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
-                    stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead)); // Push data or null for EOF
+                    stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead)); // Push data or null for EOF
                     this.file.position += result.bytesRead;
                 }
                 catch (error) {

package/eslint.shared.js

@@ -45,6 +45,7 @@ export default [
 			'@typescript-eslint/no-unsafe-call': 'off',
 			'@typescript-eslint/restrict-plus-operands': 'off',
 			'@typescript-eslint/no-base-to-string': 'off',
+			'@typescript-eslint/no-unused-expressions': 'warn',
 		},
 	},
 	{

package/package.json

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

package/tests/fs/write.test.ts

@@ -1,10 +1,9 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-
+const fn = 'write.txt';
 suite('write', () => {
 	test('write file with specified content', async () => {
-		const fn = 'write.txt';
 		const expected = 'ümlaut.';
 
 		const handle = await fs.promises.open(fn, 'w', 0o644);
@@ -20,10 +19,9 @@ suite('write', () => {
 	});
 
 	test('write a buffer to a file', async () => {
-		const filename = 'write.txt';
 		const expected = Buffer.from('hello');
 
-		const handle = await fs.promises.open(filename, 'w', 0o644);
+		const handle = await fs.promises.open(fn, 'w', 0o644);
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
@@ -31,15 +29,12 @@ suite('write', () => {
 
 		await handle.close();
 
-		assert((await fs.promises.readFile(filename)).equals(expected));
+		assert((await fs.promises.readFile(fn)).equals(expected));
 
-		await fs.promises.unlink(filename);
+		await fs.promises.unlink(fn);
 	});
-});
 
-suite('writeSync', () => {
-	test('write file with specified content', () => {
-		const fn = 'write.txt';
+	test('writeSync file with specified content', () => {
 		const fd = fs.openSync(fn, 'w');
 
 		let written = fs.writeSync(fd, '');
@@ -53,6 +48,6 @@ suite('writeSync', () => {
 
 		fs.closeSync(fd);
 
-		assert(fs.readFileSync(fn, 'utf8') === 'foobár');
+		assert.strictEqual(fs.readFileSync(fn, 'utf8'), 'foobár');
 	});
 });