poe-code 15.0.5 → 15.0.6

package/packages/safe-js/dist/browser/safe-fs-core.js

@@ -34,12 +34,13 @@ import {
   readBytes,
   relativePath,
   resolvePath,
+  retainFileSystemCleanup,
   scopeFileSystem,
   toByteSource,
   toFsError,
   validatePath,
   withFileSystemQuota
-} from "./chunks/chunk-GQOAEEHU.js";
+} from "./chunks/chunk-3EJ7BQOJ.js";
 export {
   ACCESS_MODES,
   DeviceFileSystem,
@@ -76,6 +77,7 @@ export {
   readBytes,
   relativePath,
   resolvePath,
+  retainFileSystemCleanup,
   scopeFileSystem,
   toByteSource,
   toFsError,

package/packages/safe-js/dist/browser/safe-fs.js

@@ -34,12 +34,13 @@ import {
   readBytes,
   relativePath,
   resolvePath,
+  retainFileSystemCleanup,
   scopeFileSystem,
   toByteSource,
   toFsError,
   validatePath,
   withFileSystemQuota
-} from "./chunks/chunk-GQOAEEHU.js";
+} from "./chunks/chunk-3EJ7BQOJ.js";
 export {
   ACCESS_MODES,
   DeviceFileSystem,
@@ -76,6 +77,7 @@ export {
   readBytes,
   relativePath,
   resolvePath,
+  retainFileSystemCleanup,
   scopeFileSystem,
   toByteSource,
   toFsError,

package/packages/safe-js/dist/chunks/{chunk-DIISVPWF.js → chunk-742TUUOL.js}

@@ -6150,8 +6150,8 @@ var operations = /* @__PURE__ */ new Set([
   "writeFile",
   "writeStream"
 ]);
-function scopeFileSystem(filesystem, charge, signal) {
-  const original = originals.get(filesystem) ?? filesystem;
+function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge) {
+  const original = originals.get(filesystem)?.filesystem ?? filesystem;
   const methods = /* @__PURE__ */ new Map();
   const assertOpen = (options) => {
     signal.throwIfAborted();
@@ -6304,7 +6304,7 @@ function scopeFileSystem(filesystem, charge, signal) {
         }
         if (property === "compareEntry") {
           const peer = args[1];
-          args[1] = originals.get(peer) ?? peer;
+          args[1] = originals.get(peer)?.filesystem ?? peer;
         }
         if (property === "rename" && args[2]?.noReplace) return (async () => {
           const options = args[2];
@@ -6328,13 +6328,96 @@ function scopeFileSystem(filesystem, charge, signal) {
       return scoped;
     }
   });
-  originals.set(view, original);
+  originals.set(view, { filesystem: original, signal, cleanupCharge });
   registerEntryView(view, async (path, options) => {
     assertOpen(options);
     return { filesystem: original, path };
   });
   return view;
 }
+function retainFileSystemCleanup(filesystem, cleanupCallback, options) {
+  const maximum = options?.maxOperations === void 0 ? 256 : options.maxOperations;
+  if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 4096) throw new RangeError("cleanup maxOperations must be an integer between 0 and 4096");
+  if (typeof cleanupCallback !== "function") throw new TypeError("cleanup callback must be a function");
+  const scope = originals.get(filesystem);
+  scope?.signal.throwIfAborted();
+  const backing = scope?.filesystem ?? filesystem;
+  const pending = /* @__PURE__ */ new Set();
+  let operations2 = 0;
+  let active = false;
+  let closing;
+  const invoke = (method, path, settings) => {
+    if (!active) {
+      const rejected = Promise.reject(new FsError("EBADF", { syscall: method, path, message: "cleanup callback is not active" }));
+      void rejected.catch(() => {
+      });
+      return rejected;
+    }
+    let result;
+    try {
+      settings?.signal?.throwIfAborted();
+      if (operations2 >= maximum) throw new FsError("EFBIG", { syscall: method, path, message: "cleanup operation limit exceeded" });
+      operations2++;
+      scope?.cleanupCharge();
+      settings?.signal?.throwIfAborted();
+      const operation = backing[method];
+      if (typeof operation !== "function") throw new FsError("ENOTSUP", { syscall: method, path });
+      const parameters = method === "rm" ? { ...settings, recursive: false, force: false } : settings;
+      result = Promise.resolve(Reflect.apply(operation, backing, [path, parameters]));
+    } catch (error) {
+      result = Promise.reject(error);
+      void result.catch(() => {
+      });
+      return result;
+    }
+    const completion = result.then(
+      () => {
+        pending.delete(completion);
+        return { status: "fulfilled", value: void 0 };
+      },
+      (error) => {
+        pending.delete(completion);
+        return { status: "rejected", reason: error };
+      }
+    );
+    pending.add(completion);
+    return result;
+  };
+  const view = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+    lstat: invoke.bind(void 0, "lstat"),
+    realpath: invoke.bind(void 0, "realpath"),
+    rm: invoke.bind(void 0, "rm"),
+    ...typeof backing.rmdir === "function" ? { rmdir: invoke.bind(void 0, "rmdir") } : {}
+  }));
+  scope?.signal.throwIfAborted();
+  return () => {
+    if (!closing) {
+      closing = Promise.resolve().then(async () => {
+        active = true;
+        let callbackFailed = false;
+        let callbackFailure;
+        try {
+          const result = cleanupCallback(view);
+          if (result !== void 0) await result;
+        } catch (error) {
+          callbackFailed = true;
+          callbackFailure = error;
+        } finally {
+          active = false;
+        }
+        const outcomes = await Promise.all(pending);
+        if (callbackFailed) throw callbackFailure;
+        const failures = [];
+        for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1) throw new AggregateError(failures, "retained filesystem cleanup failed");
+      });
+      void closing.catch(() => {
+      });
+    }
+    return closing;
+  };
+}
 
 // packages/safe-fs/src/bridge/stats.ts
 function predicates(type) {
@@ -6973,6 +7056,7 @@ export {
   FileSystemQuotaError,
   withFileSystemQuota,
   scopeFileSystem,
+  retainFileSystemCleanup,
   FileSystemBridge
 };
-//# sourceMappingURL=chunk-DIISVPWF.js.map
+//# sourceMappingURL=chunk-742TUUOL.js.map