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

package/src/Ref.ts

@@ -1,180 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Effect from "./Effect.js"
-import * as internal from "./internal/ref.js"
-import type * as Option from "./Option.js"
-import type * as Readable from "./Readable.js"
-import type * as Types from "./Types.js"
-import type * as Unify from "./Unify.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const RefTypeId: unique symbol = internal.RefTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type RefTypeId = typeof RefTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Ref<in out A> extends Ref.Variance<A>, Effect.Effect<A>, Readable.Readable<A> {
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
-  readonly [Unify.typeSymbol]?: unknown
-  readonly [Unify.unifySymbol]?: RefUnify<this>
-  readonly [Unify.ignoreSymbol]?: RefUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface RefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
-  Ref?: () => Extract<A[Unify.typeSymbol], Ref<any>>
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface RefUnifyIgnore extends Effect.EffectUnifyIgnore {
-  Effect?: true
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export declare namespace Ref {
-  /**
-   * @since 2.0.0
-   */
-  export interface Variance<in out A> {
-    readonly [RefTypeId]: {
-      readonly _A: Types.Invariant<A>
-    }
-  }
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const make: <A>(value: A) => Effect.Effect<Ref<A>> = internal.make
-
-/**
- * @since 2.0.0
- * @category getters
- */
-export const get: <A>(self: Ref<A>) => Effect.Effect<A> = internal.get
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndSet: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, value: A): Effect.Effect<A>
-} = internal.getAndSet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
-} = internal.getAndUpdate
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = internal.getAndUpdateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<B>
-  <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
-} = internal.modify
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifySome: {
-  <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<B>
-  <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B>
-} = internal.modifySome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const set: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref<A>, value: A): Effect.Effect<void>
-} = internal.set
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const setAndGet: {
-  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, value: A): Effect.Effect<A>
-} = internal.setAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const update: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<void>
-} = internal.update
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
-} = internal.updateAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
-} = internal.updateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeAndGet: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = internal.updateSomeAndGet
-
-/**
- * @since 2.0.0
- * @category unsafe
- */
-export const unsafeMake: <A>(value: A) => Ref<A> = internal.unsafeMake

package/src/RegExp.ts

@@ -1,38 +0,0 @@
-/**
- * This module provides utility functions for working with RegExp in TypeScript.
- *
- * @since 2.0.0
- */
-import * as predicate from "./Predicate.js"
-
-/**
- * Tests if a value is a `RegExp`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { RegExp } from "effect"
- *
- * assert.deepStrictEqual(RegExp.isRegExp(/a/), true)
- * assert.deepStrictEqual(RegExp.isRegExp("a"), false)
- * ```
- *
- * @category guards
- * @since 3.9.0
- */
-export const isRegExp: (input: unknown) => input is RegExp = predicate.isRegExp
-
-/**
- * Escapes special characters in a regular expression pattern.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { RegExp } from "effect"
- *
- * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
- * ```
- *
- * @since 2.0.0
- */
-export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/Reloadable.ts

@@ -1,127 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Context from "./Context.js"
-import type * as Effect from "./Effect.js"
-import * as internal from "./internal/reloadable.js"
-import type * as Layer from "./Layer.js"
-import type * as Schedule from "./Schedule.js"
-import type * as ScopedRef from "./ScopedRef.js"
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const ReloadableTypeId: unique symbol = internal.ReloadableTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type ReloadableTypeId = typeof ReloadableTypeId
-
-/**
- * A `Reloadable` is an implementation of some service that can be dynamically
- * reloaded, or swapped out for another implementation on-the-fly.
- *
- * @since 2.0.0
- * @category models
- */
-export interface Reloadable<in out A> extends Reloadable.Variance<A> {
-  /**
-   * @internal
-   */
-  readonly scopedRef: ScopedRef.ScopedRef<A>
-  /**
-   * @internal
-   */
-  readonly reload: Effect.Effect<void, unknown>
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Reloadable {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in out A> {
-    readonly [ReloadableTypeId]: {
-      readonly _A: Types.Invariant<A>
-    }
-  }
-}
-
-/**
- * Makes a new reloadable service from a layer that describes the construction
- * of a static service. The service is automatically reloaded according to the
- * provided schedule.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const auto: <I, S, E, In, R>(
-  tag: Context.Tag<I, S>,
-  options: { readonly layer: Layer.Layer<I, E, In>; readonly schedule: Schedule.Schedule<unknown, unknown, R> }
-) => Layer.Layer<Reloadable<I>, E, R | In> = internal.auto
-
-/**
- * Makes a new reloadable service from a layer that describes the construction
- * of a static service. The service is automatically reloaded according to a
- * schedule, which is extracted from the input to the layer.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const autoFromConfig: <I, S, E, In, R>(
-  tag: Context.Tag<I, S>,
-  options: {
-    readonly layer: Layer.Layer<I, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
-  }
-) => Layer.Layer<Reloadable<I>, E, R | In> = internal.autoFromConfig
-
-/**
- * Retrieves the current version of the reloadable service.
- *
- * @since 2.0.0
- * @category getters
- */
-export const get: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<S, never, Reloadable<I>> = internal.get
-
-/**
- * Makes a new reloadable service from a layer that describes the construction
- * of a static service.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const manual: <I, S, In, E>(
-  tag: Context.Tag<I, S>,
-  options: { readonly layer: Layer.Layer<I, E, In> }
-) => Layer.Layer<Reloadable<I>, E, In> = internal.manual
-
-/**
- * Reloads the specified service.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const reload: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<void, unknown, Reloadable<I>> = internal.reload
-
-/**
- * @since 2.0.0
- * @category context
- */
-export const tag: <I, S>(tag: Context.Tag<I, S>) => Context.Tag<Reloadable<I>, Reloadable<S>> = internal.reloadableTag
-
-/**
- * Forks the reload of the service in the background, ignoring any errors.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const reloadFork: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<void, unknown, Reloadable<I>> =
-  internal.reloadFork

package/src/Request.ts

@@ -1,347 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as _Cache from "./Cache.js"
-import type { Cause } from "./Cause.js"
-import type { Deferred } from "./Deferred.js"
-import type { DurationInput } from "./Duration.js"
-import type * as Effect from "./Effect.js"
-import type * as Exit from "./Exit.js"
-import type { FiberId } from "./FiberId.js"
-import * as RequestBlock_ from "./internal/blockedRequests.js"
-import * as cache from "./internal/cache.js"
-import * as core from "./internal/core.js"
-import * as fiberRuntime from "./internal/fiberRuntime.js"
-import * as internal from "./internal/request.js"
-import type * as Option from "./Option.js"
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const RequestTypeId: unique symbol = internal.RequestTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type RequestTypeId = typeof RequestTypeId
-
-/**
- * A `Request<A, E>` is a request from a data source for a value of type `A`
- * that may fail with an `E`.
- *
- * @since 2.0.0
- * @category models
- */
-export interface Request<out A, out E = never> extends Request.Variance<A, E> {}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Request {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<out A, out E> {
-    readonly [RequestTypeId]: {
-      readonly _A: Types.Covariant<A>
-      readonly _E: Types.Covariant<E>
-    }
-  }
-
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Constructor<R extends Request<any, any>, T extends keyof R = never> {
-    (args: Omit<R, T | keyof (Request.Variance<Request.Success<R>, Request.Error<R>>)>): R
-  }
-
-  /**
-   * A utility type to extract the error type from a `Request`.
-   *
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Error<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _E : never
-
-  /**
-   * A utility type to extract the value type from a `Request`.
-   *
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Success<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _A : never
-
-  /**
-   * A utility type to extract the result type from a `Request`.
-   *
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type Result<T extends Request<any, any>> = T extends Request<infer A, infer E> ? Exit.Exit<A, E> : never
-
-  /**
-   * A utility type to extract the optional result type from a `Request`.
-   *
-   * @since 2.0.0
-   * @category type-level
-   */
-  export type OptionalResult<T extends Request<any, any>> = T extends Request<infer A, infer E>
-    ? Exit.Exit<Option.Option<A>, E>
-    : never
-}
-
-/**
- * Returns `true` if the specified value is a `Request`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isRequest: (u: unknown) => u is Request<unknown, unknown> = internal.isRequest
-
-/**
- * Constructs a new `Request`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const of: <R extends Request<any, any>>() => Request.Constructor<R> = internal.of
-
-/**
- * Constructs a new `Request`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const tagged: <R extends Request<any, any> & { _tag: string }>(
-  tag: R["_tag"]
-) => Request.Constructor<R, "_tag"> = internal.tagged
-
-/**
- * Provides a constructor for a Request Class.
- *
- * @example
- * ```ts
- * import { Request } from "effect"
- *
- * type Success = string
- * type Error = never
- *
- * class MyRequest extends Request.Class<Success, Error, {
- *   readonly id: string
- * }> {}
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-export const Class: new<Success, Error, A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
-    : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
-) => Request<Success, Error> & Readonly<A> = internal.Class as any
-
-/**
- * Provides a Tagged constructor for a Request Class.
- *
- * @example
- * ```ts
- * import { Request } from "effect"
- *
- * type Success = string
- * type Error = never
- *
- * class MyRequest extends Request.TaggedClass("MyRequest")<Success, Error, {
- *   readonly name: string
- * }> {}
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-export const TaggedClass: <Tag extends string>(
-  tag: Tag
-) => new<Success, Error, A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
-) => Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any
-
-/**
- * Complete a `Request` with the specified result.
- *
- * @since 2.0.0
- * @category request completion
- */
-export const complete: {
-  <A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<void>
-  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<void>
-} = internal.complete
-
-/**
- * Interrupts the child effect when requests are no longer needed
- *
- * @since 2.0.0
- * @category request completion
- */
-export const interruptWhenPossible: {
-  (all: Iterable<Request<any, any>>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, all: Iterable<Request<any, any>>): Effect.Effect<void, E, R>
-} = fiberRuntime.interruptWhenPossible
-
-/**
- * Complete a `Request` with the specified effectful computation, failing the
- * request with the error from the effect workflow if it fails, and completing
- * the request with the value of the effect workflow if it succeeds.
- *
- * @since 2.0.0
- * @category request completion
- */
-export const completeEffect: {
-  <A extends Request<any, any>, R>(
-    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
-  ): (self: A) => Effect.Effect<void, never, R>
-  <A extends Request<any, any>, R>(
-    self: A,
-    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
-  ): Effect.Effect<void, never, R>
-} = internal.completeEffect
-
-/**
- * Complete a `Request` with the specified error.
- *
- * @since 2.0.0
- * @category request completion
- */
-export const fail: {
-  <A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<void>
-  <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<void>
-} = internal.fail
-
-/**
- * Complete a `Request` with the specified cause.
- *
- * @since 2.0.0
- * @category request completion
- */
-export const failCause: {
-  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<void>
-  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<void>
-} = internal.failCause
-
-/**
- * Complete a `Request` with the specified value.
- *
- * @since 2.0.0
- * @category request completion
- */
-export const succeed: {
-  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<void>
-  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<void>
-} = internal.succeed
-
-/**
- * @category models
- * @since 2.0.0
- */
-export interface Listeners {
-  readonly count: number
-  readonly observers: Set<(count: number) => void>
-  interrupted: boolean
-  addObserver(f: (count: number) => void): void
-  removeObserver(f: (count: number) => void): void
-  increment(): void
-  decrement(): void
-}
-
-/**
- * @category models
- * @since 2.0.0
- */
-export interface Cache extends
-  _Cache.ConsumerCache<Request<any, any>, {
-    listeners: Listeners
-    handle: Deferred<unknown, unknown>
-  }>
-{}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export const makeCache = (
-  options: {
-    readonly capacity: number
-    readonly timeToLive: DurationInput
-  }
-): Effect.Effect<Cache> =>
-  cache.make({
-    ...options,
-    lookup: () =>
-      core.map(core.deferredMake<unknown, unknown>(), (handle) => ({ listeners: new internal.Listeners(), handle }))
-  })
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const EntryTypeId: unique symbol = Symbol.for("effect/RequestBlock.Entry")
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type EntryTypeId = typeof EntryTypeId
-
-/**
- * A `Entry<A>` keeps track of a request of type `A` along with a
- * `Ref` containing the result of the request, existentially hiding the result
- * type. This is used internally by the library to support data sources that
- * return different result types for different requests while guaranteeing that
- * results will be of the type requested.
- *
- * @since 2.0.0
- * @category models
- */
-export interface Entry<out R> extends Entry.Variance<R> {
-  readonly request: R
-  readonly result: Deferred<
-    [R] extends [Request<infer _A, infer _E>] ? _A : never,
-    [R] extends [Request<infer _A, infer _E>] ? _E : never
-  >
-  readonly listeners: Listeners
-  readonly ownerId: FiberId
-  readonly state: {
-    completed: boolean
-  }
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export declare namespace Entry {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<out R> {
-    readonly [EntryTypeId]: {
-      readonly _R: Types.Covariant<R>
-    }
-  }
-}
-
-/**
- * @since 2.0.0
- * @category guards
- */
-export const isEntry = RequestBlock_.isEntry
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const makeEntry = RequestBlock_.makeEntry