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

package/src/Struct.ts

@@ -1,243 +0,0 @@
-/**
- * This module provides utility functions for working with structs in TypeScript.
- *
- * @since 2.0.0
- */
-
-import * as Equivalence from "./Equivalence.js"
-import { dual } from "./Function.js"
-import * as order from "./Order.js"
-import * as Predicate from "./Predicate.js"
-import type { MatchRecord, Simplify } from "./Types.js"
-
-/**
- * Create a new object by picking properties of an existing object.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { pipe, Struct } from "effect"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.pick("a", "b")), { a: "a", b: 1 })
- * assert.deepStrictEqual(Struct.pick({ a: "a", b: 1, c: true }, "a", "b"), { a: "a", b: 1 })
- * ```
- *
- * @since 2.0.0
- */
-export const pick: {
-  <Keys extends Array<PropertyKey>>(
-    ...keys: Keys
-  ): <S extends { [K in Keys[number]]?: any }>(
-    s: S
-  ) => MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
-  <S extends object, Keys extends Array<keyof S>>(
-    s: S,
-    ...keys: Keys
-  ): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>>
-} = dual(
-  (args) => Predicate.isObject(args[0]),
-  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
-    const out: any = {}
-    for (const k of keys) {
-      if (k in s) {
-        out[k] = (s as any)[k]
-      }
-    }
-    return out
-  }
-)
-
-/**
- * Create a new object by omitting properties of an existing object.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { pipe, Struct } from "effect"
- *
- * assert.deepStrictEqual(pipe({ a: "a", b: 1, c: true }, Struct.omit("c")), { a: "a", b: 1 })
- * assert.deepStrictEqual(Struct.omit({ a: "a", b: 1, c: true }, "c"), { a: "a", b: 1 })
- * ```
- *
- * @since 2.0.0
- */
-export const omit: {
-  <Keys extends Array<PropertyKey>>(
-    ...keys: Keys
-  ): <S extends { [K in Keys[number]]?: any }>(s: S) => Simplify<Omit<S, Keys[number]>>
-  <S extends object, Keys extends Array<keyof S>>(
-    s: S,
-    ...keys: Keys
-  ): Simplify<Omit<S, Keys[number]>>
-} = dual(
-  (args) => Predicate.isObject(args[0]),
-  <S extends object, Keys extends Array<keyof S>>(s: S, ...keys: Keys) => {
-    const out: any = { ...s }
-    for (const k of keys) {
-      delete out[k]
-    }
-    return out
-  }
-)
-
-/**
- * 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.
- *
- * Alias of {@link Equivalence.struct}.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Struct, String, Number } from "effect"
- *
- * const PersonEquivalence = Struct.getEquivalence({
- *   name: String.Equivalence,
- *   age: Number.Equivalence
- * })
- *
- * assert.deepStrictEqual(
- *   PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 25 }),
- *   true
- * )
- * assert.deepStrictEqual(
- *   PersonEquivalence({ name: "John", age: 25 }, { name: "John", age: 40 }),
- *   false
- * )
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const getEquivalence: <R extends Record<string, Equivalence.Equivalence<any>>>(
-  isEquivalents: R
-) => Equivalence.Equivalence<
-  { readonly [K in keyof R]: [R[K]] extends [Equivalence.Equivalence<infer A>] ? A : never }
-> = Equivalence.struct
-
-/**
- * This function creates and returns a new `Order` for a struct of values based on the given `Order`s
- * for each property in the struct.
- *
- * Alias of {@link order.struct}.
- *
- * @category combinators
- * @since 2.0.0
- */
-export const getOrder: <R extends { readonly [x: string]: order.Order<any> }>(
-  fields: R
-) => order.Order<{ [K in keyof R]: [R[K]] extends [order.Order<infer A>] ? A : never }> = order.struct
-
-type Transformed<O, T> =
-  & unknown
-  & {
-    [K in keyof O]: K extends keyof T ? (T[K] extends (...a: any) => any ? ReturnType<T[K]> : O[K]) : O[K]
-  }
-type PartialTransform<O, T> = {
-  [K in keyof T]: T[K] extends (a: O[K & keyof O]) => any ? T[K] : (a: O[K & keyof O]) => unknown
-}
-/**
- * Transforms the values of a Struct provided a transformation function for each key.
- * If no transformation function is provided for a key, it will return the original value for that key.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { pipe, Struct } from "effect"
- *
- * assert.deepStrictEqual(
- *   pipe(
- *     { a: 'a', b: 1, c: 3 },
- *     Struct.evolve({
- *       a: (a) => a.length,
- *       b: (b) => b * 2
- *     })
- *   ),
- *   { a: 1, b: 2, c: 3 }
- * )
- * ```
- *
- * @since 2.0.0
- */
-export const evolve: {
-  <O, T>(t: PartialTransform<O, T>): (obj: O) => Transformed<O, T>
-  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T>
-} = dual(
-  2,
-  <O, T>(obj: O, t: PartialTransform<O, T>): Transformed<O, T> => {
-    const out = { ...obj }
-    for (const k in t) {
-      if (Object.prototype.hasOwnProperty.call(obj, k)) {
-        // @ts-expect-error
-        out[k] = t[k](obj[k])
-      }
-    }
-    return out as any
-  }
-)
-
-/**
- * Retrieves the value associated with the specified key from a struct.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { pipe, Struct } from "effect"
- *
- * const value = pipe({ a: 1, b: 2 }, Struct.get("a"))
- *
- * assert.deepStrictEqual(value, 1)
- * ```
- *
- * @since 2.0.0
- */
-export const get =
-  <K extends PropertyKey>(key: K) => <S extends { [P in K]?: any }>(s: S): MatchRecord<S, S[K] | undefined, S[K]> =>
-    s[key]
-
-/**
- * Retrieves the object keys that are strings in a typed manner
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Struct } from "effect"
- *
- * const symbol: unique symbol = Symbol()
- *
- * const value = {
- *   a: 1,
- *   b: 2,
- *   [symbol]: 3
- * }
- *
- * const keys: Array<"a" | "b"> = Struct.keys(value)
- *
- * assert.deepStrictEqual(keys, ["a", "b"])
- * ```
- *
- * @since 3.6.0
- */
-export const keys = <T extends {}>(o: T): Array<(keyof T) & string> => Object.keys(o) as Array<(keyof T) & string>
-
-/**
- * Retrieves the entries (key-value pairs) of an object, where keys are strings,
- * in a type-safe manner. Symbol keys are excluded from the result.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Struct } from "effect"
- *
- * const c = Symbol("c")
- * const value = { a: "foo", b: 1, [c]: true }
- *
- * const entries: Array<["a" | "b", string | number]> = Struct.entries(value)
- *
- * assert.deepStrictEqual(entries, [["a", "foo"], ["b", 1]])
- * ```
- *
- * @since 3.17.0
- */
-export const entries = <const R>(obj: R): Array<[keyof R & string, R[keyof R & string]]> =>
-  Object.entries(obj as any) as any

package/src/Subscribable.ts

@@ -1,100 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Effect from "./Effect.js"
-import { dual } from "./Function.js"
-import { pipeArguments } from "./Pipeable.js"
-import { hasProperty } from "./Predicate.js"
-import * as Readable from "./Readable.js"
-import * as Stream from "./Stream.js"
-import type { NoInfer } from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category type ids
- */
-export const TypeId: unique symbol = Symbol.for("effect/Subscribable")
-
-/**
- * @since 2.0.0
- * @category type ids
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R> {
-  readonly [TypeId]: TypeId
-  readonly changes: Stream.Stream<A, E, R>
-}
-
-/**
- * @since 2.0.0
- * @category refinements
- */
-export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
-
-const Proto: Omit<Subscribable<any>, "get" | "changes"> = {
-  [Readable.TypeId]: Readable.TypeId,
-  [TypeId]: TypeId,
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const make = <A, E, R>(options: {
-  readonly get: Effect.Effect<A, E, R>
-  readonly changes: Stream.Stream<A, E, R>
-}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
-
-/**
- * @since 2.0.0
- * @category combinators
- */
-export const map: {
-  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
-  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
-} = dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
-  make({
-    get: Effect.map(self.get, f),
-    changes: Stream.map(self.changes, f)
-  }))
-
-/**
- * @since 2.0.0
- * @category combinators
- */
-export const mapEffect: {
-  <A, B, E2, R2>(
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
-  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
-  ): Subscribable<B, E | E2, R | R2>
-} = dual(2, <A, E, R, B, E2, R2>(
-  self: Subscribable<A, E, R>,
-  f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
-): Subscribable<B, E | E2, R | R2> =>
-  make({
-    get: Effect.flatMap(self.get, f),
-    changes: Stream.mapEffect(self.changes, f)
-  }))
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const unwrap = <A, E, R, E1, R1>(
-  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>
-): Subscribable<A, E | E1, R | R1> =>
-  make({
-    get: Effect.flatMap(effect, (s) => s.get),
-    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes))
-  })

package/src/SubscriptionRef.ts

@@ -1,298 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Effect from "./Effect.js"
-import * as internal from "./internal/subscriptionRef.js"
-import type * as Option from "./Option.js"
-import type * as PubSub from "./PubSub.js"
-import * as Ref from "./Ref.js"
-import type * as Stream from "./Stream.js"
-import type { Subscribable } from "./Subscribable.js"
-import * as Synchronized from "./SynchronizedRef.js"
-import type * as Types from "./Types.js"
-import type * as Unify from "./Unify.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const SubscriptionRefTypeId: unique symbol = internal.SubscriptionRefTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
-
-/**
- * A `SubscriptionRef<A>` is a `Ref` that can be subscribed to in order to
- * receive the current value as well as all changes to the value.
- *
- * @since 2.0.0
- * @category models
- */
-export interface SubscriptionRef<in out A>
-  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Subscribable<A>
-{
-  /** @internal */
-  readonly ref: Ref.Ref<A>
-  /** @internal */
-  readonly pubsub: PubSub.PubSub<A>
-  /** @internal */
-  readonly semaphore: Effect.Semaphore
-  /**
-   * A stream containing the current value of the `Ref` as well as all changes
-   * to that value.
-   */
-  readonly changes: Stream.Stream<A>
-  readonly [Unify.typeSymbol]?: unknown
-  readonly [Unify.unifySymbol]?: SubscriptionRefUnify<this>
-  readonly [Unify.ignoreSymbol]?: SubscriptionRefUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface SubscriptionRefUnify<A extends { [Unify.typeSymbol]?: any }>
-  extends Synchronized.SynchronizedRefUnify<A>
-{
-  SubscriptionRef?: () => Extract<A[Unify.typeSymbol], SubscriptionRef<any>>
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface SubscriptionRefUnifyIgnore extends Synchronized.SynchronizedRefUnifyIgnore {
-  SynchronizedRef?: true
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace SubscriptionRef {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in out A> {
-    readonly [SubscriptionRefTypeId]: {
-      readonly _A: Types.Invariant<A>
-    }
-  }
-}
-
-/**
- * @since 2.0.0
- * @category getters
- */
-export const get: <A>(self: SubscriptionRef<A>) => Effect.Effect<A> = internal.get
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndSet: {
-  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
-} = Ref.getAndSet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A>
-} = Ref.getAndUpdate
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
-} = Synchronized.getAndUpdateEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = Ref.getAndUpdateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateSomeEffect: {
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(
-    self: SubscriptionRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): Effect.Effect<A, E, R>
-} = Synchronized.getAndUpdateSomeEffect
-
-/**
- * Creates a new `SubscriptionRef` with the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const make: <A>(value: A) => Effect.Effect<SubscriptionRef<A>> = internal.make
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: SubscriptionRef<A>) => Effect.Effect<B>
-  <A, B>(self: SubscriptionRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
-} = internal.modify
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifyEffect: {
-  <B, A, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SubscriptionRef<A>) => Effect.Effect<B, E, R>
-  <A, B, E, R>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
-} = internal.modifyEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifySome: {
-  <B, A>(
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ): (self: SubscriptionRef<A>) => Effect.Effect<B>
-  <A, B>(
-    self: SubscriptionRef<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ): Effect.Effect<B>
-} = Ref.modifySome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifySomeEffect: {
-  <A, B, R, E>(
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
-  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>
-  <A, B, R, E>(
-    self: Synchronized.SynchronizedRef<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
-  ): Effect.Effect<B, E, R>
-} = Synchronized.modifySomeEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const set: {
-  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<void>
-  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<void>
-} = internal.set
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const setAndGet: {
-  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
-} = Ref.setAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const update: {
-  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<void>
-  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<void>
-} = Ref.update
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
-  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, E, R>
-} = Synchronized.updateEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A>
-} = Ref.updateAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateAndGetEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
-} = Synchronized.updateAndGetEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<void>
-  <A>(self: SubscriptionRef<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
-} = Ref.updateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeEffect: {
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
-  <A, R, E>(
-    self: Synchronized.SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): Effect.Effect<void, E, R>
-} = Synchronized.updateSomeEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeAndGet: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A>
-  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = Ref.updateSomeAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeAndGetEffect: {
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(
-    self: SubscriptionRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): Effect.Effect<A, E, R>
-} = Synchronized.updateSomeAndGetEffect