@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/stream/emit.ts

@@ -1,123 +0,0 @@
-import * as Cause from "../../Cause.js"
-import * as Chunk from "../../Chunk.js"
-import * as Effect from "../../Effect.js"
-import * as Exit from "../../Exit.js"
-import { pipe } from "../../Function.js"
-import * as Option from "../../Option.js"
-import type * as Queue from "../../Queue.js"
-import type * as Scheduler from "../../Scheduler.js"
-import type * as Emit from "../../StreamEmit.js"
-
-/** @internal */
-export const make = <R, E, A, B>(
-  emit: (f: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>) => Promise<B>
-): Emit.Emit<R, E, A, B> => {
-  const ops: Emit.EmitOps<R, E, A, B> = {
-    chunk(this: Emit.Emit<R, E, A, B>, as: Chunk.Chunk<A>) {
-      return this(Effect.succeed(as))
-    },
-    die<Err>(this: Emit.Emit<R, E, A, B>, defect: Err) {
-      return this(Effect.die(defect))
-    },
-    dieMessage(this: Emit.Emit<R, E, A, B>, message: string) {
-      return this(Effect.dieMessage(message))
-    },
-    done(this: Emit.Emit<R, E, A, B>, exit: Exit.Exit<A, E>) {
-      return this(Effect.suspend(() => Exit.mapBoth(exit, { onFailure: Option.some, onSuccess: Chunk.of })))
-    },
-    end(this: Emit.Emit<R, E, A, B>) {
-      return this(Effect.fail(Option.none()))
-    },
-    fail(this: Emit.Emit<R, E, A, B>, e: E) {
-      return this(Effect.fail(Option.some(e)))
-    },
-    fromEffect(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<A, E, R>) {
-      return this(Effect.mapBoth(effect, { onFailure: Option.some, onSuccess: Chunk.of }))
-    },
-    fromEffectChunk(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<Chunk.Chunk<A>, E, R>) {
-      return this(pipe(effect, Effect.mapError(Option.some)))
-    },
-    halt(this: Emit.Emit<R, E, A, B>, cause: Cause.Cause<E>) {
-      return this(Effect.failCause(pipe(cause, Cause.map(Option.some))))
-    },
-    single(this: Emit.Emit<R, E, A, B>, value: A) {
-      return this(Effect.succeed(Chunk.of(value)))
-    }
-  }
-  return Object.assign(emit, ops)
-}
-
-/** @internal */
-export const makePush = <E, A>(
-  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
-  scheduler: Scheduler.Scheduler
-): Emit.EmitOpsPush<E, A> => {
-  let finished = false
-  let buffer: Array<A> = []
-  let running = false
-  function array(items: ReadonlyArray<A>) {
-    if (finished) return false
-    if (items.length <= 50_000) {
-      buffer.push.apply(buffer, items as Array<A>)
-    } else {
-      for (let i = 0; i < items.length; i++) {
-        buffer.push(items[0])
-      }
-    }
-    if (!running) {
-      running = true
-      scheduler.scheduleTask(flush, 0)
-    }
-    return true
-  }
-  function flush() {
-    running = false
-    if (buffer.length > 0) {
-      queue.unsafeOffer(buffer)
-      buffer = []
-    }
-  }
-  function done(exit: Exit.Exit<A, E>) {
-    if (finished) return
-    finished = true
-    if (exit._tag === "Success") {
-      buffer.push(exit.value)
-    }
-    flush()
-    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
-  }
-  return {
-    single(value: A) {
-      if (finished) return false
-      buffer.push(value)
-      if (!running) {
-        running = true
-        scheduler.scheduleTask(flush, 0)
-      }
-      return true
-    },
-    array,
-    chunk(chunk) {
-      return array(Chunk.toReadonlyArray(chunk))
-    },
-    done,
-    end() {
-      if (finished) return
-      finished = true
-      flush()
-      queue.unsafeOffer(Exit.void)
-    },
-    halt(cause: Cause.Cause<E>) {
-      return done(Exit.failCause(cause))
-    },
-    fail(error: E) {
-      return done(Exit.fail(error))
-    },
-    die<Err>(defect: Err): void {
-      return done(Exit.die(defect))
-    },
-    dieMessage(message: string): void {
-      return done(Exit.die(new Error(message)))
-    }
-  }
-}

package/src/internal/stream/haltStrategy.ts

@@ -1,94 +0,0 @@
-import { dual } from "../../Function.js"
-import type * as HaltStrategy from "../../StreamHaltStrategy.js"
-import * as OpCodes from "../opCodes/streamHaltStrategy.js"
-
-/** @internal */
-export const Left: HaltStrategy.HaltStrategy = {
-  _tag: OpCodes.OP_LEFT
-}
-
-/** @internal */
-export const Right: HaltStrategy.HaltStrategy = {
-  _tag: OpCodes.OP_RIGHT
-}
-
-/** @internal */
-export const Both: HaltStrategy.HaltStrategy = {
-  _tag: OpCodes.OP_BOTH
-}
-
-/** @internal */
-export const Either: HaltStrategy.HaltStrategy = {
-  _tag: OpCodes.OP_EITHER
-}
-
-/** @internal */
-export const fromInput = (input: HaltStrategy.HaltStrategyInput): HaltStrategy.HaltStrategy => {
-  switch (input) {
-    case "left":
-      return Left
-    case "right":
-      return Right
-    case "both":
-      return Both
-    case "either":
-      return Either
-    default:
-      return input
-  }
-}
-
-/** @internal */
-export const isLeft = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Left => self._tag === OpCodes.OP_LEFT
-
-/** @internal */
-export const isRight = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Right => self._tag === OpCodes.OP_RIGHT
-
-/** @internal */
-export const isBoth = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Both => self._tag === OpCodes.OP_BOTH
-
-/** @internal */
-export const isEither = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.Either =>
-  self._tag === OpCodes.OP_EITHER
-
-/** @internal */
-export const match = dual<
-  <Z>(options: {
-    readonly onLeft: () => Z
-    readonly onRight: () => Z
-    readonly onBoth: () => Z
-    readonly onEither: () => Z
-  }) => (self: HaltStrategy.HaltStrategy) => Z,
-  <Z>(
-    self: HaltStrategy.HaltStrategy,
-    options: {
-      readonly onLeft: () => Z
-      readonly onRight: () => Z
-      readonly onBoth: () => Z
-      readonly onEither: () => Z
-    }
-  ) => Z
->(2, <Z>(
-  self: HaltStrategy.HaltStrategy,
-  options: {
-    readonly onLeft: () => Z
-    readonly onRight: () => Z
-    readonly onBoth: () => Z
-    readonly onEither: () => Z
-  }
-): Z => {
-  switch (self._tag) {
-    case OpCodes.OP_LEFT: {
-      return options.onLeft()
-    }
-    case OpCodes.OP_RIGHT: {
-      return options.onRight()
-    }
-    case OpCodes.OP_BOTH: {
-      return options.onBoth()
-    }
-    case OpCodes.OP_EITHER: {
-      return options.onEither()
-    }
-  }
-})

package/src/internal/stream/handoff.ts

@@ -1,187 +0,0 @@
-import * as Deferred from "../../Deferred.js"
-import * as Effect from "../../Effect.js"
-import { dual, pipe } from "../../Function.js"
-import * as Option from "../../Option.js"
-import * as Ref from "../../Ref.js"
-
-/** @internal */
-export const HandoffTypeId = Symbol.for("effect/Stream/Handoff")
-
-/** @internal */
-export type HandoffTypeId = typeof HandoffTypeId
-
-/**
- * A synchronous queue-like abstraction that allows a producer to offer an
- * element and wait for it to be taken, and allows a consumer to wait for an
- * element to be available.
- *
- * @internal
- */
-export interface Handoff<in out A> extends Handoff.Variance<A> {
-  readonly ref: Ref.Ref<Handoff.State<A>>
-}
-
-/** @internal */
-export const OP_HANDOFF_STATE_EMPTY = "Empty" as const
-
-/** @internal */
-export type OP_HANDOFF_STATE_EMPTY = typeof OP_HANDOFF_STATE_EMPTY
-
-/** @internal */
-export const OP_HANDOFF_STATE_FULL = "Full" as const
-
-/** @internal */
-export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL
-
-/** @internal */
-export declare namespace Handoff {
-  /** @internal */
-  export interface Variance<in out A> {
-    readonly [HandoffTypeId]: {
-      readonly _A: (_: A) => A
-    }
-  }
-
-  /** @internal */
-  export type State<A> = Empty | Full<A>
-
-  /** @internal */
-  export interface Empty {
-    readonly _tag: OP_HANDOFF_STATE_EMPTY
-    readonly notifyConsumer: Deferred.Deferred<void>
-  }
-
-  /** @internal */
-  export interface Full<out A> {
-    readonly _tag: OP_HANDOFF_STATE_FULL
-    readonly value: A
-    readonly notifyProducer: Deferred.Deferred<void>
-  }
-}
-
-/** @internal */
-const handoffStateEmpty = <A>(notifyConsumer: Deferred.Deferred<void>): Handoff.State<A> => ({
-  _tag: OP_HANDOFF_STATE_EMPTY,
-  notifyConsumer
-})
-
-/** @internal */
-const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<void>): Handoff.State<A> => ({
-  _tag: OP_HANDOFF_STATE_FULL,
-  value,
-  notifyProducer
-})
-
-/** @internal */
-const handoffStateMatch = <A, Z>(
-  onEmpty: (notifyConsumer: Deferred.Deferred<void>) => Z,
-  onFull: (value: A, notifyProducer: Deferred.Deferred<void>) => Z
-) => {
-  return (self: Handoff.State<A>): Z => {
-    switch (self._tag) {
-      case OP_HANDOFF_STATE_EMPTY: {
-        return onEmpty(self.notifyConsumer)
-      }
-      case OP_HANDOFF_STATE_FULL: {
-        return onFull(self.value, self.notifyProducer)
-      }
-    }
-  }
-}
-
-const handoffVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-/** @internal */
-export const make = <A>(): Effect.Effect<Handoff<A>> =>
-  pipe(
-    Deferred.make<void>(),
-    Effect.flatMap((deferred) => Ref.make(handoffStateEmpty<A>(deferred))),
-    Effect.map((ref): Handoff<A> => ({
-      [HandoffTypeId]: handoffVariance,
-      ref
-    }))
-  )
-
-/** @internal */
-export const offer = dual<
-  <A>(value: A) => (self: Handoff<A>) => Effect.Effect<void>,
-  <A>(self: Handoff<A>, value: A) => Effect.Effect<void>
->(2, (self, value): Effect.Effect<void> => {
-  return Effect.flatMap(Deferred.make<void>(), (deferred) =>
-    Effect.flatten(
-      Ref.modify(self.ref, (state) =>
-        pipe(
-          state,
-          handoffStateMatch(
-            (notifyConsumer) => [
-              Effect.zipRight(
-                Deferred.succeed(notifyConsumer, void 0),
-                Deferred.await(deferred)
-              ),
-              handoffStateFull(value, deferred)
-            ],
-            (_, notifyProducer) => [
-              Effect.flatMap(
-                Deferred.await(notifyProducer),
-                () => pipe(self, offer(value))
-              ),
-              state
-            ]
-          )
-        ))
-    ))
-})
-
-/** @internal */
-export const take = <A>(self: Handoff<A>): Effect.Effect<A> =>
-  Effect.flatMap(Deferred.make<void>(), (deferred) =>
-    Effect.flatten(
-      Ref.modify(self.ref, (state) =>
-        pipe(
-          state,
-          handoffStateMatch(
-            (notifyConsumer) =>
-              [
-                Effect.flatMap(
-                  Deferred.await(notifyConsumer),
-                  () => take(self)
-                ),
-                state
-              ] as const,
-            (value, notifyProducer) => [
-              Effect.as(
-                Deferred.succeed(notifyProducer, void 0),
-                value
-              ),
-              handoffStateEmpty<A>(deferred)
-            ]
-          )
-        ))
-    ))
-
-/** @internal */
-export const poll = <A>(self: Handoff<A>): Effect.Effect<Option.Option<A>> =>
-  Effect.flatMap(Deferred.make<void>(), (deferred) =>
-    Effect.flatten(
-      Ref.modify(self.ref, (state) =>
-        pipe(
-          state,
-          handoffStateMatch(
-            () =>
-              [
-                Effect.succeed(Option.none<A>()),
-                state
-              ] as const,
-            (value, notifyProducer) => [
-              Effect.as(
-                Deferred.succeed(notifyProducer, void 0),
-                Option.some(value)
-              ),
-              handoffStateEmpty<A>(deferred)
-            ]
-          )
-        ))
-    ))

package/src/internal/stream/handoffSignal.ts

@@ -1,59 +0,0 @@
-import type * as Cause from "../../Cause.js"
-import type * as Chunk from "../../Chunk.js"
-import type * as SinkEndReason from "./sinkEndReason.js"
-
-/** @internal */
-export type HandoffSignal<A, E = never> = Emit<A> | Halt<E> | End
-
-/** @internal */
-export const OP_EMIT = "Emit" as const
-
-/** @internal */
-export type OP_EMIT = typeof OP_EMIT
-
-/** @internal */
-export const OP_HALT = "Halt" as const
-
-/** @internal */
-export type OP_HALT = typeof OP_HALT
-
-/** @internal */
-export const OP_END = "End" as const
-
-/** @internal */
-export type OP_END = typeof OP_END
-
-export interface Emit<out A> {
-  readonly _tag: OP_EMIT
-  readonly elements: Chunk.Chunk<A>
-}
-
-/** @internal */
-export interface Halt<out E> {
-  readonly _tag: OP_HALT
-  readonly cause: Cause.Cause<E>
-}
-
-/** @internal */
-export interface End {
-  readonly _tag: OP_END
-  readonly reason: SinkEndReason.SinkEndReason
-}
-
-/** @internal */
-export const emit = <A>(elements: Chunk.Chunk<A>): HandoffSignal<A> => ({
-  _tag: OP_EMIT,
-  elements
-})
-
-/** @internal */
-export const halt = <E>(cause: Cause.Cause<E>): HandoffSignal<never, E> => ({
-  _tag: OP_HALT,
-  cause
-})
-
-/** @internal */
-export const end = (reason: SinkEndReason.SinkEndReason): HandoffSignal<never> => ({
-  _tag: OP_END,
-  reason
-})

package/src/internal/stream/pull.ts

@@ -1,34 +0,0 @@
-import type * as Cause from "../../Cause.js"
-import * as Chunk from "../../Chunk.js"
-import * as Effect from "../../Effect.js"
-import * as Option from "../../Option.js"
-import * as Queue from "../../Queue.js"
-import type * as Take from "../../Take.js"
-import * as take from "../take.js"
-
-/** @internal */
-export interface Pull<out R, out E, out A> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
-
-/** @internal */
-export const emit = <A>(value: A): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))
-
-/** @internal */
-export const emitChunk = <A>(chunk: Chunk.Chunk<A>): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(chunk)
-
-/** @internal */
-export const empty = <A>(): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.empty<A>())
-
-/** @internal */
-export const end = (): Effect.Effect<never, Option.Option<never>> => Effect.fail(Option.none())
-
-/** @internal */
-export const fail = <E>(error: E): Effect.Effect<never, Option.Option<E>> => Effect.fail(Option.some(error))
-
-/** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Effect.Effect<never, Option.Option<E>> =>
-  Effect.mapError(Effect.failCause(cause), Option.some)
-
-/** @internal */
-export const fromDequeue = <A, E>(
-  dequeue: Queue.Dequeue<Take.Take<A, E>>
-): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> => Effect.flatMap(Queue.take(dequeue), take.done)

package/src/internal/stream/sinkEndReason.ts

@@ -1,30 +0,0 @@
-/** @internal */
-export type SinkEndReason = ScheduleEnd | UpstreamEnd
-
-/** @internal */
-export const OP_SCHEDULE_END = "ScheduleEnd" as const
-
-/** @internal */
-export type OP_SCHEDULE_END = typeof OP_SCHEDULE_END
-
-/** @internal */
-export const OP_UPSTREAM_END = "UpstreamEnd" as const
-
-/** @internal */
-export type OP_UPSTREAM_END = typeof OP_UPSTREAM_END
-
-/** @internal */
-export interface ScheduleEnd {
-  readonly _tag: OP_SCHEDULE_END
-}
-
-/** @internal */
-export interface UpstreamEnd {
-  readonly _tag: OP_UPSTREAM_END
-}
-
-/** @internal */
-export const ScheduleEnd: SinkEndReason = { _tag: OP_SCHEDULE_END }
-
-/** @internal */
-export const UpstreamEnd: SinkEndReason = { _tag: OP_UPSTREAM_END }

package/src/internal/stream/zipAllState.ts

@@ -1,88 +0,0 @@
-import type * as Chunk from "../../Chunk.js"
-
-/** @internal */
-export type ZipAllState<A, A2> = DrainLeft | DrainRight | PullBoth | PullLeft<A2> | PullRight<A>
-
-/** @internal */
-export const OP_DRAIN_LEFT = "DrainLeft" as const
-
-/** @internal */
-export type OP_DRAIN_LEFT = typeof OP_DRAIN_LEFT
-
-/** @internal */
-export const OP_DRAIN_RIGHT = "DrainRight" as const
-
-/** @internal */
-export type OP_DRAIN_RIGHT = typeof OP_DRAIN_RIGHT
-
-/** @internal */
-export const OP_PULL_BOTH = "PullBoth" as const
-
-/** @internal */
-export type OP_PULL_BOTH = typeof OP_PULL_BOTH
-
-/** @internal */
-export const OP_PULL_LEFT = "PullLeft" as const
-
-/** @internal */
-export type OP_PULL_LEFT = typeof OP_PULL_LEFT
-
-/** @internal */
-export const OP_PULL_RIGHT = "PullRight" as const
-
-/** @internal */
-export type OP_PULL_RIGHT = typeof OP_PULL_RIGHT
-
-/** @internal */
-export interface DrainLeft {
-  readonly _tag: OP_DRAIN_LEFT
-}
-
-/** @internal */
-export interface DrainRight {
-  readonly _tag: OP_DRAIN_RIGHT
-}
-
-/** @internal */
-export interface PullBoth {
-  readonly _tag: OP_PULL_BOTH
-}
-
-/** @internal */
-export interface PullLeft<A> {
-  readonly _tag: OP_PULL_LEFT
-  readonly rightChunk: Chunk.Chunk<A>
-}
-
-/** @internal */
-export interface PullRight<A> {
-  readonly _tag: OP_PULL_RIGHT
-  readonly leftChunk: Chunk.Chunk<A>
-}
-
-/** @internal */
-export const DrainLeft: ZipAllState<never, never> = {
-  _tag: OP_DRAIN_LEFT
-}
-
-/** @internal */
-export const DrainRight: ZipAllState<never, never> = {
-  _tag: OP_DRAIN_RIGHT
-}
-
-/** @internal */
-export const PullBoth: ZipAllState<never, never> = {
-  _tag: OP_PULL_BOTH
-}
-
-/** @internal */
-export const PullLeft = <A>(rightChunk: Chunk.Chunk<A>): ZipAllState<never, A> => ({
-  _tag: OP_PULL_LEFT,
-  rightChunk
-})
-
-/** @internal */
-export const PullRight = <A>(leftChunk: Chunk.Chunk<A>): ZipAllState<A, never> => ({
-  _tag: OP_PULL_RIGHT,
-  leftChunk
-})

package/src/internal/stream/zipChunksState.ts

@@ -1,56 +0,0 @@
-import type * as Chunk from "../../Chunk.js"
-
-/** @internal */
-export type ZipChunksState<A, A2> = PullBoth | PullLeft<A2> | PullRight<A>
-
-/** @internal */
-export const OP_PULL_BOTH = "PullBoth" as const
-
-/** @internal */
-export type OP_PULL_BOTH = typeof OP_PULL_BOTH
-
-/** @internal */
-export const OP_PULL_LEFT = "PullLet" as const
-
-/** @internal */
-export type OP_PULL_LEFT = typeof OP_PULL_LEFT
-
-/** @internal */
-export const OP_PULL_RIGHT = "PullRight" as const
-
-/** @internal */
-export type OP_PULL_RIGHT = typeof OP_PULL_RIGHT
-
-/** @internal */
-export interface PullBoth {
-  readonly _tag: OP_PULL_BOTH
-}
-
-/** @internal */
-export interface PullLeft<A> {
-  readonly _tag: OP_PULL_LEFT
-  readonly rightChunk: Chunk.Chunk<A>
-}
-
-/** @internal */
-export interface PullRight<A> {
-  readonly _tag: OP_PULL_RIGHT
-  readonly leftChunk: Chunk.Chunk<A>
-}
-
-/** @internal */
-export const PullBoth: ZipChunksState<never, never> = {
-  _tag: OP_PULL_BOTH
-}
-
-/** @internal */
-export const PullLeft = <A>(rightChunk: Chunk.Chunk<A>): ZipChunksState<never, A> => ({
-  _tag: OP_PULL_LEFT,
-  rightChunk
-})
-
-/** @internal */
-export const PullRight = <A>(leftChunk: Chunk.Chunk<A>): ZipChunksState<A, never> => ({
-  _tag: OP_PULL_RIGHT,
-  leftChunk
-})