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

package/src/Encoding.ts

@@ -0,0 +1,195 @@
+/**
+ * This module provides encoding & decoding functionality for:
+ *
+ * - base64 (RFC4648)
+ * - base64 (URL)
+ * - hex
+ *
+ * @since 2.0.0
+ */
+import * as Either from "./Either.js"
+import * as Base64 from "./internal/encoding/base64.js"
+import * as Base64Url from "./internal/encoding/base64Url.js"
+import * as Common from "./internal/encoding/common.js"
+import * as Hex from "./internal/encoding/hex.js"
+
+/**
+ * Encodes the given value into a base64 (RFC4648) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeBase64: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Base64.encode(Common.encoder.encode(input)) : Base64.encode(input)
+
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64 = (str: string): Either.Either<Uint8Array, DecodeException> => Base64.decode(str)
+
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64String = (str: string) => Either.map(decodeBase64(str), (_) => Common.decoder.decode(_))
+
+/**
+ * Encodes the given value into a base64 (URL) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeBase64Url: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Base64Url.encode(Common.encoder.encode(input)) : Base64Url.encode(input)
+
+/**
+ * Decodes a base64 (URL) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64Url = (str: string): Either.Either<Uint8Array, DecodeException> => Base64Url.decode(str)
+
+/**
+ * Decodes a base64 (URL) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64UrlString = (str: string) => Either.map(decodeBase64Url(str), (_) => Common.decoder.decode(_))
+
+/**
+ * Encodes the given value into a hex `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeHex: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Hex.encode(Common.encoder.encode(input)) : Hex.encode(input)
+
+/**
+ * Decodes a hex encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeHex = (str: string): Either.Either<Uint8Array, DecodeException> => Hex.decode(str)
+
+/**
+ * Decodes a hex encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeHexString = (str: string) => Either.map(decodeHex(str), (_) => Common.decoder.decode(_))
+
+/**
+ * Encodes a UTF-8 `string` into a URI component `string`.
+ *
+ * @category encoding
+ * @since 3.12.0
+ */
+export const encodeUriComponent = (str: string): Either.Either<string, EncodeException> =>
+  Either.try({
+    try: () => encodeURIComponent(str),
+    catch: (e) => EncodeException(str, e instanceof Error ? e.message : "Invalid input")
+  })
+
+/**
+ * Decodes a URI component `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 3.12.0
+ */
+export const decodeUriComponent = (str: string): Either.Either<string, DecodeException> =>
+  Either.try({
+    try: () => decodeURIComponent(str),
+    catch: (e) => DecodeException(str, e instanceof Error ? e.message : "Invalid input")
+  })
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const DecodeExceptionTypeId: unique symbol = Common.DecodeExceptionTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type DecodeExceptionTypeId = typeof DecodeExceptionTypeId
+
+/**
+ * Represents a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface DecodeException {
+  readonly _tag: "DecodeException"
+  readonly [DecodeExceptionTypeId]: DecodeExceptionTypeId
+  readonly input: string
+  readonly message?: string
+}
+
+/**
+ * Creates a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+export const DecodeException: (input: string, message?: string) => DecodeException = Common.DecodeException
+
+/**
+ * Returns `true` if the specified value is an `DecodeException`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isDecodeException: (u: unknown) => u is DecodeException = Common.isDecodeException
+
+/**
+ * @since 3.12.0
+ * @category symbols
+ */
+export const EncodeExceptionTypeId: unique symbol = Common.EncodeExceptionTypeId
+
+/**
+ * @since 3.12.0
+ * @category symbols
+ */
+export type EncodeExceptionTypeId = typeof EncodeExceptionTypeId
+
+/**
+ * Represents a checked exception which occurs when encoding fails.
+ *
+ * @since 3.12.0
+ * @category models
+ */
+export interface EncodeException {
+  readonly _tag: "EncodeException"
+  readonly [EncodeExceptionTypeId]: EncodeExceptionTypeId
+  readonly input: string
+  readonly message?: string
+}
+
+/**
+ * Creates a checked exception which occurs when encoding fails.
+ *
+ * @since 3.12.0
+ * @category errors
+ */
+export const EncodeException: (input: string, message?: string) => EncodeException = Common.EncodeException
+
+/**
+ * Returns `true` if the specified value is an `EncodeException`, `false` otherwise.
+ *
+ * @since 3.12.0
+ * @category refinements
+ */
+export const isEncodeException: (u: unknown) => u is EncodeException = Common.isEncodeException

package/src/Equal.ts

@@ -0,0 +1,98 @@
+/**
+ * @since 2.0.0
+ */
+import type { Equivalence } from "./Equivalence.js"
+import * as Hash from "./Hash.js"
+import { hasProperty } from "./Predicate.js"
+import { structuralRegionState } from "./Utils.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("effect/Equal")
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Equal extends Hash.Hash {
+  [symbol](that: Equal): boolean
+}
+
+/**
+ * @since 2.0.0
+ * @category equality
+ */
+export function equals<B>(that: B): <A>(self: A) => boolean
+export function equals<A, B>(self: A, that: B): boolean
+export function equals(): any {
+  if (arguments.length === 1) {
+    return (self: unknown) => compareBoth(self, arguments[0])
+  }
+  return compareBoth(arguments[0], arguments[1])
+}
+
+function compareBoth(self: unknown, that: unknown): boolean {
+  if (self === that) {
+    return true
+  }
+  const selfType = typeof self
+  if (selfType !== typeof that) {
+    return false
+  }
+  if (selfType === "object" || selfType === "function") {
+    if (self !== null && that !== null) {
+      if (isEqual(self) && isEqual(that)) {
+        if (Hash.hash(self) === Hash.hash(that) && self[symbol](that)) {
+          return true
+        } else {
+          return structuralRegionState.enabled && structuralRegionState.tester
+            ? structuralRegionState.tester(self, that)
+            : false
+        }
+      } else if (self instanceof Date && that instanceof Date) {
+        const t1 = self.getTime()
+        const t2 = that.getTime()
+        return t1 === t2 || (Number.isNaN(t1) && Number.isNaN(t2))
+      } else if (self instanceof URL && that instanceof URL) {
+        return self.href === that.href
+      }
+    }
+    if (structuralRegionState.enabled) {
+      if (Array.isArray(self) && Array.isArray(that)) {
+        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]))
+      }
+      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
+        const keysSelf = Object.keys(self as any)
+        const keysThat = Object.keys(that as any)
+        if (keysSelf.length === keysThat.length) {
+          for (const key of keysSelf) {
+            // @ts-expect-error
+            if (!(key in that && compareBoth(self[key], that[key]))) {
+              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false
+            }
+          }
+          return true
+        }
+      }
+      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false
+    }
+  }
+
+  return structuralRegionState.enabled && structuralRegionState.tester
+    ? structuralRegionState.tester(self, that)
+    : false
+}
+
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
+
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+export const equivalence: <A>() => Equivalence<A> = () => equals

package/src/Equivalence.ts

@@ -0,0 +1,235 @@
+/**
+ * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
+ * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
+ * These properties are also known in mathematics as an "equivalence relation".
+ *
+ * @since 2.0.0
+ */
+import { dual } from "./Function.js"
+import type { TypeLambda } from "./HKT.js"
+
+/**
+ * @category type class
+ * @since 2.0.0
+ */
+export interface Equivalence<in A> {
+  (self: A, that: A): boolean
+}
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export interface EquivalenceTypeLambda extends TypeLambda {
+  readonly type: Equivalence<this["Target"]>
+}
+
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export const make = <A>(isEquivalent: (self: A, that: A) => boolean): Equivalence<A> => (self: A, that: A): boolean =>
+  self === that || isEquivalent(self, that)
+
+const isStrictEquivalent = (x: unknown, y: unknown) => x === y
+
+/**
+ * Return an `Equivalence` that uses strict equality (===) to compare values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const strict: <A>() => Equivalence<A> = () => isStrictEquivalent
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const string: Equivalence<string> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const number: Equivalence<number> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const boolean: Equivalence<boolean> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const bigint: Equivalence<bigint> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const symbol: Equivalence<symbol> = strict()
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combine: {
+  <A>(that: Equivalence<A>): (self: Equivalence<A>) => Equivalence<A>
+  <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A>
+} = dual(2, <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A> => make((x, y) => self(x, y) && that(x, y)))
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combineMany: {
+  <A>(collection: Iterable<Equivalence<A>>): (self: Equivalence<A>) => Equivalence<A>
+  <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A>
+} = dual(2, <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A> =>
+  make((x, y) => {
+    if (!self(x, y)) {
+      return false
+    }
+    for (const equivalence of collection) {
+      if (!equivalence(x, y)) {
+        return false
+      }
+    }
+    return true
+  }))
+
+const isAlwaysEquivalent: Equivalence<unknown> = (_x, _y) => true
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> =>
+  combineMany(isAlwaysEquivalent, collection)
+
+/**
+ * @category mapping
+ * @since 2.0.0
+ */
+export const mapInput: {
+  <B, A>(f: (b: B) => A): (self: Equivalence<A>) => Equivalence<B>
+  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B>
+} = dual(
+  2,
+  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B> => make((x, y) => self(f(x), f(y)))
+)
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Date: Equivalence<Date> = mapInput(number, (date) => date.getTime())
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const product: {
+  <B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<readonly [A, B]> // readonly because invariant
+  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> // readonly because invariant
+} = dual(
+  2,
+  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> =>
+    make(([xa, xb], [ya, yb]) => self(xa, ya) && that(xb, yb))
+)
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const all = <A>(collection: Iterable<Equivalence<A>>): Equivalence<ReadonlyArray<A>> => {
+  return make((x, y) => {
+    const len = Math.min(x.length, y.length)
+
+    let collectionLength = 0
+    for (const equivalence of collection) {
+      if (collectionLength >= len) {
+        break
+      }
+      if (!equivalence(x[collectionLength], y[collectionLength])) {
+        return false
+      }
+      collectionLength++
+    }
+    return true
+  })
+}
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const productMany = <A>(
+  self: Equivalence<A>,
+  collection: Iterable<Equivalence<A>>
+): Equivalence<readonly [A, ...Array<A>]> /* readonly because invariant */ => {
+  const equivalence = all(collection)
+  return make((x, y) => !self(x[0], y[0]) ? false : equivalence(x.slice(1), y.slice(1)))
+}
+
+/**
+ * Similar to `Promise.all` but operates on `Equivalence`s.
+ *
+ * ```ts skip-type-checking
+ * [Equivalence<A>, Equivalence<B>, ...] -> Equivalence<[A, B, ...]>
+ * ```
+ *
+ * Given a tuple of `Equivalence`s returns a new `Equivalence` that compares values of a tuple
+ * by applying each `Equivalence` to the corresponding element of the tuple.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const tuple = <T extends ReadonlyArray<Equivalence<any>>>(
+  ...elements: T
+): Equivalence<Readonly<{ [I in keyof T]: [T[I]] extends [Equivalence<infer A>] ? A : never }>> => all(elements) as any
+
+/**
+ * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const array = <A>(item: Equivalence<A>): Equivalence<ReadonlyArray<A>> =>
+  make((self, that) => {
+    if (self.length !== that.length) {
+      return false
+    }
+
+    for (let i = 0; i < self.length; i++) {
+      const isEq = item(self[i], that[i])
+      if (!isEq) {
+        return false
+      }
+    }
+
+    return true
+  })
+
+/**
+ * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
+ * by applying each `Equivalence` to the corresponding property of the struct.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const struct = <R extends Record<string, Equivalence<any>>>(
+  fields: R
+): Equivalence<{ readonly [K in keyof R]: [R[K]] extends [Equivalence<infer A>] ? A : never }> => {
+  const keys = Object.keys(fields)
+  return make((self, that) => {
+    for (const key of keys) {
+      if (!fields[key](self[key], that[key])) {
+        return false
+      }
+    }
+    return true
+  })
+}