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

package/src/internal/encoding/hex.ts

@@ -1,315 +0,0 @@
-import * as Either from "../../Either.js"
-import type * as Encoding from "../../Encoding.js"
-import { DecodeException } from "./common.js"
-
-/** @internal */
-export const encode = (bytes: Uint8Array) => {
-  let result = ""
-  for (let i = 0; i < bytes.length; ++i) {
-    result += bytesToHex[bytes[i]]
-  }
-
-  return result
-}
-
-/** @internal */
-export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
-  const bytes = new TextEncoder().encode(str)
-  if (bytes.length % 2 !== 0) {
-    return Either.left(DecodeException(str, `Length must be a multiple of 2, but is ${bytes.length}`))
-  }
-
-  try {
-    const length = bytes.length / 2
-    const result = new Uint8Array(length)
-    for (let i = 0; i < length; i++) {
-      const a = fromHexChar(bytes[i * 2])
-      const b = fromHexChar(bytes[i * 2 + 1])
-      result[i] = (a << 4) | b
-    }
-
-    return Either.right(result)
-  } catch (e) {
-    return Either.left(DecodeException(str, e instanceof Error ? e.message : "Invalid input"))
-  }
-}
-
-/** @internal */
-const bytesToHex = [
-  "00",
-  "01",
-  "02",
-  "03",
-  "04",
-  "05",
-  "06",
-  "07",
-  "08",
-  "09",
-  "0a",
-  "0b",
-  "0c",
-  "0d",
-  "0e",
-  "0f",
-  "10",
-  "11",
-  "12",
-  "13",
-  "14",
-  "15",
-  "16",
-  "17",
-  "18",
-  "19",
-  "1a",
-  "1b",
-  "1c",
-  "1d",
-  "1e",
-  "1f",
-  "20",
-  "21",
-  "22",
-  "23",
-  "24",
-  "25",
-  "26",
-  "27",
-  "28",
-  "29",
-  "2a",
-  "2b",
-  "2c",
-  "2d",
-  "2e",
-  "2f",
-  "30",
-  "31",
-  "32",
-  "33",
-  "34",
-  "35",
-  "36",
-  "37",
-  "38",
-  "39",
-  "3a",
-  "3b",
-  "3c",
-  "3d",
-  "3e",
-  "3f",
-  "40",
-  "41",
-  "42",
-  "43",
-  "44",
-  "45",
-  "46",
-  "47",
-  "48",
-  "49",
-  "4a",
-  "4b",
-  "4c",
-  "4d",
-  "4e",
-  "4f",
-  "50",
-  "51",
-  "52",
-  "53",
-  "54",
-  "55",
-  "56",
-  "57",
-  "58",
-  "59",
-  "5a",
-  "5b",
-  "5c",
-  "5d",
-  "5e",
-  "5f",
-  "60",
-  "61",
-  "62",
-  "63",
-  "64",
-  "65",
-  "66",
-  "67",
-  "68",
-  "69",
-  "6a",
-  "6b",
-  "6c",
-  "6d",
-  "6e",
-  "6f",
-  "70",
-  "71",
-  "72",
-  "73",
-  "74",
-  "75",
-  "76",
-  "77",
-  "78",
-  "79",
-  "7a",
-  "7b",
-  "7c",
-  "7d",
-  "7e",
-  "7f",
-  "80",
-  "81",
-  "82",
-  "83",
-  "84",
-  "85",
-  "86",
-  "87",
-  "88",
-  "89",
-  "8a",
-  "8b",
-  "8c",
-  "8d",
-  "8e",
-  "8f",
-  "90",
-  "91",
-  "92",
-  "93",
-  "94",
-  "95",
-  "96",
-  "97",
-  "98",
-  "99",
-  "9a",
-  "9b",
-  "9c",
-  "9d",
-  "9e",
-  "9f",
-  "a0",
-  "a1",
-  "a2",
-  "a3",
-  "a4",
-  "a5",
-  "a6",
-  "a7",
-  "a8",
-  "a9",
-  "aa",
-  "ab",
-  "ac",
-  "ad",
-  "ae",
-  "af",
-  "b0",
-  "b1",
-  "b2",
-  "b3",
-  "b4",
-  "b5",
-  "b6",
-  "b7",
-  "b8",
-  "b9",
-  "ba",
-  "bb",
-  "bc",
-  "bd",
-  "be",
-  "bf",
-  "c0",
-  "c1",
-  "c2",
-  "c3",
-  "c4",
-  "c5",
-  "c6",
-  "c7",
-  "c8",
-  "c9",
-  "ca",
-  "cb",
-  "cc",
-  "cd",
-  "ce",
-  "cf",
-  "d0",
-  "d1",
-  "d2",
-  "d3",
-  "d4",
-  "d5",
-  "d6",
-  "d7",
-  "d8",
-  "d9",
-  "da",
-  "db",
-  "dc",
-  "dd",
-  "de",
-  "df",
-  "e0",
-  "e1",
-  "e2",
-  "e3",
-  "e4",
-  "e5",
-  "e6",
-  "e7",
-  "e8",
-  "e9",
-  "ea",
-  "eb",
-  "ec",
-  "ed",
-  "ee",
-  "ef",
-  "f0",
-  "f1",
-  "f2",
-  "f3",
-  "f4",
-  "f5",
-  "f6",
-  "f7",
-  "f8",
-  "f9",
-  "fa",
-  "fb",
-  "fc",
-  "fd",
-  "fe",
-  "ff"
-]
-
-/** @internal */
-const fromHexChar = (byte: number) => {
-  // '0' <= byte && byte <= '9'
-  if (48 <= byte && byte <= 57) {
-    return byte - 48
-  }
-
-  // 'a' <= byte && byte <= 'f'
-  if (97 <= byte && byte <= 102) {
-    return byte - 97 + 10
-  }
-
-  // 'A' <= byte && byte <= 'F'
-  if (65 <= byte && byte <= 70) {
-    return byte - 65 + 10
-  }
-
-  throw new TypeError("Invalid input")
-}

package/src/internal/errors.ts

@@ -1,7 +0,0 @@
-/**
- * @since 2.0.0
- */
-
-/** @internal */
-export const getBugErrorMessage = (message: string) =>
-  `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`

package/src/internal/executionPlan.ts

@@ -1,114 +0,0 @@
-import type { Effect } from "../Effect.js"
-import * as Either from "../Either.js"
-import type * as Api from "../ExecutionPlan.js"
-import { dual } from "../Function.js"
-import * as Predicate from "../Predicate.js"
-import * as core from "./core.js"
-import * as layer from "./layer.js"
-import * as InternalSchedule from "./schedule.js"
-
-/** @internal */
-export const TypeId: Api.TypeId = Symbol.for("effect/ExecutionPlan") as Api.TypeId
-
-/** @internal */
-export const isExecutionPlan = (u: unknown): u is Api.ExecutionPlan<any> => Predicate.hasProperty(u, TypeId)
-
-/** @internal */
-export const withExecutionPlan: {
-  <Input, Provides, PlanE, PlanR>(
-    plan: Api.ExecutionPlan<{
-      provides: Provides
-      input: Input
-      error: PlanE
-      requirements: PlanR
-    }>
-  ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
-    A,
-    E | PlanE,
-    Exclude<R, Provides> | PlanR
-  >
-  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
-    effect: Effect<A, E, R>,
-    plan: Api.ExecutionPlan<{
-      provides: Provides
-      input: Input
-      error: PlanE
-      requirements: PlanR
-    }>
-  ): Effect<
-    A,
-    E | PlanE,
-    Exclude<R, Provides> | PlanR
-  >
-} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
-  effect: Effect<A, E, R>,
-  plan: Api.ExecutionPlan<{
-    provides: Provides
-    input: Input
-    error: PlanE
-    requirements: PlanR
-  }>
-) =>
-  core.suspend(() => {
-    let i = 0
-    let result: Either.Either<A, any> | undefined
-    return core.flatMap(
-      core.whileLoop({
-        while: () => i < plan.steps.length && (result === undefined || Either.isLeft(result)),
-        body: () => {
-          const step = plan.steps[i]
-          let nextEffect: Effect<A, any, any> = layer.effect_provide(effect, step.provide as any)
-          if (result) {
-            let attempted = false
-            const wrapped = nextEffect
-            // ensure the schedule is applied at least once
-            nextEffect = core.suspend(() => {
-              if (attempted) return wrapped
-              attempted = true
-              return result!
-            })
-            nextEffect = InternalSchedule.scheduleDefectRefail(
-              InternalSchedule.retry_Effect(nextEffect, scheduleFromStep(step, false)!)
-            )
-          } else {
-            const schedule = scheduleFromStep(step, true)
-            nextEffect = schedule
-              ? InternalSchedule.scheduleDefectRefail(InternalSchedule.retry_Effect(nextEffect, schedule))
-              : nextEffect
-          }
-          return core.either(nextEffect)
-        },
-        step: (either) => {
-          result = either
-          i++
-        }
-      }),
-      () => result!
-    )
-  }))
-
-/** @internal */
-export const scheduleFromStep = <Provides, In, PlanE, PlanR>(
-  step: Api.ExecutionPlan<{
-    provides: Provides
-    input: In
-    error: PlanE
-    requirements: PlanR
-  }>["steps"][number],
-  first: boolean
-) => {
-  if (!first) {
-    return InternalSchedule.fromRetryOptions({
-      schedule: step.schedule ? step.schedule : step.attempts ? undefined : InternalSchedule.once,
-      times: step.attempts,
-      while: step.while
-    })
-  } else if (step.attempts === 1 || !(step.schedule || step.attempts)) {
-    return undefined
-  }
-  return InternalSchedule.fromRetryOptions({
-    schedule: step.schedule,
-    while: step.while,
-    times: step.attempts ? step.attempts - 1 : undefined
-  })
-}

package/src/internal/executionStrategy.ts

@@ -1,74 +0,0 @@
-import type * as ExecutionStrategy from "../ExecutionStrategy.js"
-import { dual } from "../Function.js"
-import type { LazyArg } from "../Function.js"
-
-/** @internal */
-export const OP_SEQUENTIAL = "Sequential" as const
-
-/** @internal */
-export type OP_SEQUENTIAL = typeof OP_SEQUENTIAL
-
-/** @internal */
-export const OP_PARALLEL = "Parallel" as const
-
-/** @internal */
-export type OP_PARALLEL = typeof OP_PARALLEL
-
-/** @internal */
-export const OP_PARALLEL_N = "ParallelN" as const
-
-/** @internal */
-export type OP_PARALLEL_N = typeof OP_PARALLEL_N
-
-/** @internal */
-export const sequential: ExecutionStrategy.ExecutionStrategy = { _tag: OP_SEQUENTIAL }
-
-/** @internal */
-export const parallel: ExecutionStrategy.ExecutionStrategy = { _tag: OP_PARALLEL }
-
-/** @internal */
-export const parallelN = (parallelism: number): ExecutionStrategy.ExecutionStrategy => ({
-  _tag: OP_PARALLEL_N,
-  parallelism
-})
-
-/** @internal */
-export const isSequential = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.Sequential =>
-  self._tag === OP_SEQUENTIAL
-
-/** @internal */
-export const isParallel = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.Parallel =>
-  self._tag === OP_PARALLEL
-
-/** @internal */
-export const isParallelN = (self: ExecutionStrategy.ExecutionStrategy): self is ExecutionStrategy.ParallelN =>
-  self._tag === OP_PARALLEL_N
-
-/** @internal */
-export const match = dual<
-  <A>(options: {
-    readonly onSequential: LazyArg<A>
-    readonly onParallel: LazyArg<A>
-    readonly onParallelN: (n: number) => A
-  }) => (self: ExecutionStrategy.ExecutionStrategy) => A,
-  <A>(
-    self: ExecutionStrategy.ExecutionStrategy,
-    options: {
-      readonly onSequential: LazyArg<A>
-      readonly onParallel: LazyArg<A>
-      readonly onParallelN: (n: number) => A
-    }
-  ) => A
->(2, (self, options) => {
-  switch (self._tag) {
-    case OP_SEQUENTIAL: {
-      return options.onSequential()
-    }
-    case OP_PARALLEL: {
-      return options.onParallel()
-    }
-    case OP_PARALLEL_N: {
-      return options.onParallelN(self.parallelism)
-    }
-  }
-})