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

package/src/LayerMap.ts

@@ -1,436 +0,0 @@
-/**
- * @since 3.14.0
- * @experimental
- */
-import * as Context from "./Context.js"
-import type * as Duration from "./Duration.js"
-import * as Effect from "./Effect.js"
-import * as FiberRefsPatch from "./FiberRefsPatch.js"
-import { identity } from "./Function.js"
-import * as core from "./internal/core.js"
-import * as Layer from "./Layer.js"
-import * as RcMap from "./RcMap.js"
-import * as Runtime from "./Runtime.js"
-import * as Scope from "./Scope.js"
-import type { Mutable, NoExcessProperties } from "./Types.js"
-
-/**
- * @since 3.14.0
- * @category Symbols
- */
-export const TypeId: unique symbol = Symbol.for("effect/LayerMap")
-
-/**
- * @since 3.14.0
- * @category Symbols
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 3.14.0
- * @category Models
- * @experimental
- */
-export interface LayerMap<in K, in out I, out E = never> {
-  readonly [TypeId]: TypeId
-
-  /**
-   * The internal RcMap that stores the resources.
-   */
-  readonly rcMap: RcMap.RcMap<K, {
-    readonly layer: Layer.Layer<I, E>
-    readonly runtimeEffect: Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope>
-  }, E>
-
-  /**
-   * Retrieves a Layer for the resources associated with the key.
-   */
-  get(key: K): Layer.Layer<I, E>
-
-  /**
-   * Retrieves a Runtime for the resources associated with the key.
-   */
-  runtime(key: K): Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope>
-
-  /**
-   * Invalidates the resource associated with the key.
-   */
-  invalidate(key: K): Effect.Effect<void>
-}
-
-/**
- * @since 3.14.0
- * @category Constructors
- * @experimental
- *
- * A `LayerMap` allows you to create a map of Layer's that can be used to
- * dynamically access resources based on a key.
- *
- * ```ts
- * import { NodeRuntime } from "@effect/platform-node"
- * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
- *
- * class Greeter extends Context.Tag("Greeter")<Greeter, {
- *   greet: Effect.Effect<string>
- * }>() {}
- *
- * // create a service that wraps a LayerMap
- * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
- *   // define the lookup function for the layer map
- *   //
- *   // The returned Layer will be used to provide the Greeter service for the
- *   // given name.
- *   lookup: (name: string) =>
- *     Layer.succeed(Greeter, {
- *       greet: Effect.succeed(`Hello, ${name}!`)
- *     }).pipe(
- *       Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
- *     ),
- *
- *   // If a layer is not used for a certain amount of time, it can be removed
- *   idleTimeToLive: "5 seconds",
- *
- *   // Supply the dependencies for the layers in the LayerMap
- *   dependencies: []
- * }) {}
- *
- * // usage
- * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
- *   // access and use the Greeter service
- *   const greeter = yield* Greeter
- *   yield* Effect.log(yield* greeter.greet)
- * }).pipe(
- *   // use the GreeterMap service to provide a variant of the Greeter service
- *   Effect.provide(GreeterMap.get("John"))
- * )
- *
- * // run the program
- * program.pipe(
- *   Effect.provide(GreeterMap.Default),
- *   NodeRuntime.runMain
- * )
- * ```
- */
-export const make: <
-  K,
-  L extends Layer.Layer<any, any, any>,
-  PreloadKeys extends Iterable<K> | undefined = undefined
->(
-  lookup: (key: K) => L,
-  options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-    readonly preloadKeys?: PreloadKeys
-  } | undefined
-) => Effect.Effect<
-  LayerMap<
-    K,
-    L extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
-    L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
-  >,
-  PreloadKeys extends undefined ? never : L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
-  Scope.Scope | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> = Effect.fnUntraced(function*<I, K, EL, RL>(
-  lookup: (key: K) => Layer.Layer<I, EL, RL>,
-  options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-    readonly preloadKeys?: Iterable<K> | undefined
-  } | undefined
-) {
-  const context = yield* Effect.context<never>()
-
-  // If we are inside another layer build, use the current memo map,
-  // otherwise create a new one.
-  const memoMap = context.unsafeMap.has(Layer.CurrentMemoMap.key)
-    ? Context.get(context, Layer.CurrentMemoMap)
-    : yield* Layer.makeMemoMap
-
-  const rcMap = yield* RcMap.make({
-    lookup: (key: K) =>
-      Effect.scopeWith((scope) => Effect.diffFiberRefs(Layer.buildWithMemoMap(lookup(key), memoMap, scope))).pipe(
-        Effect.map(([patch, context]) => ({
-          layer: Layer.scopedContext(
-            core.withFiberRuntime<Context.Context<I>, any, Scope.Scope>((fiber) => {
-              const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope)
-              const oldRefs = fiber.getFiberRefs()
-              const newRefs = FiberRefsPatch.patch(patch, fiber.id(), oldRefs)
-              const revert = FiberRefsPatch.diff(newRefs, oldRefs)
-              fiber.setFiberRefs(newRefs)
-              return Effect.as(
-                Scope.addFinalizerExit(scope, () => {
-                  fiber.setFiberRefs(FiberRefsPatch.patch(revert, fiber.id(), fiber.getFiberRefs()))
-                  return Effect.void
-                }),
-                context
-              )
-            })
-          ),
-          runtimeEffect: Effect.withFiberRuntime<Runtime.Runtime<I>, any, Scope.Scope>((fiber) => {
-            const fiberRefs = FiberRefsPatch.patch(patch, fiber.id(), fiber.getFiberRefs())
-            return Effect.succeed(Runtime.make({
-              context,
-              fiberRefs,
-              runtimeFlags: Runtime.defaultRuntime.runtimeFlags
-            }))
-          })
-        } as const))
-      ),
-    idleTimeToLive: options?.idleTimeToLive
-  })
-
-  if (options?.preloadKeys) {
-    for (const key of options.preloadKeys) {
-      yield* (RcMap.get(rcMap, key) as Effect.Effect<any, EL, RL | Scope.Scope>)
-    }
-  }
-
-  return identity<LayerMap<K, Exclude<I, Scope.Scope>, any>>({
-    [TypeId]: TypeId,
-    rcMap,
-    get: (key) => Layer.unwrapScoped(Effect.map(RcMap.get(rcMap, key), ({ layer }) => layer)),
-    runtime: (key) => Effect.flatMap(RcMap.get(rcMap, key), ({ runtimeEffect }) => runtimeEffect),
-    invalidate: (key) => RcMap.invalidate(rcMap, key)
-  })
-})
-
-/**
- * @since 3.14.0
- * @category Constructors
- * @experimental
- */
-export const fromRecord = <
-  const Layers extends Record<string, Layer.Layer<any, any, any>>,
-  const Preload extends boolean = false
->(
-  layers: Layers,
-  options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-    readonly preload?: Preload | undefined
-  } | undefined
-): Effect.Effect<
-  LayerMap<
-    keyof Layers,
-    Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
-    Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
-  >,
-  Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
-  Scope.Scope | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> =>
-  make((key: keyof Layers) => layers[key], {
-    ...options,
-    preloadKeys: options?.preload ? Object.keys(layers) : undefined
-  }) as any
-
-/**
- * @since 3.14.0
- * @category Service
- */
-export interface TagClass<
-  in out Self,
-  in out Id extends string,
-  in out K,
-  in out I,
-  in out E,
-  in out R,
-  in out LE,
-  in out Deps extends Layer.Layer<any, any, any>
-> extends Context.TagClass<Self, Id, LayerMap<K, I, E>> {
-  /**
-   * A default layer for the `LayerMap` service.
-   */
-  readonly Default: Layer.Layer<
-    Self,
-    (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never) | LE,
-    | Exclude<R, (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never)>
-    | (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-  >
-
-  /**
-   * A default layer for the `LayerMap` service without the dependencies provided.
-   */
-  readonly DefaultWithoutDependencies: Layer.Layer<Self, LE, R>
-
-  /**
-   * Retrieves a Layer for the resources associated with the key.
-   */
-  readonly get: (key: K) => Layer.Layer<I, E, Self>
-
-  /**
-   * Retrieves a Runtime for the resources associated with the key.
-   */
-  readonly runtime: (key: K) => Effect.Effect<Runtime.Runtime<I>, E, Scope.Scope | Self>
-
-  /**
-   * Invalidates the resource associated with the key.
-   */
-  readonly invalidate: (key: K) => Effect.Effect<void, never, Self>
-}
-
-/**
- * @since 3.14.0
- * @category Service
- * @experimental
- *
- * Create a `LayerMap` service that provides a dynamic set of resources based on
- * a key.
- *
- * ```ts
- * import { NodeRuntime } from "@effect/platform-node"
- * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
- *
- * class Greeter extends Context.Tag("Greeter")<Greeter, {
- *   greet: Effect.Effect<string>
- * }>() {}
- *
- * // create a service that wraps a LayerMap
- * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
- *   // define the lookup function for the layer map
- *   //
- *   // The returned Layer will be used to provide the Greeter service for the
- *   // given name.
- *   lookup: (name: string) =>
- *     Layer.succeed(Greeter, {
- *       greet: Effect.succeed(`Hello, ${name}!`)
- *     }).pipe(
- *       Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
- *     ),
- *
- *   // If a layer is not used for a certain amount of time, it can be removed
- *   idleTimeToLive: "5 seconds",
- *
- *   // Supply the dependencies for the layers in the LayerMap
- *   dependencies: []
- * }) {}
- *
- * // usage
- * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
- *   // access and use the Greeter service
- *   const greeter = yield* Greeter
- *   yield* Effect.log(yield* greeter.greet)
- * }).pipe(
- *   // use the GreeterMap service to provide a variant of the Greeter service
- *   Effect.provide(GreeterMap.get("John"))
- * )
- *
- * // run the program
- * program.pipe(
- *   Effect.provide(GreeterMap.Default),
- *   NodeRuntime.runMain
- * )
- * ```
- */
-export const Service = <Self>() =>
-<
-  const Id extends string,
-  Options extends
-    | NoExcessProperties<
-      {
-        readonly lookup: (key: any) => Layer.Layer<any, any, any>
-        readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
-        readonly idleTimeToLive?: Duration.DurationInput | undefined
-        readonly preloadKeys?:
-          | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
-          | undefined
-      },
-      Options
-    >
-    | NoExcessProperties<{
-      readonly layers: Record<string, Layer.Layer<any, any, any>>
-      readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
-      readonly preload?: boolean
-    }, Options>
->(
-  id: Id,
-  options: Options
-): TagClass<
-  Self,
-  Id,
-  Options extends { readonly lookup: (key: infer K) => any } ? K
-    : Options extends { readonly layers: infer Layers } ? keyof Layers
-    : never,
-  Service.Success<Options>,
-  Options extends { readonly preload: true } ? never : Service.Error<Options>,
-  Service.Context<Options>,
-  Options extends { readonly preload: true } ? Service.Error<Options>
-    : Options extends { readonly preloadKey: Iterable<any> } ? Service.Error<Options>
-    : never,
-  Options extends { readonly dependencies: ReadonlyArray<any> } ? Options["dependencies"][number] : never
-> => {
-  const Err = globalThis.Error as any
-  const limit = Err.stackTraceLimit
-  Err.stackTraceLimit = 2
-  const creationError = new Err()
-  Err.stackTraceLimit = limit
-
-  function TagClass() {}
-  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
-  Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.GenericTag<Self, any>(id)))
-  TagClass.key = id
-  Object.defineProperty(TagClass, "stack", {
-    get() {
-      return creationError.stack
-    }
-  })
-
-  TagClass_.DefaultWithoutDependencies = Layer.scoped(
-    TagClass_,
-    "lookup" in options
-      ? make(options.lookup, options)
-      : fromRecord(options.layers as any, options)
-  )
-  TagClass_.Default = options.dependencies && options.dependencies.length > 0 ?
-    Layer.provide(TagClass_.DefaultWithoutDependencies, options.dependencies as any) :
-    TagClass_.DefaultWithoutDependencies
-
-  TagClass_.get = (key: string) => Layer.unwrapScoped(Effect.map(TagClass_, (layerMap) => layerMap.get(key)))
-  TagClass_.runtime = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.runtime(key))
-  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))
-
-  return TagClass as any
-}
-
-/**
- * @since 3.14.0
- * @category Service
- * @experimental
- */
-export declare namespace Service {
-  /**
-   * @since 3.14.0
-   * @category Service
-   * @experimental
-   */
-  export type Key<Options> = Options extends { readonly lookup: (key: infer K) => any } ? K
-    : Options extends { readonly layers: infer Layers } ? keyof Layers
-    : never
-
-  /**
-   * @since 3.14.0
-   * @category Service
-   * @experimental
-   */
-  export type Layers<Options> = Options extends { readonly lookup: (key: infer _K) => infer Layers } ? Layers
-    : Options extends { readonly layers: infer Layers } ? Layers[keyof Layers]
-    : never
-
-  /**
-   * @since 3.14.0
-   * @category Service
-   * @experimental
-   */
-  export type Success<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never
-
-  /**
-   * @since 3.14.0
-   * @category Service
-   * @experimental
-   */
-  export type Error<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
-
-  /**
-   * @since 3.14.0
-   * @category Service
-   * @experimental
-   */
-  export type Context<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never
-}