effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/Layer-8586a429.esm.js

@@ -0,0 +1,623 @@
+import { T as Tag, g as get } from './Context-c41aa832.esm.js';
+import { L as LayerTypeId$1, i as isLayer$1, a as isFresh$1, b as build$1, c as buildWithScope$1, d as catchAll$1, g as catchAllCause$1, h as context$1, j as die$1, k as dieSync$1, l as discard$1, m as fromEffect, n as fromEffectDiscard, o as fromEffectContext, p as extendScope$1, q as fail$1, r as failSync$1, t as failCause$1, u as failCauseSync$1, f as flatMap$1, v as flatten$1, w as fresh$1, x as fromFunction$1, y as launch$1, z as map$1, A as mapError$1, B as match$1, C as matchCause$1, D as memoize$1, E as merge$1, F as mergeAll$1, G as orDie$1, H as orElse$1, I as passthrough$1, J as project$1, K as provide$1, M as locallyEffect$1, N as fiberRefLocally, O as fiberRefLocallyWith, P as fiberRefLocallyScoped, Q as fiberRefLocallyScopedWith$1, R as provideMerge$1, S as retry$1, T as scope$1, U as scoped$1, s as scopedDiscard$1, V as scopedContext$1, W as service$1, X as succeed$1, Y as succeedContext$1, Z as suspend$1, _ as sync$1, $ as syncContext$1, a0 as tap$1, a1 as tapError$1, a2 as tapErrorCause$1, a3 as toRuntime$1, a4 as use$1, a5 as useMerge$1, a6 as zipWithPar$1 } from './layer-35828af7.esm.js';
+
+/**
+ * A `Layer<RIn, E, ROut>` describes how to build one or more services in your
+ * application. Services can be injected into effects via
+ * `Effect.provideService`. Effects can require services via `Effect.service`.
+ *
+ * Layer can be thought of as recipes for producing bundles of services, given
+ * their dependencies (other services).
+ *
+ * Construction of services can be effectful and utilize resources that must be
+ * acquired and safely released when the services are done being utilized.
+ *
+ * By default layers are shared, meaning that if the same layer is used twice
+ * the layer will only be allocated a single time.
+ *
+ * Because of their excellent composition properties, layers are the idiomatic
+ * way in Effect-TS to create services that depend on other services.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const LayerTypeId = LayerTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Returns `true` if the specified value is a `Layer`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isLayer = isLayer$1;
+
+/**
+ * Returns `true` if the specified `Layer` is a fresh version that will not be
+ * shared, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFresh = isFresh$1;
+
+/**
+ * Builds a layer into a scoped value.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const build = build$1;
+
+/**
+ * Builds a layer into an `Effect` value. Any resources associated with this
+ * layer will be released when the specified scope is closed unless their scope
+ * has been extended. This allows building layers where the lifetime of some of
+ * the services output by the layer exceed the lifetime of the effect the
+ * layer is provided to.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const buildWithScope = buildWithScope$1;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = catchAll$1;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAllCause = catchAllCause$1;
+
+/**
+ * Constructs a `Layer` that passes along the specified context as an
+ * output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = context$1;
+
+/**
+ * Constructs a layer that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * Constructs a layer that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = dieSync$1;
+
+/**
+ * Replaces the layer's output with `void` and includes the layer only for its
+ * side-effects.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const discard = discard$1;
+
+/**
+ * Constructs a layer from the specified effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effect = fromEffect;
+
+/**
+ * Constructs a layer from the specified effect discarding it's output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effectDiscard = fromEffectDiscard;
+
+/**
+ * Constructs a layer from the specified effect, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effectContext = fromEffectContext;
+
+/**
+ * Extends the scope of this layer, returning a new layer that when provided
+ * to an effect will not immediately release its associated resources when
+ * that effect completes execution but instead when the scope the resulting
+ * effect depends on is closed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const extendScope = extendScope$1;
+
+/**
+ * Constructs a layer that fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * Constructs a layer that fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * Constructs a layer that fails with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * Constructs a layer that fails with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = failCauseSync$1;
+
+/**
+ * Constructs a layer dynamically based on the output of this layer.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = flatMap$1;
+
+/**
+ * Flattens layers nested in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = flatten$1;
+
+/**
+ * Creates a fresh version of this layer that will not be shared.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const fresh = fresh$1;
+const fromFunction = fromFunction$1;
+
+/**
+ * Builds this layer and uses it until it is interrupted. This is useful when
+ * your entire application is a layer, such as an HTTP server.
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const launch = launch$1;
+
+/**
+ * Returns a new layer whose output is mapped by the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Returns a layer with its error channel mapped using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * Feeds the error or output services of this layer into the input of either
+ * the specified `failure` or `success` layers, resulting in a new layer with
+ * the inputs of this layer, and the error or outputs of the specified layer.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = match$1;
+
+/**
+ * Feeds the error or output services of this layer into the input of either
+ * the specified `failure` or `success` layers, resulting in a new layer with
+ * the inputs of this layer, and the error or outputs of the specified layer.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const matchCause = matchCause$1;
+
+/**
+ * Returns a scoped effect that, if evaluated, will return the lazily computed
+ * result of this layer.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const memoize = memoize$1;
+
+/**
+ * Combines this layer with the specified layer, producing a new layer that
+ * has the inputs and outputs of both.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const merge = merge$1;
+
+/**
+ * Merges all the layers together in parallel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const mergeAll = mergeAll$1;
+
+/**
+ * Translates effect failure into death of the fiber, making all failures
+ * unchecked and not a part of the type of the layer.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = orDie$1;
+
+/**
+ * Executes this layer and returns its output, if it succeeds, but otherwise
+ * executes the specified layer.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = orElse$1;
+
+/**
+ * Returns a new layer that produces the outputs of this layer but also
+ * passes through the inputs.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const passthrough = passthrough$1;
+
+/**
+ * Projects out part of one of the services output by this layer using the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const project = project$1;
+
+/**
+ * Feeds the output services of this builder into the input of the specified
+ * builder, resulting in a new builder with the inputs of this builder as
+ * well as any leftover inputs, and the outputs of the specified builder.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const provide = provide$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyEffect = locallyEffect$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locally = fiberRefLocally;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyWith = fiberRefLocallyWith;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyScoped = fiberRefLocallyScoped;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const fiberRefLocallyScopedWith = fiberRefLocallyScopedWith$1;
+
+/**
+ * Feeds the output services of this layer into the input of the specified
+ * layer, resulting in a new layer with the inputs of this layer, and the
+ * outputs of both layers.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const provideMerge = provideMerge$1;
+
+/**
+ * Retries constructing this layer according to the specified schedule.
+ *
+ * @since 2.0.0
+ * @category retrying
+ */
+const retry = retry$1;
+
+/**
+ * A layer that constructs a scope and closes it when the workflow the layer
+ * is provided to completes execution, whether by success, failure, or
+ * interruption. This can be used to close a scope when providing a layer to a
+ * workflow.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scope = scope$1;
+
+/**
+ * Constructs a layer from the specified scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = scoped$1;
+
+/**
+ * Constructs a layer from the specified scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scopedDiscard = scopedDiscard$1;
+
+/**
+ * Constructs a layer from the specified scoped effect, which must return one
+ * or more services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scopedContext = scopedContext$1;
+
+/**
+ * Constructs a layer that accesses and returns the specified service from the
+ * context.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const service = service$1;
+
+/**
+ * Constructs a layer from the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Constructs a layer from the specified value, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedContext = succeedContext$1;
+
+/**
+ * Lazily constructs a layer. This is useful to avoid infinite recursion when
+ * creating layers that refer to themselves.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = suspend$1;
+
+/**
+ * Lazily constructs a layer from the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * Lazily constructs a layer from the specified value, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const syncContext = syncContext$1;
+
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = tap$1;
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = tapError$1;
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapErrorCause = tapErrorCause$1;
+
+/**
+ * Converts a layer that requires no services into a scoped runtime, which can
+ * be used to execute effects.
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+const toRuntime = toRuntime$1;
+
+/**
+ * Feeds the output services of this builder into the input of the specified
+ * builder, resulting in a new builder with the inputs of this builder as
+ * well as any leftover inputs, and the outputs of the specified builder.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const use = use$1;
+
+/**
+ * Feeds the output services of this layer into the input of the specified
+ * layer, resulting in a new layer with the inputs of this layer, and the
+ * outputs of both layers.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const useMerge = useMerge$1;
+
+/**
+ * Combines this layer the specified layer, producing a new layer that has the
+ * inputs of both, and the outputs of both combined using the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithPar = zipWithPar$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const unwrapEffect = self => {
+  const tag = Tag();
+  return flatMap$1(fromEffect(tag, self), context => get(context, tag));
+};
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const unwrapScoped = self => {
+  const tag = Tag();
+  return flatMap$1(scoped$1(tag, self), context => get(context, tag));
+};
+
+var Layer = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  LayerTypeId: LayerTypeId,
+  isLayer: isLayer,
+  isFresh: isFresh,
+  build: build,
+  buildWithScope: buildWithScope,
+  catchAll: catchAll,
+  catchAllCause: catchAllCause,
+  context: context,
+  die: die,
+  dieSync: dieSync,
+  discard: discard,
+  effect: effect,
+  effectDiscard: effectDiscard,
+  effectContext: effectContext,
+  extendScope: extendScope,
+  fail: fail,
+  failSync: failSync,
+  failCause: failCause,
+  failCauseSync: failCauseSync,
+  flatMap: flatMap,
+  flatten: flatten,
+  fresh: fresh,
+  'function': fromFunction,
+  launch: launch,
+  map: map,
+  mapError: mapError,
+  match: match,
+  matchCause: matchCause,
+  memoize: memoize,
+  merge: merge,
+  mergeAll: mergeAll,
+  orDie: orDie,
+  orElse: orElse,
+  passthrough: passthrough,
+  project: project,
+  provide: provide,
+  locallyEffect: locallyEffect,
+  locally: locally,
+  locallyWith: locallyWith,
+  locallyScoped: locallyScoped,
+  fiberRefLocallyScopedWith: fiberRefLocallyScopedWith,
+  provideMerge: provideMerge,
+  retry: retry,
+  scope: scope,
+  scoped: scoped,
+  scopedDiscard: scopedDiscard,
+  scopedContext: scopedContext,
+  service: service,
+  succeed: succeed,
+  succeedContext: succeedContext,
+  suspend: suspend,
+  sync: sync,
+  syncContext: syncContext,
+  tap: tap,
+  tapError: tapError,
+  tapErrorCause: tapErrorCause,
+  toRuntime: toRuntime,
+  use: use,
+  useMerge: useMerge,
+  zipWithPar: zipWithPar,
+  unwrapEffect: unwrapEffect,
+  unwrapScoped: unwrapScoped
+});
+
+export { suspend as $, launch as A, map as B, mapError as C, match as D, matchCause as E, memoize as F, mergeAll as G, orDie as H, orElse as I, passthrough as J, project as K, Layer as L, provide as M, locallyEffect as N, locally as O, locallyWith as P, locallyScoped as Q, fiberRefLocallyScopedWith as R, provideMerge as S, retry as T, scope as U, scoped as V, scopedDiscard as W, scopedContext as X, service as Y, succeed as Z, succeedContext as _, unwrapScoped as a, sync as a0, syncContext as a1, tap as a2, tapError as a3, tapErrorCause as a4, toRuntime as a5, use as a6, useMerge as a7, zipWithPar as a8, build as b, context as c, LayerTypeId as d, effect as e, isFresh as f, buildWithScope as g, catchAll as h, isLayer as i, catchAllCause as j, die as k, dieSync as l, merge as m, discard as n, effectDiscard as o, effectContext as p, extendScope as q, fail as r, failSync as s, failCause as t, unwrapEffect as u, failCauseSync as v, flatMap as w, flatten as x, fresh as y, fromFunction as z };