@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/internal/effectable.ts

@@ -0,0 +1,131 @@
+import type * as Channel from "../Channel.js"
+import type * as Effect from "../Effect.js"
+import type * as Effectable from "../Effectable.js"
+import * as Equal from "../Equal.js"
+import * as Hash from "../Hash.js"
+import { pipeArguments } from "../Pipeable.js"
+import type * as Sink from "../Sink.js"
+import type * as Stream from "../Stream.js"
+import { SingleShotGen, YieldWrap } from "../Utils.js"
+import * as OpCodes from "./opCodes/effect.js"
+import * as version from "./version.js"
+
+/** @internal */
+export const EffectTypeId: Effect.EffectTypeId = Symbol.for("effect/Effect") as Effect.EffectTypeId
+
+/** @internal */
+export const StreamTypeId: Stream.StreamTypeId = Symbol.for("effect/Stream") as Stream.StreamTypeId
+
+/** @internal */
+export const SinkTypeId: Sink.SinkTypeId = Symbol.for("effect/Sink") as Sink.SinkTypeId
+
+/** @internal */
+export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for("effect/Channel") as Channel.ChannelTypeId
+
+/** @internal */
+export const effectVariance = {
+  /* c8 ignore next */
+  _R: (_: never) => _,
+  /* c8 ignore next */
+  _E: (_: never) => _,
+  /* c8 ignore next */
+  _A: (_: never) => _,
+
+  _V: version.getCurrentVersion()
+}
+
+const sinkVariance = {
+  /* c8 ignore next */
+  _A: (_: never) => _,
+  /* c8 ignore next */
+  _In: (_: unknown) => _,
+  /* c8 ignore next */
+  _L: (_: never) => _,
+  /* c8 ignore next */
+  _E: (_: never) => _,
+  /* c8 ignore next */
+  _R: (_: never) => _
+}
+
+const channelVariance = {
+  /* c8 ignore next */
+  _Env: (_: never) => _,
+  /* c8 ignore next */
+  _InErr: (_: unknown) => _,
+  /* c8 ignore next */
+  _InElem: (_: unknown) => _,
+  /* c8 ignore next */
+  _InDone: (_: unknown) => _,
+  /* c8 ignore next */
+  _OutErr: (_: never) => _,
+  /* c8 ignore next */
+  _OutElem: (_: never) => _,
+  /* c8 ignore next */
+  _OutDone: (_: never) => _
+}
+
+/** @internal */
+export const EffectPrototype: Effect.Effect<never> & Equal.Equal = {
+  [EffectTypeId]: effectVariance,
+  [StreamTypeId]: effectVariance,
+  [SinkTypeId]: sinkVariance,
+  [ChannelTypeId]: channelVariance,
+  [Equal.symbol](that: any) {
+    return this === that
+  },
+  [Hash.symbol]() {
+    return Hash.cached(this, Hash.random(this))
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this)) as any
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const StructuralPrototype: Equal.Equal = {
+  [Hash.symbol]() {
+    return Hash.cached(this, Hash.structure(this))
+  },
+  [Equal.symbol](this: Equal.Equal, that: Equal.Equal) {
+    const selfKeys = Object.keys(this)
+    const thatKeys = Object.keys(that as object)
+    if (selfKeys.length !== thatKeys.length) {
+      return false
+    }
+    for (const key of selfKeys) {
+      if (!(key in (that as object) && Equal.equals((this as any)[key], (that as any)[key]))) {
+        return false
+      }
+    }
+    return true
+  }
+}
+
+/** @internal */
+export const CommitPrototype: Effect.Effect<never> = {
+  ...EffectPrototype,
+  _op: OpCodes.OP_COMMIT
+} as any
+
+/** @internal */
+export const StructuralCommitPrototype: Effect.Effect<never> = {
+  ...CommitPrototype,
+  ...StructuralPrototype
+} as any
+
+/** @internal */
+export const Base: Effectable.CommitPrimitive = (function() {
+  function Base() {}
+  Base.prototype = CommitPrototype
+  return Base as any
+})()
+
+/** @internal */
+export const StructuralBase: Effectable.CommitPrimitive = (function() {
+  function Base() {}
+  Base.prototype = StructuralCommitPrototype
+  return Base as any
+})()

package/src/internal/either.ts

@@ -0,0 +1,110 @@
+/**
+ * @since 2.0.0
+ */
+
+import type * as Either from "../Either.js"
+import * as Equal from "../Equal.js"
+import { dual } from "../Function.js"
+import * as Hash from "../Hash.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import type { Option } from "../Option.js"
+import { hasProperty } from "../Predicate.js"
+import { EffectPrototype } from "./effectable.js"
+import * as option from "./option.js"
+
+/**
+ * @internal
+ */
+export const TypeId: Either.TypeId = Symbol.for("effect/Either") as Either.TypeId
+
+const CommonProto = {
+  ...EffectPrototype,
+  [TypeId]: {
+    _R: (_: never) => _
+  },
+  [NodeInspectSymbol]<L, R>(this: Either.Either<R, L>) {
+    return this.toJSON()
+  },
+  toString<L, R>(this: Either.Left<L, R>) {
+    return format(this.toJSON())
+  }
+}
+
+const RightProto = Object.assign(Object.create(CommonProto), {
+  _tag: "Right",
+  _op: "Right",
+  [Equal.symbol]<L, R>(this: Either.Right<L, R>, that: unknown): boolean {
+    return isEither(that) && isRight(that) && Equal.equals(this.right, that.right)
+  },
+  [Hash.symbol]<L, R>(this: Either.Right<L, R>) {
+    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.right))
+  },
+  toJSON<L, R>(this: Either.Right<L, R>) {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    }
+  }
+})
+
+const LeftProto = Object.assign(Object.create(CommonProto), {
+  _tag: "Left",
+  _op: "Left",
+  [Equal.symbol]<L, R>(this: Either.Left<L, R>, that: unknown): boolean {
+    return isEither(that) && isLeft(that) && Equal.equals(this.left, that.left)
+  },
+  [Hash.symbol]<L, R>(this: Either.Left<L, R>) {
+    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.left))
+  },
+  toJSON<E, A>(this: Either.Left<E, A>) {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    }
+  }
+})
+
+/** @internal */
+export const isEither = (input: unknown): input is Either.Either<unknown, unknown> => hasProperty(input, TypeId)
+
+/** @internal */
+export const isLeft = <R, L>(ma: Either.Either<R, L>): ma is Either.Left<L, R> => ma._tag === "Left"
+
+/** @internal */
+export const isRight = <R, L>(ma: Either.Either<R, L>): ma is Either.Right<L, R> => ma._tag === "Right"
+
+/** @internal */
+export const left = <L>(left: L): Either.Either<never, L> => {
+  const a = Object.create(LeftProto)
+  a.left = left
+  return a
+}
+
+/** @internal */
+export const right = <R>(right: R): Either.Either<R> => {
+  const a = Object.create(RightProto)
+  a.right = right
+  return a
+}
+
+/** @internal */
+export const getLeft = <R, L>(
+  self: Either.Either<R, L>
+): Option<L> => (isRight(self) ? option.none : option.some(self.left))
+
+/** @internal */
+export const getRight = <R, L>(
+  self: Either.Either<R, L>
+): Option<R> => (isLeft(self) ? option.none : option.some(self.right))
+
+/** @internal */
+export const fromOption: {
+  <L>(onNone: () => L): <R>(self: Option<R>) => Either.Either<R, L>
+  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L>
+} = dual(
+  2,
+  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L> =>
+    option.isNone(self) ? left(onNone()) : right(self.value)
+)

package/src/internal/encoding/base64.ts

@@ -0,0 +1,286 @@
+import * as Either from "../../Either.js"
+import type * as Encoding from "../../Encoding.js"
+import { DecodeException } from "./common.js"
+
+/** @internal */
+export const encode = (bytes: Uint8Array) => {
+  const length = bytes.length
+
+  let result = ""
+  let i: number
+
+  for (i = 2; i < length; i += 3) {
+    result += base64abc[bytes[i - 2] >> 2]
+    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
+    result += base64abc[((bytes[i - 1] & 0x0f) << 2) | (bytes[i] >> 6)]
+    result += base64abc[bytes[i] & 0x3f]
+  }
+
+  if (i === length + 1) {
+    // 1 octet yet to write
+    result += base64abc[bytes[i - 2] >> 2]
+    result += base64abc[(bytes[i - 2] & 0x03) << 4]
+    result += "=="
+  }
+
+  if (i === length) {
+    // 2 octets yet to write
+    result += base64abc[bytes[i - 2] >> 2]
+    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)]
+    result += base64abc[(bytes[i - 1] & 0x0f) << 2]
+    result += "="
+  }
+
+  return result
+}
+
+/** @internal */
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
+  const stripped = stripCrlf(str)
+  const length = stripped.length
+  if (length % 4 !== 0) {
+    return Either.left(
+      DecodeException(stripped, `Length must be a multiple of 4, but is ${length}`)
+    )
+  }
+
+  const index = stripped.indexOf("=")
+  if (index !== -1 && ((index < length - 2) || (index === length - 2 && stripped[length - 1] !== "="))) {
+    return Either.left(
+      DecodeException(stripped, "Found a '=' character, but it is not at the end")
+    )
+  }
+
+  try {
+    const missingOctets = stripped.endsWith("==") ? 2 : stripped.endsWith("=") ? 1 : 0
+    const result = new Uint8Array(3 * (length / 4) - missingOctets)
+    for (let i = 0, j = 0; i < length; i += 4, j += 3) {
+      const buffer = getBase64Code(stripped.charCodeAt(i)) << 18 |
+        getBase64Code(stripped.charCodeAt(i + 1)) << 12 |
+        getBase64Code(stripped.charCodeAt(i + 2)) << 6 |
+        getBase64Code(stripped.charCodeAt(i + 3))
+
+      result[j] = buffer >> 16
+      result[j + 1] = (buffer >> 8) & 0xff
+      result[j + 2] = buffer & 0xff
+    }
+
+    return Either.right(result)
+  } catch (e) {
+    return Either.left(
+      DecodeException(stripped, e instanceof Error ? e.message : "Invalid input")
+    )
+  }
+}
+
+/** @internal */
+export const stripCrlf = (str: string) => str.replace(/[\n\r]/g, "")
+
+/** @internal */
+function getBase64Code(charCode: number) {
+  if (charCode >= base64codes.length) {
+    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`)
+  }
+
+  const code = base64codes[charCode]
+  if (code === 255) {
+    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`)
+  }
+
+  return code
+}
+
+/** @internal */
+const base64abc = [
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "+",
+  "/"
+]
+
+/** @internal */
+const base64codes = [
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  62,
+  255,
+  255,
+  255,
+  63,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  59,
+  60,
+  61,
+  255,
+  255,
+  255,
+  0,
+  255,
+  255,
+  255,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  255,
+  255,
+  255,
+  255,
+  255,
+  255,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  46,
+  47,
+  48,
+  49,
+  50,
+  51
+]

package/src/internal/encoding/base64Url.ts

@@ -0,0 +1,29 @@
+import * as Either from "../../Either.js"
+import type * as Encoding from "../../Encoding.js"
+import * as Base64 from "./base64.js"
+import { DecodeException } from "./common.js"
+
+/** @internal */
+export const encode = (data: Uint8Array) =>
+  Base64.encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_")
+
+/** @internal */
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
+  const stripped = Base64.stripCrlf(str)
+  const length = stripped.length
+  if (length % 4 === 1) {
+    return Either.left(
+      DecodeException(stripped, `Length should be a multiple of 4, but is ${length}`)
+    )
+  }
+
+  if (!/^[-_A-Z0-9]*?={0,2}$/i.test(stripped)) {
+    return Either.left(DecodeException(stripped, "Invalid input"))
+  }
+
+  // Some variants allow or require omitting the padding '=' signs
+  let sanitized = length % 4 === 2 ? `${stripped}==` : length % 4 === 3 ? `${stripped}=` : stripped
+  sanitized = sanitized.replace(/-/g, "+").replace(/_/g, "/")
+
+  return Base64.decode(sanitized)
+}

package/src/internal/encoding/common.ts

@@ -0,0 +1,51 @@
+import type * as Encoding from "../../Encoding.js"
+import { hasProperty, isString } from "../../Predicate.js"
+import type { Mutable } from "../../Types.js"
+
+/** @internal */
+export const DecodeExceptionTypeId: Encoding.DecodeExceptionTypeId = Symbol.for(
+  "effect/Encoding/errors/Decode"
+) as Encoding.DecodeExceptionTypeId
+
+/** @internal */
+export const DecodeException = (input: string, message?: string): Encoding.DecodeException => {
+  const out: Mutable<Encoding.DecodeException> = {
+    _tag: "DecodeException",
+    [DecodeExceptionTypeId]: DecodeExceptionTypeId,
+    input
+  }
+  if (isString(message)) {
+    out.message = message
+  }
+  return out
+}
+
+/** @internal */
+export const isDecodeException = (u: unknown): u is Encoding.DecodeException => hasProperty(u, DecodeExceptionTypeId)
+
+/** @internal */
+export const EncodeExceptionTypeId: Encoding.EncodeExceptionTypeId = Symbol.for(
+  "effect/Encoding/errors/Encode"
+) as Encoding.EncodeExceptionTypeId
+
+/** @internal */
+export const EncodeException = (input: string, message?: string): Encoding.EncodeException => {
+  const out: Mutable<Encoding.EncodeException> = {
+    _tag: "EncodeException",
+    [EncodeExceptionTypeId]: EncodeExceptionTypeId,
+    input
+  }
+  if (isString(message)) {
+    out.message = message
+  }
+  return out
+}
+
+/** @internal */
+export const isEncodeException = (u: unknown): u is Encoding.EncodeException => hasProperty(u, EncodeExceptionTypeId)
+
+/** @interal */
+export const encoder = new TextEncoder()
+
+/** @interal */
+export const decoder = new TextDecoder()