effect 3.4.9 → 3.5.1

package/dist/esm/internal/stream.js

@@ -163,8 +163,23 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
 });
 /** @internal */
 export const as = /*#__PURE__*/dual(2, (self, value) => map(self, () => value));
+const queueFromBufferOptions = bufferSize => {
+  if (bufferSize === "unbounded") {
+    return Queue.unbounded();
+  } else if (typeof bufferSize === "number" || bufferSize === undefined) {
+    return Queue.bounded(bufferSize ?? 16);
+  }
+  switch (bufferSize.strategy) {
+    case "dropping":
+      return Queue.dropping(bufferSize.bufferSize ?? 16);
+    case "sliding":
+      return Queue.sliding(bufferSize.bufferSize ?? 16);
+    default:
+      return Queue.bounded(bufferSize.bufferSize ?? 16);
+  }
+};
 /** @internal */
-export const _async = (register, outputBuffer = 16) => Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)).pipe(Effect.flatMap(output => Effect.runtime().pipe(Effect.flatMap(runtime => Effect.sync(() => {
+export const _async = (register, bufferSize) => Effect.acquireRelease(queueFromBufferOptions(bufferSize), queue => Queue.shutdown(queue)).pipe(Effect.flatMap(output => Effect.runtime().pipe(Effect.flatMap(runtime => Effect.sync(() => {
   const runPromiseExit = Runtime.runPromiseExit(runtime);
   const canceler = register(emit.make(resume => InternalTake.fromPull(resume).pipe(Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, runPromiseExit).then(exit => {
     if (Exit.isFailure(exit)) {
@@ -185,7 +200,7 @@ export const _async = (register, outputBuffer = 16) => Effect.acquireRelease(Que
   return fromChannel(loop).pipe(ensuring(value ?? Effect.void));
 }))), unwrapScoped);
 /** @internal */
-export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
+export const asyncEffect = (register, bufferSize) => pipe(Effect.acquireRelease(queueFromBufferOptions(bufferSize), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
@@ -202,7 +217,7 @@ export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireR
   return loop;
 }))))), channel.unwrapScoped, fromChannel);
 /** @internal */
-export const asyncScoped = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
+export const asyncScoped = (register, bufferSize) => pipe(Effect.acquireRelease(queueFromBufferOptions(bufferSize), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
@@ -231,9 +246,9 @@ export const broadcast = /*#__PURE__*/dual(3, (self, n, maximumLag) => pipe(self
   shutdown: true
 }))))));
 /** @internal */
-export const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => pipe(self, broadcastedQueuesDynamic(maximumLag), Effect.map(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
+export const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => Effect.map(toPubSub(self, maximumLag), pubsub => flattenTake(fromPubSub(pubsub))));
 /** @internal */
-export const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => Effect.flatMap(PubSub.bounded(maximumLag), pubsub => pipe(Effect.all(Array.from({
+export const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => Effect.flatMap(pubsubFromOptions(maximumLag), pubsub => pipe(Effect.all(Array.from({
   length: n
 }, () => PubSub.subscribe(pubsub))), Effect.tap(() => Effect.forkScoped(runIntoPubSubScoped(self, pubsub))))));
 /** @internal */
@@ -1269,9 +1284,9 @@ export const mergeEither = /*#__PURE__*/dual(2, (self, that) => mergeWith(self,
   onOther: Either.right
 }));
 /** @internal */
-export const mergeLeft = /*#__PURE__*/dual(2, (self, that) => pipe(self, merge(drain(that))));
+export const mergeLeft = /*#__PURE__*/dual(2, (left, right) => pipe(left, merge(drain(right))));
 /** @internal */
-export const mergeRight = /*#__PURE__*/dual(2, (self, that) => pipe(drain(self), merge(that)));
+export const mergeRight = /*#__PURE__*/dual(2, (left, right) => pipe(drain(left), merge(right)));
 /** @internal */
 export const mergeWith = /*#__PURE__*/dual(3, (self, other, options) => {
   const strategy = options.haltStrategy ? haltStrategy.fromInput(options.haltStrategy) : HaltStrategy.Both;
@@ -1454,6 +1469,19 @@ export const range = (min, max, chunkSize = DefaultChunkSize) => suspend(() => {
   };
   return new StreamImpl(go(min, max, chunkSize));
 });
+export const raceAll = (...streams) => Deferred.make().pipe(Effect.map(halt => {
+  let winner = null;
+  return mergeAll(streams.map((stream, index) => stream.pipe(takeWhile(() => {
+    if (winner === null) {
+      winner = index;
+      Deferred.unsafeDone(halt, Exit.void);
+      return true;
+    }
+    return winner === index;
+  }), interruptWhen(Deferred.await(halt).pipe(Effect.flatMap(() => winner === index ? Effect.never : Effect.void))))), {
+    concurrency: streams.length
+  });
+}), unwrap);
 /** @internal */
 export const rechunk = /*#__PURE__*/dual(2, (self, n) => suspend(() => {
   const target = Math.max(n, 1);
@@ -2016,8 +2044,25 @@ export const timeoutTo = /*#__PURE__*/dual(3, (self, duration, that) => {
   const StreamTimeout = new Cause.RuntimeException("Stream Timeout");
   return pipe(self, timeoutFailCause(() => Cause.die(StreamTimeout), duration), catchSomeCause(cause => Cause.isDieType(cause) && Cause.isRuntimeException(cause.defect) && cause.defect.message !== undefined && cause.defect.message === "Stream Timeout" ? Option.some(that) : Option.none()));
 });
+const pubsubFromOptions = options => {
+  if (typeof options === "number") {
+    return PubSub.bounded(options);
+  } else if (options.capacity === "unbounded") {
+    return PubSub.unbounded({
+      replay: options.replay
+    });
+  }
+  switch (options.strategy) {
+    case "dropping":
+      return PubSub.dropping(options);
+    case "sliding":
+      return PubSub.sliding(options);
+    default:
+      return PubSub.bounded(options);
+  }
+};
 /** @internal */
-export const toPubSub = /*#__PURE__*/dual(2, (self, capacity) => pipe(Effect.acquireRelease(PubSub.bounded(capacity), pubsub => PubSub.shutdown(pubsub)), Effect.tap(pubsub => pipe(self, runIntoPubSubScoped(pubsub), Effect.forkScoped))));
+export const toPubSub = /*#__PURE__*/dual(2, (self, capacity) => pipe(Effect.acquireRelease(pubsubFromOptions(capacity), pubsub => PubSub.shutdown(pubsub)), Effect.tap(pubsub => pipe(self, runIntoPubSubScoped(pubsub), Effect.forkScoped))));
 /** @internal */
 export const toPull = self => Effect.map(channel.toPull(toChannel(self)), pull => pipe(pull, Effect.mapError(Option.some), Effect.flatMap(Either.match({
   onLeft: () => Effect.fail(Option.none()),