Lorem Ipsum MCP Server

"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.merge = exports.make = exports.isExecutionPlan = exports.TypeId = void 0; var Effect = _interopRequireWildcard(require("./Effect.js")); var internal = _interopRequireWildcard(require("./internal/executionPlan.js")); var Layer = _interopRequireWildcard(require("./Layer.js")); var _Pipeable = require("./Pipeable.js"); function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /** * @since 3.16.0 * @category Symbols * @experimental */ const TypeId = exports.TypeId = internal.TypeId; /** * @since 3.16.0 * @category Guards * @experimental */ const isExecutionPlan = exports.isExecutionPlan = internal.isExecutionPlan; /** * Create an `ExecutionPlan`, which can be used with `Effect.withExecutionPlan` or `Stream.withExecutionPlan`, allowing you to provide different resources for each step of execution until the effect succeeds or the plan is exhausted. * * ```ts * import { type AiLanguageModel } from "@effect/ai" * import type { Layer } from "effect" * import { Effect, ExecutionPlan, Schedule } from "effect" * * declare const layerBad: Layer.Layer<AiLanguageModel.AiLanguageModel> * declare const layerGood: Layer.Layer<AiLanguageModel.AiLanguageModel> * * const ThePlan = ExecutionPlan.make( * { * // First try with the bad layer 2 times with a 3 second delay between attempts * provide: layerBad, * attempts: 2, * schedule: Schedule.spaced(3000) * }, * // Then try with the bad layer 3 times with a 1 second delay between attempts * { * provide: layerBad, * attempts: 3, * schedule: Schedule.spaced(1000) * }, * // Finally try with the good layer. * // * // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided. * { * provide: layerGood * } * ) * * declare const effect: Effect.Effect< * void, * never, * AiLanguageModel.AiLanguageModel * > * const withPlan: Effect.Effect<void> = Effect.withExecutionPlan(effect, ThePlan) * ``` * * @since 3.16.0 * @category Constructors * @experimental */ const make = (...steps) => makeProto(steps.map((options, i) => { if (options.attempts && options.attempts < 1) { throw new Error(`ExecutionPlan.make: step[${i}].attempts must be greater than 0`); } return { schedule: options.schedule, attempts: options.attempts, while: options.while ? input => Effect.suspend(() => { const result = options.while(input); return typeof result === "boolean" ? Effect.succeed(result) : result; }) : undefined, provide: options.provide }; })); exports.make = make; const Proto = { [TypeId]: TypeId, get withRequirements() { const self = this; return Effect.contextWith(context => makeProto(self.steps.map(step => ({ ...step, provide: Layer.isLayer(step.provide) ? Layer.provide(step.provide, Layer.succeedContext(context)) : step.provide })))); }, pipe() { return (0, _Pipeable.pipeArguments)(this, arguments); } }; const makeProto = steps => { const self = Object.create(Proto); self.steps = steps; return self; }; /** * @since 3.16.0 * @category Combining * @experimental */ const merge = (...plans) => makeProto(plans.flatMap(plan => plan.steps)); exports.merge = merge; //# sourceMappingURL=ExecutionPlan.js.map