effect 3.11.10 → 3.12.1

package/dist/esm/internal/stream.js

@@ -33,7 +33,7 @@ import * as MergeStrategy from "./channel/mergeStrategy.js";
 import * as core from "./core-stream.js";
 import * as doNotation from "./doNotation.js";
 import { RingBuffer } from "./ringBuffer.js";
-import * as _sink from "./sink.js";
+import * as sink_ from "./sink.js";
 import * as DebounceState from "./stream/debounceState.js";
 import * as emit from "./stream/emit.js";
 import * as haltStrategy from "./stream/haltStrategy.js";
@@ -128,7 +128,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
     }), channel.unwrap);
     const timeout = lastB => scheduleDriver.next(lastB);
     const scheduledAggregator = (sinkFiber, scheduleFiber, scope) => {
-      const forkSink = pipe(Ref.set(consumed, false), Effect.zipRight(Ref.set(endAfterEmit, false)), Effect.zipRight(pipe(handoffConsumer, channel.pipeToOrFail(_sink.toChannel(sink)), core.collectElements, channel.run, Effect.forkIn(scope))));
+      const forkSink = pipe(Ref.set(consumed, false), Effect.zipRight(Ref.set(endAfterEmit, false)), Effect.zipRight(pipe(handoffConsumer, channel.pipeToOrFail(sink_.toChannel(sink)), core.collectElements, channel.run, Effect.forkIn(scope))));
       const handleSide = (leftovers, b, c) => pipe(Ref.set(sinkLeftovers, Chunk.flatten(leftovers)), Effect.zipRight(Effect.map(Ref.get(sinkEndReason), reason => {
         switch (reason._tag) {
           case SinkEndReason.OP_SCHEDULE_END:
@@ -161,7 +161,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
         })
       }));
     };
-    return unwrapScopedWith(scope => core.pipeTo(toChannel(self), handoffProducer).pipe(channel.run, Effect.forkIn(scope), Effect.zipRight(channel.pipeToOrFail(handoffConsumer, _sink.toChannel(sink)).pipe(core.collectElements, channel.run, Effect.forkIn(scope), Effect.flatMap(sinkFiber => timeout(Option.none()).pipe(Effect.forkIn(scope), Effect.map(scheduleFiber => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))));
+    return unwrapScopedWith(scope => core.pipeTo(toChannel(self), handoffProducer).pipe(channel.run, Effect.forkIn(scope), Effect.zipRight(channel.pipeToOrFail(handoffConsumer, sink_.toChannel(sink)).pipe(core.collectElements, channel.run, Effect.forkIn(scope), Effect.flatMap(sinkFiber => timeout(Option.none()).pipe(Effect.forkIn(scope), Effect.map(scheduleFiber => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))));
   }));
 });
 /** @internal */
@@ -1122,7 +1122,7 @@ export const groupAdjacentBy = /*#__PURE__*/dual(2, (self, f) => {
 /** @internal */
 export const grouped = /*#__PURE__*/dual(2, (self, chunkSize) => pipe(self, rechunk(chunkSize), chunks));
 /** @internal */
-export const groupedWithin = /*#__PURE__*/dual(3, (self, chunkSize, duration) => aggregateWithin(self, _sink.collectAllN(chunkSize), Schedule.spaced(duration)));
+export const groupedWithin = /*#__PURE__*/dual(3, (self, chunkSize, duration) => aggregateWithin(self, sink_.collectAllN(chunkSize), Schedule.spaced(duration)));
 /** @internal */
 export const haltWhen = /*#__PURE__*/dual(2, (self, effect) => {
   const writer = fiber => pipe(Fiber.poll(fiber), Effect.map(Option.match({
@@ -1342,7 +1342,7 @@ export const mergeWith = /*#__PURE__*/dual(3, (self, other, options) => {
   }));
 });
 /** @internal */
-export const mkString = self => run(self, _sink.mkString);
+export const mkString = self => run(self, sink_.mkString);
 /** @internal */
 export const never = /*#__PURE__*/fromEffect(Effect.never);
 /** @internal */
@@ -1415,8 +1415,8 @@ export const peel = /*#__PURE__*/dual(2, (self, sink) => {
   const OP_HALT = "Halt";
   const OP_END = "End";
   return pipe(Deferred.make(), Effect.flatMap(deferred => pipe(Handoff.make(), Effect.map(handoff => {
-    const consumer = _sink.foldSink(_sink.collectLeftover(sink), {
-      onFailure: error => _sink.zipRight(_sink.fromEffect(Deferred.fail(deferred, error)), _sink.fail(error)),
+    const consumer = sink_.foldSink(sink_.collectLeftover(sink), {
+      onFailure: error => sink_.zipRight(sink_.fromEffect(Deferred.fail(deferred, error)), sink_.fail(error)),
       onSuccess: ([z, leftovers]) => {
         const loop = core.readWithCause({
           onInput: elements => core.flatMap(core.fromEffect(Handoff.offer(handoff, {
@@ -1431,7 +1431,7 @@ export const peel = /*#__PURE__*/dual(2, (self, sink) => {
             _tag: OP_END
           })), core.void)
         });
-        return _sink.fromChannel(pipe(core.fromEffect(Deferred.succeed(deferred, z)), channel.zipRight(core.fromEffect(pipe(handoff, Handoff.offer({
+        return sink_.fromChannel(pipe(core.fromEffect(Deferred.succeed(deferred, z)), channel.zipRight(core.fromEffect(pipe(handoff, Handoff.offer({
           _tag: OP_EMIT,
           elements: leftovers
         })))), channel.zipRight(loop)));
@@ -1478,7 +1478,7 @@ export const partitionEither = /*#__PURE__*/dual(args => typeof args[1] === "fun
   onRight: Option.some
 }))]))));
 /** @internal */
-export const pipeThrough = /*#__PURE__*/dual(2, (self, sink) => new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)))));
+export const pipeThrough = /*#__PURE__*/dual(2, (self, sink) => new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(sink_.toChannel(sink)))));
 /** @internal */
 export const pipeThroughChannel = /*#__PURE__*/dual(2, (self, channel) => new StreamImpl(core.pipeTo(toChannel(self), channel)));
 /** @internal */
@@ -1675,13 +1675,13 @@ export const retry = /*#__PURE__*/dual(2, (self, schedule) => Schedule.driver(sc
   return loop;
 }), channel.unwrap, fromChannel));
 /** @internal */
-export const run = /*#__PURE__*/dual(2, (self, sink) => toChannel(self).pipe(channel.pipeToOrFail(_sink.toChannel(sink)), channel.runDrain));
+export const run = /*#__PURE__*/dual(2, (self, sink) => toChannel(self).pipe(channel.pipeToOrFail(sink_.toChannel(sink)), channel.runDrain));
 /** @internal */
-export const runCollect = self => run(self, _sink.collectAll());
+export const runCollect = self => run(self, sink_.collectAll());
 /** @internal */
-export const runCount = self => run(self, _sink.count);
+export const runCount = self => run(self, sink_.count);
 /** @internal */
-export const runDrain = self => run(self, _sink.drain);
+export const runDrain = self => run(self, sink_.drain);
 /** @internal */
 export const runFold = /*#__PURE__*/dual(3, (self, s, f) => runFoldWhile(self, s, constTrue, f));
 /** @internal */
@@ -1691,27 +1691,27 @@ export const runFoldScoped = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, run
 /** @internal */
 export const runFoldScopedEffect = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, runFoldWhileScopedEffect(s, constTrue, f)));
 /** @internal */
-export const runFoldWhile = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, _sink.fold(s, cont, f)));
+export const runFoldWhile = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, sink_.fold(s, cont, f)));
 /** @internal */
-export const runFoldWhileEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, _sink.foldEffect(s, cont, f)));
+export const runFoldWhileEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => run(self, sink_.foldEffect(s, cont, f)));
 /** @internal */
-export const runFoldWhileScoped = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(_sink.fold(s, cont, f))));
+export const runFoldWhileScoped = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(sink_.fold(s, cont, f))));
 /** @internal */
-export const runFoldWhileScopedEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(_sink.foldEffect(s, cont, f))));
+export const runFoldWhileScopedEffect = /*#__PURE__*/dual(4, (self, s, cont, f) => pipe(self, runScoped(sink_.foldEffect(s, cont, f))));
 /** @internal */
-export const runForEach = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEach(f)));
+export const runForEach = /*#__PURE__*/dual(2, (self, f) => run(self, sink_.forEach(f)));
 /** @internal */
-export const runForEachChunk = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEachChunk(f)));
+export const runForEachChunk = /*#__PURE__*/dual(2, (self, f) => run(self, sink_.forEachChunk(f)));
 /** @internal */
-export const runForEachChunkScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEachChunk(f))));
+export const runForEachChunkScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(sink_.forEachChunk(f))));
 /** @internal */
-export const runForEachScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEach(f))));
+export const runForEachScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(sink_.forEach(f))));
 /** @internal */
-export const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => run(self, _sink.forEachWhile(f)));
+export const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => run(self, sink_.forEachWhile(f)));
 /** @internal */
-export const runForEachWhileScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(_sink.forEachWhile(f))));
+export const runForEachWhileScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runScoped(sink_.forEachWhile(f))));
 /** @internal */
-export const runHead = self => run(self, _sink.head());
+export const runHead = self => run(self, sink_.head());
 /** @internal */
 export const runIntoPubSub = /*#__PURE__*/dual(2, (self, pubsub) => pipe(self, runIntoQueue(pubsub)));
 /** @internal */
@@ -1737,11 +1737,11 @@ export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
   return pipe(core.pipeTo(toChannel(self), writer), channel.mapOutEffect(take => Queue.offer(queue, take)), channel.drain, channel.runScoped, Effect.asVoid);
 });
 /** @internal */
-export const runLast = self => run(self, _sink.last());
+export const runLast = self => run(self, sink_.last());
 /** @internal */
-export const runScoped = /*#__PURE__*/dual(2, (self, sink) => pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)), channel.drain, channel.runScoped));
+export const runScoped = /*#__PURE__*/dual(2, (self, sink) => pipe(toChannel(self), channel.pipeToOrFail(sink_.toChannel(sink)), channel.drain, channel.runScoped));
 /** @internal */
-export const runSum = self => run(self, _sink.sum);
+export const runSum = self => run(self, sink_.sum);
 /** @internal */
 export const scan = /*#__PURE__*/dual(3, (self, s, f) => pipe(self, scanEffect(s, (s, a) => Effect.succeed(f(s, a)))));
 /** @internal */
@@ -2198,7 +2198,7 @@ export const transduce = /*#__PURE__*/dual(2, (self, sink) => {
         upstreamDone.ref = true;
       }), core.succeedNow(done))
     });
-    const transducer = pipe(sink, _sink.toChannel, core.collectElements, core.flatMap(([leftover, z]) => pipe(core.succeed([upstreamDone.ref, concatAndGet(leftover)]), core.flatMap(([done, newLeftovers]) => {
+    const transducer = pipe(sink, sink_.toChannel, core.collectElements, core.flatMap(([leftover, z]) => pipe(core.succeed([upstreamDone.ref, concatAndGet(leftover)]), core.flatMap(([done, newLeftovers]) => {
       const nextChannel = done && Chunk.isEmpty(newLeftovers) ? core.void : transducer;
       return pipe(core.write(Chunk.of(z)), core.flatMap(() => nextChannel));
     }))));