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

package/dist/Layer-ec0ab71c.cjs.prod.js

@@ -0,0 +1,687 @@
+'use strict';
+
+var Context_dist_effectContext = require('./Context-25a49952.cjs.prod.js');
+var layer = require('./layer-db9c42be.cjs.prod.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 = layer.LayerTypeId;
+
+/**
+ * @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 = layer.isLayer;
+
+/**
+ * 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 = layer.isFresh;
+
+/**
+ * Builds a layer into a scoped value.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const build = layer.build;
+
+/**
+ * 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 = layer.buildWithScope;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = layer.catchAll;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAllCause = layer.catchAllCause;
+
+/**
+ * Constructs a `Layer` that passes along the specified context as an
+ * output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = layer.context;
+
+/**
+ * Constructs a layer that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = layer.die;
+
+/**
+ * Constructs a layer that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = layer.dieSync;
+
+/**
+ * Replaces the layer's output with `void` and includes the layer only for its
+ * side-effects.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const discard = layer.discard;
+
+/**
+ * Constructs a layer from the specified effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effect = layer.fromEffect;
+
+/**
+ * Constructs a layer from the specified effect discarding it's output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effectDiscard = layer.fromEffectDiscard;
+
+/**
+ * Constructs a layer from the specified effect, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const effectContext = layer.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 = layer.extendScope;
+
+/**
+ * Constructs a layer that fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = layer.fail;
+
+/**
+ * Constructs a layer that fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = layer.failSync;
+
+/**
+ * Constructs a layer that fails with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = layer.failCause;
+
+/**
+ * Constructs a layer that fails with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = layer.failCauseSync;
+
+/**
+ * Constructs a layer dynamically based on the output of this layer.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = layer.flatMap;
+
+/**
+ * Flattens layers nested in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = layer.flatten;
+
+/**
+ * Creates a fresh version of this layer that will not be shared.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const fresh = layer.fresh;
+const fromFunction = layer.fromFunction;
+
+/**
+ * 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 = layer.launch;
+
+/**
+ * Returns a new layer whose output is mapped by the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = layer.map;
+
+/**
+ * Returns a layer with its error channel mapped using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = layer.mapError;
+
+/**
+ * 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 = layer.match;
+
+/**
+ * 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 = layer.matchCause;
+
+/**
+ * Returns a scoped effect that, if evaluated, will return the lazily computed
+ * result of this layer.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const memoize = layer.memoize;
+
+/**
+ * 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 = layer.merge;
+
+/**
+ * Merges all the layers together in parallel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const mergeAll = layer.mergeAll;
+
+/**
+ * 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 = layer.orDie;
+
+/**
+ * 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 = layer.orElse;
+
+/**
+ * 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 = layer.passthrough;
+
+/**
+ * Projects out part of one of the services output by this layer using the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const project = layer.project;
+
+/**
+ * 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 = layer.provide;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyEffect = layer.locallyEffect;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locally = layer.fiberRefLocally;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyWith = layer.fiberRefLocallyWith;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const locallyScoped = layer.fiberRefLocallyScoped;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const fiberRefLocallyScopedWith = layer.fiberRefLocallyScopedWith;
+
+/**
+ * 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 = layer.provideMerge;
+
+/**
+ * Retries constructing this layer according to the specified schedule.
+ *
+ * @since 2.0.0
+ * @category retrying
+ */
+const retry = layer.retry;
+
+/**
+ * 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 = layer.scope;
+
+/**
+ * Constructs a layer from the specified scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = layer.scoped;
+
+/**
+ * Constructs a layer from the specified scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scopedDiscard = layer.scopedDiscard;
+
+/**
+ * Constructs a layer from the specified scoped effect, which must return one
+ * or more services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scopedContext = layer.scopedContext;
+
+/**
+ * Constructs a layer that accesses and returns the specified service from the
+ * context.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const service = layer.service;
+
+/**
+ * Constructs a layer from the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = layer.succeed;
+
+/**
+ * Constructs a layer from the specified value, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedContext = layer.succeedContext;
+
+/**
+ * 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 = layer.suspend;
+
+/**
+ * Lazily constructs a layer from the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = layer.sync;
+
+/**
+ * Lazily constructs a layer from the specified value, which must return one or more
+ * services.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const syncContext = layer.syncContext;
+
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = layer.tap;
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = layer.tapError;
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapErrorCause = layer.tapErrorCause;
+
+/**
+ * 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 = layer.toRuntime;
+
+/**
+ * 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 = layer.use;
+
+/**
+ * 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 = layer.useMerge;
+
+/**
+ * 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 = layer.zipWithPar;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const unwrapEffect = self => {
+  const tag = Context_dist_effectContext.Tag();
+  return layer.flatMap(layer.fromEffect(tag, self), context => Context_dist_effectContext.get(context, tag));
+};
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const unwrapScoped = self => {
+  const tag = Context_dist_effectContext.Tag();
+  return layer.flatMap(layer.scoped(tag, self), context => Context_dist_effectContext.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
+});
+
+exports.Layer = Layer;
+exports.LayerTypeId = LayerTypeId;
+exports.build = build;
+exports.buildWithScope = buildWithScope;
+exports.catchAll = catchAll;
+exports.catchAllCause = catchAllCause;
+exports.context = context;
+exports.die = die;
+exports.dieSync = dieSync;
+exports.discard = discard;
+exports.effect = effect;
+exports.effectContext = effectContext;
+exports.effectDiscard = effectDiscard;
+exports.extendScope = extendScope;
+exports.fail = fail;
+exports.failCause = failCause;
+exports.failCauseSync = failCauseSync;
+exports.failSync = failSync;
+exports.fiberRefLocallyScopedWith = fiberRefLocallyScopedWith;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.fresh = fresh;
+exports.fromFunction = fromFunction;
+exports.isFresh = isFresh;
+exports.isLayer = isLayer;
+exports.launch = launch;
+exports.locally = locally;
+exports.locallyEffect = locallyEffect;
+exports.locallyScoped = locallyScoped;
+exports.locallyWith = locallyWith;
+exports.map = map;
+exports.mapError = mapError;
+exports.match = match;
+exports.matchCause = matchCause;
+exports.memoize = memoize;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.orDie = orDie;
+exports.orElse = orElse;
+exports.passthrough = passthrough;
+exports.project = project;
+exports.provide = provide;
+exports.provideMerge = provideMerge;
+exports.retry = retry;
+exports.scope = scope;
+exports.scoped = scoped;
+exports.scopedContext = scopedContext;
+exports.scopedDiscard = scopedDiscard;
+exports.service = service;
+exports.succeed = succeed;
+exports.succeedContext = succeedContext;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.syncContext = syncContext;
+exports.tap = tap;
+exports.tapError = tapError;
+exports.tapErrorCause = tapErrorCause;
+exports.toRuntime = toRuntime;
+exports.unwrapEffect = unwrapEffect;
+exports.unwrapScoped = unwrapScoped;
+exports.use = use;
+exports.useMerge = useMerge;
+exports.zipWithPar = zipWithPar;