effect 4.0.0-beta.100 → 4.0.0-beta.102

package/dist/Stream.js

@@ -3849,7 +3849,7 @@ export const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, e
  * @since 4.0.0
  */
 export const catchReasons = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, cases, orElse) => {
-  const handlers = {};
+  const handlers = Object.create(null);
   for (const key of Object.keys(cases)) {
     const handler = cases[key];
     handlers[key] = (reason, error) => handler(reason, error).channel;
@@ -6519,7 +6519,7 @@ export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => from
  */
 export const interruptWhen = /*#__PURE__*/dual(2, (self, effect) => fromChannel(Channel.interruptWhen(self.channel, effect)));
 /**
- * Stops a stream after the current element when an effect completes.
+ * Stops a stream after the current pull when an effect completes.
  *
  * **When to use**
  *
@@ -6532,8 +6532,10 @@ export const interruptWhen = /*#__PURE__*/dual(2, (self, effect) => fromChannel(
  *
  * **Gotchas**
  *
- * This does not interrupt an in-progress pull. Use {@link interruptWhen} when
- * the stream should be interrupted immediately.
+ * This does not interrupt or truncate an in-progress pull. A pull may emit
+ * multiple elements in a single chunk, in which case the entire chunk is
+ * emitted. Use {@link interruptWhen} when the stream should be interrupted
+ * immediately.
  *
  * **Example** (Halting a stream after an effect completes)
  *
@@ -7674,35 +7676,63 @@ export const toReadableStreamEffect = /*#__PURE__*/dual(args => isStream(args[0]
 export const toAsyncIterableWith = /*#__PURE__*/dual(2, (self, context) => ({
   [Symbol.asyncIterator]() {
     const runPromise = Effect.runPromiseWith(context);
-    const runPromiseExit = Effect.runPromiseExitWith(context);
+    const runFork = Effect.runForkWith(context);
     const scope = Scope.makeUnsafe();
     let pull;
     let currentIter;
+    let currentFiber;
+    let closePromise;
+    const close = exit => {
+      if (closePromise) return closePromise;
+      const fiber = currentFiber;
+      closePromise = runPromise(Effect.as(Effect.andThen(fiber ? Fiber.interrupt(fiber) : Effect.void, Scope.close(scope, exit)), {
+        done: true,
+        value: undefined
+      }));
+      return closePromise;
+    };
+    const closeAndReportError = async exit => {
+      try {
+        await close(exit);
+      } catch (error) {
+        await runPromise(Effect.logError("Suppressed error while closing Stream async iterator", error));
+      }
+    };
     return {
       async next() {
+        if (closePromise) return closePromise;
         if (currentIter) {
           const next = currentIter.next();
           if (!next.done) return next;
           currentIter = undefined;
         }
-        pull ??= await runPromise(Channel.toPullScoped(self.channel, scope));
-        const exit = await runPromiseExit(pull);
+        const fiber = runFork(pull ?? Effect.flatMap(Channel.toPullScoped(self.channel, scope), nextPull => {
+          pull = nextPull;
+          return nextPull;
+        }));
+        currentFiber = fiber;
+        const exit = await runPromise(Fiber.await(fiber));
+        if (currentFiber === fiber) {
+          currentFiber = undefined;
+        }
         if (Exit.isSuccess(exit)) {
           currentIter = exit.value[Symbol.iterator]();
           return currentIter.next();
         } else if (Pull.isDoneCause(exit.cause)) {
-          return {
-            done: true,
-            value: undefined
-          };
+          return close(Exit.void);
+        }
+        if (closePromise && Cause.hasInterruptsOnly(exit.cause)) {
+          return closePromise;
         }
+        await closeAndReportError(exit);
         throw Cause.squash(exit.cause);
       },
-      return(_) {
-        return runPromise(Effect.as(Scope.close(scope, Exit.void), {
-          done: true,
-          value: undefined
-        }));
+      return() {
+        return close(Exit.void);
+      },
+      async throw(error) {
+        await closeAndReportError(Exit.die(error));
+        throw error;
       }
     };
   }