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

package/src/Clock.ts

@@ -0,0 +1,111 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Context from "./Context.js"
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/clock.js"
+import * as defaultServices from "./internal/defaultServices.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ClockTypeId: unique symbol = internal.ClockTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ClockTypeId = typeof ClockTypeId
+
+/**
+ * Represents a time-based clock which provides functionality related to time
+ * and scheduling.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Clock {
+  readonly [ClockTypeId]: ClockTypeId
+  /**
+   * Unsafely returns the current time in milliseconds.
+   */
+  unsafeCurrentTimeMillis(): number
+  /**
+   * Returns the current time in milliseconds.
+   */
+  readonly currentTimeMillis: Effect.Effect<number>
+  /**
+   * Unsafely returns the current time in nanoseconds.
+   */
+  unsafeCurrentTimeNanos(): bigint
+  /**
+   * Returns the current time in nanoseconds.
+   */
+  readonly currentTimeNanos: Effect.Effect<bigint>
+  /**
+   * Asynchronously sleeps for the specified duration.
+   */
+  sleep(duration: Duration.Duration): Effect.Effect<void>
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type CancelToken = () => boolean
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type Task = () => void
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface ClockScheduler {
+  /**
+   * Unsafely schedules the specified task for the specified duration.
+   */
+  unsafeSchedule(task: Task, duration: Duration.Duration): CancelToken
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (_: void) => Clock = internal.make
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sleep: (duration: Duration.DurationInput) => Effect.Effect<void> = defaultServices.sleep
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const currentTimeMillis: Effect.Effect<number> = defaultServices.currentTimeMillis
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const currentTimeNanos: Effect.Effect<bigint> = defaultServices.currentTimeNanos
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const clockWith: <A, E, R>(f: (clock: Clock) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
+  defaultServices.clockWith
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const Clock: Context.Tag<Clock, Clock> = internal.clockTag

package/src/Config.ts

@@ -0,0 +1,542 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Brand from "./Brand.js"
+import type * as Chunk from "./Chunk.js"
+import type * as ConfigError from "./ConfigError.js"
+import type * as Duration from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import type * as Either from "./Either.js"
+import type { LazyArg } from "./Function.js"
+import type * as HashMap from "./HashMap.js"
+import type * as HashSet from "./HashSet.js"
+import * as internal from "./internal/config.js"
+import type * as LogLevel from "./LogLevel.js"
+import type * as Option from "./Option.js"
+import type { Predicate, Refinement } from "./Predicate.js"
+import type * as Redacted from "./Redacted.js"
+import type * as Secret from "./Secret.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ConfigTypeId: unique symbol = internal.ConfigTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ConfigTypeId = typeof ConfigTypeId
+
+/**
+ * A `Config` describes the structure of some configuration data.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Config<out A> extends Config.Variance<A>, Effect.Effect<A, ConfigError.ConfigError> {}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Config {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<out A> {
+    readonly [ConfigTypeId]: {
+      readonly _A: Types.Covariant<A>
+    }
+  }
+
+  /**
+   * @since 2.5.0
+   * @category models
+   */
+  export type Success<T extends Config<any>> = [T] extends [Config<infer _A>] ? _A : never
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Primitive<out A> extends Config<A> {
+    readonly description: string
+    parse(text: string): Either.Either<A, ConfigError.ConfigError>
+  }
+
+  /**
+   * Wraps a nested structure, converting all primitives to a `Config`.
+   *
+   * `Config.Wrap<{ key: string }>` becomes `{ key: Config<string> }`
+   *
+   * To create the resulting config, use the `unwrap` constructor.
+   *
+   * @since 2.0.0
+   * @category models
+   */
+  export type Wrap<A> = [NonNullable<A>] extends [infer T] ? [IsPlainObject<T>] extends [true] ?
+        | { readonly [K in keyof A]: Wrap<A[K]> }
+        | Config<A>
+    : Config<A>
+    : Config<A>
+
+  type IsPlainObject<A> = [A] extends [Record<string, any>]
+    ? [keyof A] extends [never] ? false : [keyof A] extends [string] ? true : false
+    : false
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type LiteralValue = string | number | boolean | null | bigint
+
+/**
+ * Constructs a config from a tuple / struct / arguments of configs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const all: <const Arg extends Iterable<Config<any>> | Record<string, Config<any>>>(
+  arg: Arg
+) => Config<
+  [Arg] extends [ReadonlyArray<Config<any>>] ? {
+      -readonly [K in keyof Arg]: [Arg[K]] extends [Config<infer A>] ? A : never
+    }
+    : [Arg] extends [Iterable<Config<infer A>>] ? Array<A>
+    : [Arg] extends [Record<string, Config<any>>] ? {
+        -readonly [K in keyof Arg]: [Arg[K]] extends [Config<infer A>] ? A : never
+      }
+    : never
+> = internal.all
+
+/**
+ * Constructs a config for an array of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const array: <A>(config: Config<A>, name?: string) => Config<Array<A>> = internal.array
+
+/**
+ * Constructs a config for a boolean value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const boolean: (name?: string) => Config<boolean> = internal.boolean
+
+/**
+ * Constructs a config for a network port [1, 65535].
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+export const port: (name?: string) => Config<number> = internal.port
+
+/**
+ * Constructs a config for an URL value.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export const url: (name?: string) => Config<URL> = internal.url
+
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const chunk: <A>(config: Config<A>, name?: string) => Config<Chunk.Chunk<A>> = internal.chunk
+
+/**
+ * Constructs a config for a date value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const date: (name?: string) => Config<Date> = internal.date
+
+/**
+ * Constructs a config that fails with the specified message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fail: (message: string) => Config<never> = internal.fail
+
+/**
+ * Constructs a config for a float value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const number: (name?: string) => Config<number> = internal.number
+
+/**
+ * Constructs a config for a integer value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const integer: (name?: string) => Config<number> = internal.integer
+
+/**
+ * Constructs a config for a literal value.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Config } from "effect"
+ *
+ * const config = Config.literal("http", "https")("PROTOCOL")
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const literal: <Literals extends ReadonlyArray<LiteralValue>>(...literals: Literals) => (
+  name?: string
+) => Config<Literals[number]> = internal.literal
+
+/**
+ * Constructs a config for a `LogLevel` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const logLevel: (name?: string) => Config<LogLevel.LogLevel> = internal.logLevel
+
+/**
+ * Constructs a config for a duration value.
+ *
+ * @since 2.5.0
+ * @category constructors
+ */
+export const duration: (name?: string) => Config<Duration.Duration> = internal.duration
+
+/**
+ * This function returns `true` if the specified value is an `Config` value,
+ * `false` otherwise.
+ *
+ * This function can be useful for checking the type of a value before
+ * attempting to operate on it as an `Config` value. For example, you could
+ * use `isConfig` to check the type of a value before using it as an
+ * argument to a function that expects an `Config` value.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isConfig: (u: unknown) => u is Config<unknown> = internal.isConfig
+
+/**
+ * Returns a  config whose structure is the same as this one, but which produces
+ * a different value, constructed using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <A, B>(f: (a: A) => B): (self: Config<A>) => Config<B>
+  <A, B>(self: Config<A>, f: (a: A) => B): Config<B>
+} = internal.map
+
+/**
+ * Returns a config whose structure is the same as this one, but which may
+ * produce a different value, constructed using the specified function, which
+ * may throw exceptions that will be translated into validation errors.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapAttempt: {
+  <A, B>(f: (a: A) => B): (self: Config<A>) => Config<B>
+  <A, B>(self: Config<A>, f: (a: A) => B): Config<B>
+} = internal.mapAttempt
+
+/**
+ * Returns a new config whose structure is the samea as this one, but which
+ * may produce a different value, constructed using the specified fallible
+ * function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const mapOrFail: {
+  <A, B>(f: (a: A) => Either.Either<B, ConfigError.ConfigError>): (self: Config<A>) => Config<B>
+  <A, B>(self: Config<A>, f: (a: A) => Either.Either<B, ConfigError.ConfigError>): Config<B>
+} = internal.mapOrFail
+
+/**
+ * Returns a config that has this configuration nested as a property of the
+ * specified name.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const nested: {
+  (name: string): <A>(self: Config<A>) => Config<A>
+  <A>(self: Config<A>, name: string): Config<A>
+} = internal.nested
+
+/**
+ * Returns a config whose structure is preferentially described by this
+ * config, but which falls back to the specified config if there is an issue
+ * reading from this config.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const orElse: {
+  <A2>(that: LazyArg<Config<A2>>): <A>(self: Config<A>) => Config<A2 | A>
+  <A, A2>(self: Config<A>, that: LazyArg<Config<A2>>): Config<A | A2>
+} = internal.orElse
+
+/**
+ * Returns configuration which reads from this configuration, but which falls
+ * back to the specified configuration if reading from this configuration
+ * fails with an error satisfying the specified predicate.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const orElseIf: {
+  <A2>(
+    options: {
+      readonly if: Predicate<ConfigError.ConfigError>
+      readonly orElse: LazyArg<Config<A2>>
+    }
+  ): <A>(self: Config<A>) => Config<A | A2>
+  <A, A2>(
+    self: Config<A>,
+    options: {
+      readonly if: Predicate<ConfigError.ConfigError>
+      readonly orElse: LazyArg<Config<A2>>
+    }
+  ): Config<A | A2>
+} = internal.orElseIf
+
+/**
+ * Returns an optional version of this config, which will be `None` if the
+ * data is missing from configuration, and `Some` otherwise.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const option: <A>(self: Config<A>) => Config<Option.Option<A>> = internal.option
+
+/**
+ * Constructs a new primitive config.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const primitive: <A>(
+  description: string,
+  parse: (text: string) => Either.Either<A, ConfigError.ConfigError>
+) => Config<A> = internal.primitive
+
+/**
+ * Returns a config that describes a sequence of values, each of which has the
+ * structure of this config.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const repeat: <A>(self: Config<A>) => Config<Array<A>> = internal.repeat
+
+/**
+ * Constructs a config for a secret value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ * @deprecated
+ */
+export const secret: (name?: string) => Config<Secret.Secret> = internal.secret
+
+/**
+ * Constructs a config for a redacted value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const redacted: {
+  (name?: string): Config<Redacted.Redacted>
+  <A>(config: Config<A>): Config<Redacted.Redacted<A>>
+} = internal.redacted
+
+/**
+ * Constructs a config for a branded value.
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+export const branded: {
+  <A, B extends Brand.Branded<A, any>>(
+    constructor: Brand.Brand.Constructor<B>
+  ): (config: Config<A>) => Config<B>
+  <B extends Brand.Branded<string, any>>(
+    name: string | undefined,
+    constructor: Brand.Brand.Constructor<B>
+  ): Config<B>
+  <A, B extends Brand.Branded<A, any>>(
+    config: Config<A>,
+    constructor: Brand.Brand.Constructor<B>
+  ): Config<B>
+} = internal.branded
+
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const hashSet: <A>(config: Config<A>, name?: string) => Config<HashSet.HashSet<A>> = internal.hashSet
+
+/**
+ * Constructs a config for a string value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const string: (name?: string) => Config<string> = internal.string
+
+/**
+ * Constructs a config for a non-empty string value.
+ *
+ * @since 3.7.0
+ * @category constructors
+ */
+export const nonEmptyString: (name?: string) => Config<string> = internal.nonEmptyString
+
+/**
+ * Constructs a config which contains the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const succeed: <A>(value: A) => Config<A> = internal.succeed
+
+/**
+ * Lazily constructs a config.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const suspend: <A>(config: LazyArg<Config<A>>) => Config<A> = internal.suspend
+
+/**
+ * Constructs a config which contains the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sync: <A>(value: LazyArg<A>) => Config<A> = internal.sync
+
+/**
+ * Constructs a config for a sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const hashMap: <A>(config: Config<A>, name?: string) => Config<HashMap.HashMap<string, A>> = internal.hashMap
+
+/**
+ * Constructs a config from some configuration wrapped with the `Wrap<A>` utility type.
+ *
+ * For example:
+ *
+ * ```
+ * import { Config, unwrap } from "./Config"
+ *
+ * interface Options { key: string }
+ *
+ * const makeConfig = (config: Config.Wrap<Options>): Config<Options> => unwrap(config)
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap: <A>(wrapped: Config.Wrap<A>) => Config<A> = internal.unwrap
+
+/**
+ * Returns a config that describes the same structure as this one, but which
+ * performs validation during loading.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const validate: {
+  <A, B extends A>(
+    options: {
+      readonly message: string
+      readonly validation: Refinement<A, B>
+    }
+  ): (self: Config<A>) => Config<B>
+  <A>(options: {
+    readonly message: string
+    readonly validation: Predicate<A>
+  }): (self: Config<A>) => Config<A>
+  <A, B extends A>(
+    self: Config<A>,
+    options: {
+      readonly message: string
+      readonly validation: Refinement<A, B>
+    }
+  ): Config<B>
+  <A>(self: Config<A>, options: {
+    readonly message: string
+    readonly validation: Predicate<A>
+  }): Config<A>
+} = internal.validate
+
+/**
+ * Returns a config that describes the same structure as this one, but has the
+ * specified default value in case the information cannot be found.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const withDefault: {
+  <const A2>(def: A2): <A>(self: Config<A>) => Config<A2 | A>
+  <A, const A2>(self: Config<A>, def: A2): Config<A | A2>
+} = internal.withDefault
+
+/**
+ * Adds a description to this configuration, which is intended for humans.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const withDescription: {
+  (description: string): <A>(self: Config<A>) => Config<A>
+  <A>(self: Config<A>, description: string): Config<A>
+} = internal.withDescription
+
+/**
+ * Returns a config that is the composition of this config and the specified
+ * config.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+export const zip: {
+  <B>(that: Config<B>): <A>(self: Config<A>) => Config<[A, B]>
+  <A, B>(self: Config<A>, that: Config<B>): Config<[A, B]>
+} = internal.zip
+
+/**
+ * Returns a config that is the composes this config and the specified config
+ * using the provided function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+export const zipWith: {
+  <B, A, C>(that: Config<B>, f: (a: A, b: B) => C): (self: Config<A>) => Config<C>
+  <A, B, C>(self: Config<A>, that: Config<B>, f: (a: A, b: B) => C): Config<C>
+} = internal.zipWith