@zenfs/core 2.7.2 → 2.7.3

package/dist/backends/fetch.d.ts

@@ -47,6 +47,8 @@ export declare class FetchFS extends IndexFS {
     protected _async(p: Promise<unknown>): void;
     constructor(index: Index, baseUrl: string, requestInit?: RequestInit, remoteWrite?: boolean | undefined);
     protected resize(path: string, inode: Inode, oldSize: number): Promise<void> | void;
+    protected _create(path: string, inode: Inode): Promise<void>;
+    protected _createSync(path: string, inode: Inode): void;
     touch(path: string, metadata: InodeLike): Promise<void>;
     touchSync(path: string, metadata: InodeLike): void;
     protected remove(path: string): Promise<void>;

package/dist/backends/fetch.js

@@ -63,6 +63,14 @@ export class FetchFS extends IndexFS {
         if (this.remoteWrite)
             return requests.set(url, zeroes, { offset: oldSize, warn }, this.requestInit).catch(parseError);
     }
+    async _create(path, inode) {
+        await requests
+            .set(this.baseUrl + path, new Uint8Array(inode.size), { warn, cacheOnly: !this.remoteWrite, method: 'PUT' }, this.requestInit)
+            .catch(parseError);
+    }
+    _createSync(path, inode) {
+        this._async(this._create(path, inode));
+    }
     async touch(path, metadata) {
         const inode = this.index.get(path) ?? _throw(withErrno('ENOENT'));
         const oldSize = inode.size;
@@ -81,7 +89,7 @@ export class FetchFS extends IndexFS {
         await requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit);
     }
     removeSync(path) {
-        this._async(requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit));
+        this._async(this.remove(path));
     }
     async read(path, buffer, offset = 0, end) {
         const inode = this.index.get(path);

package/dist/internal/index_fs.d.ts

@@ -5,6 +5,8 @@ import { Inode, type InodeLike } from './inode.js';
  * A file system that uses an `Index` for metadata.
  * @category Internals
  * @internal
+ *
+ * @todo [breaking] replace the three method `create` system with something more intuitive, e.g. requiring subclasses to implement `createFile`, with this just exposing `create` for convenience.
  */
 export declare abstract class IndexFS extends FileSystem {
     readonly index: Index;
@@ -27,6 +29,10 @@ export declare abstract class IndexFS extends FileSystem {
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
+    /** Create a new file in the underlying backend */
+    protected _create?(path: string, inode: Inode): Promise<void>;
+    /** Create a new file in the underlying backend */
+    protected _createSync?(path: string, inode: Inode): void;
     protected create(path: string, options: CreationOptions): Inode;
     createFile(path: string, options: CreationOptions): Promise<Inode>;
     createFileSync(path: string, options: CreationOptions): Inode;

package/dist/internal/index_fs.js

@@ -11,6 +11,8 @@ import { Inode } from './inode.js';
  * A file system that uses an `Index` for metadata.
  * @category Internals
  * @internal
+ *
+ * @todo [breaking] replace the three method `create` system with something more intuitive, e.g. requiring subclasses to implement `createFile`, with this just exposing `create` for convenience.
  */
 export class IndexFS extends FileSystem {
     index;
@@ -165,10 +167,26 @@ export class IndexFS extends FileSystem {
         return inode;
     }
     async createFile(path, options) {
-        return this.create(path, { ...options, mode: options.mode | S_IFREG });
+        const inode = this.create(path, { ...options, mode: options.mode | S_IFREG });
+        try {
+            await this._create?.(path, inode);
+            return inode;
+        }
+        catch (e) {
+            this.index.delete(path);
+            throw e;
+        }
     }
     createFileSync(path, options) {
-        return this.create(path, { ...options, mode: options.mode | S_IFREG });
+        const inode = this.create(path, { ...options, mode: options.mode | S_IFREG });
+        try {
+            this._createSync?.(path, inode);
+            return inode;
+        }
+        catch (e) {
+            this.index.delete(path);
+            throw e;
+        }
     }
     async mkdir(path, options) {
         options = { ...options, mode: options.mode | S_IFDIR };

package/dist/mixins/async.d.ts

@@ -1,3 +1,4 @@
+import type { Semaphore } from 'kerium/locks';
 import type { FileSystem } from '../internal/filesystem.js';
 import { type _SyncFSKeys, type AsyncFSMethods, type Mixin } from './shared.js';
 /**
@@ -12,13 +13,11 @@ export type AsyncOperation = {
  * @category Internals
  */
 export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'existsSync'>> {
-    /**
-     * @internal @protected
-     */
+    /** @internal @protected */
     _sync?: FileSystem;
-    /**
-     * @deprecated Use {@link sync | `sync`} instead
-     */
+    /** Restrict how many files can be copied across at once @internal @protected */
+    _crossCopySemaphore?: Semaphore;
+    /** @deprecated Use {@link sync | `sync`} instead */
     queueDone(): Promise<void>;
     ready(): Promise<void>;
     sync(): Promise<void>;

package/dist/mixins/async.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { crit, debug, err } from 'kerium/log';
@@ -164,19 +216,30 @@ export function Async(FS) {
                 },
             });
         }
-        /**
-         * @internal
-         */
+        /** @internal @protected */
+        _crossCopySemaphore;
+        /** @internal */
         async crossCopy(path) {
             this.checkSync();
             const stats = await this.stat(path);
             if (!isDirectory(stats)) {
-                this._sync.createFileSync(path, stats);
-                const buffer = new Uint8Array(stats.size);
-                await this.read(path, buffer, 0, stats.size);
-                this._sync.writeSync(path, buffer, 0);
-                this._sync.touchSync(path, stats);
-                return;
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const _ = __addDisposableResource(env_1, (await this._crossCopySemaphore?.get()) || { [Symbol.dispose]() { } }, false);
+                    this._sync.createFileSync(path, stats);
+                    const buffer = new Uint8Array(stats.size);
+                    await this.read(path, buffer, 0, stats.size);
+                    this._sync.writeSync(path, buffer, 0);
+                    this._sync.touchSync(path, stats);
+                    return;
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
             }
             if (path !== '/') {
                 this._sync.mkdirSync(path, stats);

package/dist/node/sync.d.ts

@@ -1,3 +1,4 @@
+import type { BufferView } from 'node:buffer';
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { FileContents } from '../vfs/shared.js';
@@ -72,14 +73,14 @@ export declare function lopenSync(this: V_Context, path: fs.PathLike, flag: stri
  * Synchronously reads the entire contents of a file.
  * @option encoding The string encoding for the file contents. Defaults to `null`.
  * @option flag Defaults to `'r'`.
+ * @option buffer A view (or a factory taking the file size) the contents are read into,
+ * instead of allocating a new buffer. It must be large enough to hold the entire file.
  * @returns file contents
  */
-export declare function readFileSync(this: V_Context, path: fs.PathOrFileDescriptor, options?: {
-    flag?: string;
-} | null): NonSharedBuffer;
-export declare function readFileSync(this: V_Context, path: fs.PathOrFileDescriptor, options?: (fs.EncodingOption & {
-    flag?: string;
-}) | BufferEncoding | null): string;
+export declare function readFileSync<T extends NodeJS.ArrayBufferView>(this: V_Context, path: fs.PathOrFileDescriptor, options: fs.ReadFileSyncOptionsWithBuffer<T>): BufferView<T>;
+export declare function readFileSync(this: V_Context, path: fs.PathOrFileDescriptor, options?: fs.ReadFileSyncOptionsWithBufferEncoding | null): NonSharedBuffer;
+export declare function readFileSync(this: V_Context, path: fs.PathOrFileDescriptor, options: fs.ReadFileSyncOptionsWithStringEncoding | BufferEncoding): string;
+export declare function readFileSync(this: V_Context, path: fs.PathOrFileDescriptor, options: fs.ReadFileSyncOptions): string | NonSharedBuffer;
 /**
  * Synchronously writes data to a file, replacing the file if it already exists.
  *

package/dist/node/sync.js

@@ -175,6 +175,22 @@ openSync;
 export function lopenSync(path, flag, mode) {
     return toFD(_sync.open(this, path, { flag, mode, preserveSymlinks: true }));
 }
+/**
+ * Resolves the `buffer` option of `readFileSync` into a buffer covering the first `size` bytes of the view.
+ * @hidden
+ */
+function intoBuffer(into, size) {
+    const isFn = typeof into == 'function';
+    const view = isFn ? into(size) : into;
+    const name = isFn ? 'options.buffer()' : 'options.buffer';
+    if (!ArrayBuffer.isView(view))
+        throw Object.assign(new TypeError(`The "options.buffer" property must be of type function or an instance of Buffer, TypedArray, or DataView. Received ${typeof view}`), { code: 'ERR_INVALID_ARG_TYPE' });
+    if (view.byteLength < size)
+        throw Object.assign(new TypeError(`The property '${name}.byteLength' is smaller than the file size of ${size} bytes. Received ${view.byteLength}`), {
+            code: 'ERR_INVALID_ARG_VALUE',
+        });
+    return Buffer.from(view.buffer, view.byteOffset, size);
+}
 export function readFileSync(path, _options = {}) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
@@ -186,7 +202,8 @@ export function readFileSync(path, _options = {}) {
             ? fromFD(this, path)
             : _sync.open(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
         const { size } = file.stat();
-        const data = Buffer.alloc(size);
+        const into = typeof _options == 'object' && _options !== null ? _options.buffer : undefined;
+        const data = into === undefined ? Buffer.alloc(size) : intoBuffer(into, size);
         file.readSync(data, 0, size, 0);
         return options.encoding ? data.toString(options.encoding) : data;
     }
@@ -584,7 +601,7 @@ export function copyFileSync(source, destination, flags) {
     destination = normalizePath.call(this, destination);
     if (flags && flags & constants.COPYFILE_EXCL && existsSync.call(this, destination))
         throw UV('EEXIST', 'copyFile', destination);
-    writeFileSync.call(this, destination, readFileSync.call(this, source));
+    writeFileSync.call(this, destination, readFileSync.call(this, source, {}));
     emitChange(this, 'rename', destination.toString());
 }
 copyFileSync;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.7.2",
+	"version": "2.7.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -69,16 +69,15 @@
 		"lint": "eslint src tests",
 		"test": "npx -s zenfs-test --clean; npx -s zenfs-test -abcpn; tests/fetch/run.sh; npx -s zenfs-test --report-only",
 		"test:native": "npx -s zenfs-test tests/native-setup.ts --verbose",
-		"build": "tsc -p tsconfig.json",
-		"build:docs": "typedoc",
-		"dev": "tsc -p tsconfig.json --watch",
+		"build": "tsc --build",
+		"dev": "tsc --build --watch",
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
 		"@types/node": "^26.0.0",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
-		"kerium": "^1.4.2",
+		"kerium": "^1.5.0",
 		"memium": "^1.0.0",
 		"readable-stream": "^4.5.2",
 		"utilium": "^3.0.0"