effect 2.0.0-next.46 → 2.0.0-next.47

package/dist/{tRef-b860ef05.cjs.dev.js → tRef-90f0872b.cjs.dev.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var core = require('./core-c5747f88.cjs.dev.js');
+var core = require('./core-c01fd1d8.cjs.dev.js');
 var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js');
 
 /** @internal */

package/internal/queue.esm.js

@@ -1,8 +1,8 @@
-import { head, prepend, filter, isEmpty as isEmpty$1, fromIterable as fromIterable$1, appendAll, append, empty as empty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { head, prepend, filter, isEmpty as isEmpty$2, fromIterable as fromIterable$1, appendAll, append, empty as empty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
 import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
 import { flatMap, sync, map, deferredMake, fiberId, withFiberRuntime, unit, succeed, deferredUnsafeDone, deferredInterruptWith, asUnit, deferredUnsafeMake, onInterrupt, suspend, interrupt, deferredAwait, catchAll, uninterruptible, whenEffect, deferredSucceed, zipRight } from './core.esm.js';
 import { forEachParUnboundedDiscard } from './fiberRuntime.esm.js';
-import { bounded as bounded$1, unbounded as unbounded$1, length, poll as poll$1, EmptyMutableQueue, offer as offer$1, offerAll as offerAll$1, pollUpTo, capacity as capacity$1 } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
+import { bounded as bounded$1, unbounded as unbounded$1, length, isEmpty as isEmpty$1, poll as poll$1, EmptyMutableQueue, offer as offer$1, offerAll as offerAll$1, pollUpTo, capacity as capacity$1 } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
 import { make as make$1, get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
 import { none, some } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
@@ -162,7 +162,7 @@ class QueueImpl {
       // Not enough takers, offer to the queue
       const surplus = this.queue.offerAll(remaining);
       unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return isEmpty$1(surplus) ? succeed(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+      return isEmpty$2(surplus) ? succeed(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
     });
   }
   take() {
@@ -353,6 +353,16 @@ class BackPressureStrategy {
   surplusSize() {
     return length(this.putters);
   }
+  onCompleteTakersWithEmptyQueue(takers) {
+    while (!isEmpty$1(this.putters) && !isEmpty$1(takers)) {
+      const taker = poll$1(takers, void 0);
+      const putter = poll$1(this.putters, void 0);
+      if (putter[2]) {
+        unsafeCompleteDeferred(putter[1], true);
+      }
+      unsafeCompleteDeferred(taker, putter[0]);
+    }
+  }
   shutdown() {
     return pipe(fiberId, flatMap(fiberId => pipe(sync(() => unsafePollAll(this.putters)), flatMap(putters => forEachParUnboundedDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? pipe(deferredInterruptWith(deferred, fiberId), asUnit) : unit, false)))));
   }
@@ -385,17 +395,12 @@ class BackPressureStrategy {
     }
   }
   unsafeOffer(iterable, deferred) {
-    const iterator = iterable[Symbol.iterator]();
-    let next = iterator.next();
-    if (!next.done) {
-      // eslint-disable-next-line no-constant-condition
-      while (1) {
-        const value = next.value;
-        next = iterator.next();
-        if (next.done) {
-          pipe(this.putters, offer$1([value, deferred, true]));
-          break;
-        }
+    const stuff = Array.from(iterable);
+    for (let i = 0; i < stuff.length; i++) {
+      const value = stuff[i];
+      if (i === stuff.length - 1) {
+        pipe(this.putters, offer$1([value, deferred, true]));
+      } else {
         pipe(this.putters, offer$1([value, deferred, false]));
       }
     }
@@ -414,6 +419,7 @@ class DroppingStrategy {
   shutdown() {
     return unit;
   }
+  onCompleteTakersWithEmptyQueue() {}
   handleSurplus(_iterable, _queue, _takers, _isShutdown) {
     return succeed(false);
   }
@@ -431,6 +437,7 @@ class SlidingStrategy {
   shutdown() {
     return unit;
   }
+  onCompleteTakersWithEmptyQueue() {}
   handleSurplus(iterable, queue, takers, _isShutdown) {
     return sync(() => {
       this.unsafeOffer(queue, iterable);
@@ -500,6 +507,9 @@ const unsafeCompleteTakers = (strategy, queue, takers) => {
       keepPolling = false;
     }
   }
+  if (keepPolling && queue.length() === 0 && !isEmpty$1(takers)) {
+    strategy.onCompleteTakersWithEmptyQueue(takers);
+  }
 };
 
 export { BackingQueueFromMutableQueue, DequeueTypeId, EnqueueTypeId, QueueStrategyTypeId, awaitShutdown, backPressureStrategy, backingQueueFromMutableQueue, bounded, capacity, dequeueVariance, dropping, droppingStrategy, enqueueVariance, isDequeue, isEmpty, isEnqueue, isFull, isQueue, isShutdown, make, offer, offerAll, poll, shutdown, size, sliding, slidingStrategy, take, takeAll, takeBetween, takeN, takeUpTo, unbounded, unsafeCompleteTakers, unsafeOffer, unsafeRemove };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.46",
+  "version": "2.0.0-next.47",
   "packageManager": "pnpm@8.7.3",
   "publishConfig": {
     "access": "public"

package/src/Queue.ts

@@ -216,6 +216,14 @@ export interface Strategy<A> extends Queue.StrategyVariance<A> {
     isShutdown: MutableRef.MutableRef<boolean>
   ): Effect.Effect<never, never, boolean>
 
+  /**
+   * It is called when the backing queue is empty but there are some
+   * takers that can be completed
+   */
+  onCompleteTakersWithEmptyQueue(
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  ): void
+
   /**
    * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty
    * slots following a `take` operation.

package/src/internal/queue.ts

@@ -513,6 +513,17 @@ class BackPressureStrategy<A> implements Queue.Strategy<A> {
     return MutableQueue.length(this.putters)
   }
 
+  onCompleteTakersWithEmptyQueue(takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>): void {
+    while (!MutableQueue.isEmpty(this.putters) && !MutableQueue.isEmpty(takers)) {
+      const taker = MutableQueue.poll(takers, void 0)!
+      const putter = MutableQueue.poll(this.putters, void 0)!
+      if (putter[2]) {
+        unsafeCompleteDeferred(putter[1], true)
+      }
+      unsafeCompleteDeferred(taker, putter[0])
+    }
+  }
+
   shutdown(): Effect.Effect<never, never, void> {
     return pipe(
       core.fiberId,
@@ -575,17 +586,12 @@ class BackPressureStrategy<A> implements Queue.Strategy<A> {
   }
 
   unsafeOffer(iterable: Iterable<A>, deferred: Deferred.Deferred<never, boolean>): void {
-    const iterator = iterable[Symbol.iterator]()
-    let next: IteratorResult<A> = iterator.next()
-    if (!next.done) {
-      // eslint-disable-next-line no-constant-condition
-      while (1) {
-        const value = next.value
-        next = iterator.next()
-        if (next.done) {
-          pipe(this.putters, MutableQueue.offer([value, deferred, true as boolean] as const))
-          break
-        }
+    const stuff = Array.from(iterable)
+    for (let i = 0; i < stuff.length; i++) {
+      const value = stuff[i]
+      if (i === stuff.length - 1) {
+        pipe(this.putters, MutableQueue.offer([value, deferred, true as boolean] as const))
+      } else {
         pipe(this.putters, MutableQueue.offer([value, deferred, false as boolean] as const))
       }
     }
@@ -611,6 +617,9 @@ class DroppingStrategy<A> implements Queue.Strategy<A> {
     return core.unit
   }
 
+  onCompleteTakersWithEmptyQueue(): void {
+  }
+
   handleSurplus(
     _iterable: Iterable<A>,
     _queue: Queue.BackingQueue<A>,
@@ -640,6 +649,9 @@ class SlidingStrategy<A> implements Queue.Strategy<A> {
     return core.unit
   }
 
+  onCompleteTakersWithEmptyQueue(): void {
+  }
+
   handleSurplus(
     iterable: Iterable<A>,
     queue: Queue.BackingQueue<A>,
@@ -726,4 +738,7 @@ export const unsafeCompleteTakers = <A>(
       keepPolling = false
     }
   }
+  if (keepPolling && queue.length() === 0 && !MutableQueue.isEmpty(takers)) {
+    strategy.onCompleteTakersWithEmptyQueue(takers)
+  }
 }