@zenfs/core 0.12.10 → 0.14.0

package/dist/emulation/promises.d.ts

@@ -18,6 +18,7 @@ import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
+import '../symbol-dispose.js';
 export declare class FileHandle implements promises.FileHandle {
     /**
      * The file descriptor for this file handle.

package/dist/emulation/promises.js

@@ -1,3 +1,48 @@
+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;
+        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 (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        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;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            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;
+});
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
 import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
@@ -9,6 +54,7 @@ import { dirname, join, parse } from './path.js';
 import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
+import '../symbol-dispose.js';
 export class FileHandle {
     constructor(fdOrFile) {
         const isFile = typeof fdOrFile != 'number';
@@ -353,12 +399,19 @@ lstat;
  * @param len
  */
 export async function truncate(path, len = 0) {
-    const handle = await open(path, 'r+');
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_1, await open(path, 'r+'), true);
         await handle.truncate(len);
     }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
 }
 truncate;
@@ -425,13 +478,20 @@ export async function open(path, flag = 'r', mode = 0o644) {
 }
 open;
 export async function readFile(path, _options) {
-    const options = normalizeOptions(_options, null, 'r', 0o644);
-    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        const options = normalizeOptions(_options, null, 'r', 0o644);
+        const handle = __addDisposableResource(env_2, typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode), true);
         return await handle.readFile(options);
     }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
     }
 }
 readFile;
@@ -447,17 +507,24 @@ readFile;
  * @option options flag Defaults to `'w'`.
  */
 export async function writeFile(path, data, _options) {
-    const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-    const handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
+    const env_3 = { stack: [], error: void 0, hasError: false };
     try {
+        const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
+        const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode), true);
         const _data = typeof data == 'string' ? data : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
             throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
         }
         await handle.writeFile(_data, options);
     }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
     }
 }
 writeFile;
@@ -472,21 +539,28 @@ writeFile;
  * @option options flag Defaults to `'a'`.
  */
 export async function appendFile(path, data, _options) {
-    const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isAppendable(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
-    }
-    if (typeof data != 'string' && !options.encoding) {
-        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-    }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
+    const env_4 = { stack: [], error: void 0, hasError: false };
     try {
+        const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
+        const flag = parseFlag(options.flag);
+        if (!isAppendable(flag)) {
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        }
+        if (typeof data != 'string' && !options.encoding) {
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+        }
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const handle = __addDisposableResource(env_4, typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode), true);
         await handle.appendFile(encodedData, options);
     }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
     }
 }
 appendFile;
@@ -508,14 +582,28 @@ export async function rmdir(path) {
 }
 rmdir;
 export async function mkdir(path, options) {
+    options = typeof options === 'object' ? options : { mode: options };
+    const mode = normalizeMode(options?.mode, 0o777);
     path = normalizePath(path);
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
+    const errorPaths = { [resolved]: path };
     try {
-        await fs.mkdir(resolved, normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
+        if (!options?.recursive) {
+            await fs.mkdir(resolved, mode, cred);
+        }
+        const dirs = [];
+        for (let dir = resolved, origDir = path; !(await fs.exists(dir, cred)); dir = dirname(dir), origDir = dirname(origDir)) {
+            dirs.unshift(dir);
+            errorPaths[dir] = origDir;
+        }
+        for (const dir of dirs) {
+            await fs.mkdir(dir, mode, cred);
+        }
+        return dirs[0];
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw fixError(e, errorPaths);
     }
 }
 mkdir;
@@ -584,14 +672,21 @@ export async function symlink(target, path, type = 'file') {
 }
 symlink;
 export async function readlink(path, options) {
-    const handle = await _open(normalizePath(path), 'r', 0o644, false);
+    const env_5 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_5, await _open(normalizePath(path), 'r', 0o644, false), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options?.encoding : options;
         return encoding == 'buffer' ? value : value.toString(encoding);
     }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_5 = __disposeResources(env_5);
+        if (result_5)
+            await result_5;
     }
 }
 readlink;
@@ -603,12 +698,19 @@ readlink;
  * @param gid
  */
 export async function chown(path, uid, gid) {
-    const handle = await open(path, 'r+');
+    const env_6 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_6, await open(path, 'r+'), true);
         await handle.chown(uid, gid);
     }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_6 = __disposeResources(env_6);
+        if (result_6)
+            await result_6;
     }
 }
 chown;
@@ -619,12 +721,19 @@ chown;
  * @param gid
  */
 export async function lchown(path, uid, gid) {
-    const handle = await _open(path, 'r+', 0o644, false);
+    const env_7 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_7, await _open(path, 'r+', 0o644, false), true);
         await handle.chown(uid, gid);
     }
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_7 = __disposeResources(env_7);
+        if (result_7)
+            await result_7;
     }
 }
 lchown;
@@ -634,12 +743,19 @@ lchown;
  * @param mode
  */
 export async function chmod(path, mode) {
-    const handle = await open(path, 'r+');
+    const env_8 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_8, await open(path, 'r+'), true);
         await handle.chmod(mode);
     }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_8 = __disposeResources(env_8);
+        if (result_8)
+            await result_8;
     }
 }
 chmod;
@@ -649,12 +765,19 @@ chmod;
  * @param mode
  */
 export async function lchmod(path, mode) {
-    const handle = await _open(path, 'r+', 0o644, false);
+    const env_9 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_9, await _open(path, 'r+', 0o644, false), true);
         await handle.chmod(mode);
     }
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_9 = __disposeResources(env_9);
+        if (result_9)
+            await result_9;
     }
 }
 lchmod;
@@ -665,12 +788,19 @@ lchmod;
  * @param mtime
  */
 export async function utimes(path, atime, mtime) {
-    const handle = await open(path, 'r+');
+    const env_10 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_10, await open(path, 'r+'), true);
         await handle.utimes(atime, mtime);
     }
+    catch (e_10) {
+        env_10.error = e_10;
+        env_10.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_10 = __disposeResources(env_10);
+        if (result_10)
+            await result_10;
     }
 }
 utimes;
@@ -681,12 +811,19 @@ utimes;
  * @param mtime
  */
 export async function lutimes(path, atime, mtime) {
-    const handle = await _open(path, 'r+', 0o644, false);
+    const env_11 = { stack: [], error: void 0, hasError: false };
     try {
+        const handle = __addDisposableResource(env_11, await _open(path, 'r+', 0o644, false), true);
         await handle.utimes(new Date(atime), new Date(mtime));
     }
+    catch (e_11) {
+        env_11.error = e_11;
+        env_11.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_11 = __disposeResources(env_11);
+        if (result_11)
+            await result_11;
     }
 }
 lutimes;

package/dist/emulation/sync.js

@@ -1,3 +1,48 @@
+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;
+        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 (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        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;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            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;
+});
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
 import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
@@ -78,12 +123,21 @@ lstatSync;
  * @param len
  */
 export function truncateSync(path, len = 0) {
-    const fd = openSync(path, 'r+');
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        ftruncateSync(fd, len);
+        const file = __addDisposableResource(env_1, _openSync(path, 'r+'), false);
+        len || (len = 0);
+        if (len < 0) {
+            throw new ErrnoError(Errno.EINVAL);
+        }
+        file.truncateSync(len);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        closeSync(fd);
+        __disposeResources(env_1);
     }
 }
 truncateSync;
@@ -161,9 +215,10 @@ export function lopenSync(path, flag, mode) {
  * Synchronously reads the entire contents of a file.
  */
 function _readFileSync(fname, flag, resolveSymlinks) {
-    // Get file.
-    const file = _openSync(fname, flag, 0o644, resolveSymlinks);
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        // Get file.
+        const file = __addDisposableResource(env_2, _openSync(fname, flag, 0o644, resolveSymlinks), false);
         const stat = file.statSync();
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
@@ -171,8 +226,12 @@ function _readFileSync(fname, flag, resolveSymlinks) {
         file.closeSync();
         return data;
     }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
     finally {
-        file.closeSync();
+        __disposeResources(env_2);
     }
 }
 export function readFileSync(path, _options = {}) {
@@ -186,24 +245,29 @@ export function readFileSync(path, _options = {}) {
 }
 readFileSync;
 export function writeFileSync(path, data, _options = {}) {
-    const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isWriteable(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing.');
-    }
-    if (typeof data != 'string' && !options.encoding) {
-        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-    }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    if (!encodedData) {
-        throw new ErrnoError(Errno.EINVAL, 'Data not specified');
-    }
-    const file = _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true);
+    const env_3 = { stack: [], error: void 0, hasError: false };
     try {
+        const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
+        const flag = parseFlag(options.flag);
+        if (!isWriteable(flag)) {
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing.');
+        }
+        if (typeof data != 'string' && !options.encoding) {
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+        }
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        if (!encodedData) {
+            throw new ErrnoError(Errno.EINVAL, 'Data not specified');
+        }
+        const file = __addDisposableResource(env_3, _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
     }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
     finally {
-        file.closeSync();
+        __disposeResources(env_3);
     }
 }
 writeFileSync;
@@ -219,21 +283,26 @@ writeFileSync;
  * @option options flag Defaults to `'a'`.
  */
 export function appendFileSync(filename, data, _options = {}) {
-    const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isAppendable(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
-    }
-    if (typeof data != 'string' && !options.encoding) {
-        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-    }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    const file = _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true);
+    const env_4 = { stack: [], error: void 0, hasError: false };
     try {
+        const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
+        const flag = parseFlag(options.flag);
+        if (!isAppendable(flag)) {
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        }
+        if (typeof data != 'string' && !options.encoding) {
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+        }
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const file = __addDisposableResource(env_4, _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true), false);
         file.writeSync(encodedData, 0, encodedData.byteLength);
     }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
     finally {
-        file.closeSync();
+        __disposeResources(env_4);
     }
 }
 appendFileSync;
@@ -366,15 +435,28 @@ export function rmdirSync(path) {
 }
 rmdirSync;
 export function mkdirSync(path, options) {
-    const mode = normalizeMode(typeof options == 'number' || typeof options == 'string' ? options : options?.mode, 0o777);
-    const recursive = typeof options == 'object' && options?.recursive;
+    options = typeof options === 'object' ? options : { mode: options };
+    const mode = normalizeMode(options?.mode, 0o777);
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    path = existsSync(path) ? realpathSync(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    const errorPaths = { [resolved]: path };
     try {
-        return fs.mkdirSync(resolved, mode, cred);
+        if (!options?.recursive) {
+            return fs.mkdirSync(resolved, mode, cred);
+        }
+        const dirs = [];
+        for (let dir = resolved, original = path; !fs.existsSync(dir, cred); dir = dirname(dir), original = dirname(original)) {
+            dirs.unshift(dir);
+            errorPaths[dir] = original;
+        }
+        for (const dir of dirs) {
+            fs.mkdirSync(dir, mode, cred);
+        }
+        return dirs[0];
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw fixError(e, errorPaths);
     }
 }
 mkdirSync;

package/dist/file.d.ts

@@ -3,6 +3,7 @@
 import type { FileReadResult } from 'node:fs/promises';
 import type { FileSystem } from './filesystem.js';
 import { Stats, type FileType } from './stats.js';
+import './symbol-dispose.js';
 declare global {
     interface ArrayBuffer {
         readonly resizable: boolean;

package/dist/file.js

@@ -2,6 +2,7 @@ import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY,
 import { Errno, ErrnoError } from './error.js';
 import { size_max } from './inode.js';
 import { Stats } from './stats.js';
+import './symbol-dispose.js';
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {