Aktueller Stand

backend/node_modules/effect/dist/dts/ManagedRuntime.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js";
+import type * as Exit from "./Exit.js";
+import type * as Fiber from "./Fiber.js";
+import type * as Layer from "./Layer.js";
+import type * as Runtime from "./Runtime.js";
+import type * as Unify from "./Unify.js";
+/**
+ * @since 3.9.0
+ * @category symbol
+ */
+export declare const TypeId: unique symbol;
+/**
+ * @since 3.9.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId;
+/**
+ * Checks if the provided argument is a `ManagedRuntime`.
+ *
+ * @since 3.9.0
+ * @category guards
+ */
+export declare const isManagedRuntime: (input: unknown) => input is ManagedRuntime<unknown, unknown>;
+/**
+ * @since 3.4.0
+ */
+export declare namespace ManagedRuntime {
+    /**
+     * @category type-level
+     * @since 3.4.0
+     */
+    type Context<T extends ManagedRuntime<never, any>> = [T] extends [ManagedRuntime<infer R, infer _E>] ? R : never;
+    /**
+     * @category type-level
+     * @since 3.4.0
+     */
+    type Error<T extends ManagedRuntime<never, any>> = [T] extends [ManagedRuntime<infer _R, infer E>] ? E : never;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface ManagedRuntime<in R, out ER> extends Effect.Effect<Runtime.Runtime<R>, ER> {
+    readonly [TypeId]: TypeId;
+    readonly memoMap: Layer.MemoMap;
+    readonly runtimeEffect: Effect.Effect<Runtime.Runtime<R>, ER>;
+    readonly runtime: () => Promise<Runtime.Runtime<R>>;
+    /**
+     * Executes the effect using the provided Scheduler or using the global
+     * Scheduler if not provided
+     */
+    readonly runFork: <A, E>(self: Effect.Effect<A, E, R>, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber<A, E | ER>;
+    /**
+     * Executes the effect synchronously returning the exit.
+     *
+     * This method is effectful and should only be invoked at the edges of your
+     * program.
+     */
+    readonly runSyncExit: <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, ER | E>;
+    /**
+     * Executes the effect synchronously throwing in case of errors or async boundaries.
+     *
+     * This method is effectful and should only be invoked at the edges of your
+     * program.
+     */
+    readonly runSync: <A, E>(effect: Effect.Effect<A, E, R>) => A;
+    /**
+     * Executes the effect asynchronously, eventually passing the exit value to
+     * the specified callback.
+     *
+     * This method is effectful and should only be invoked at the edges of your
+     * program.
+     */
+    readonly runCallback: <A, E>(effect: Effect.Effect<A, E, R>, options?: Runtime.RunCallbackOptions<A, E | ER> | undefined) => Runtime.Cancel<A, E | ER>;
+    /**
+     * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+     * with the value of the effect once the effect has been executed, or will be
+     * rejected with the first error or exception throw by the effect.
+     *
+     * This method is effectful and should only be used at the edges of your
+     * program.
+     */
+    readonly runPromise: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<A>;
+    /**
+     * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+     * with the `Exit` state of the effect once the effect has been executed.
+     *
+     * This method is effectful and should only be used at the edges of your
+     * program.
+     */
+    readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<Exit.Exit<A, ER | E>>;
+    /**
+     * Dispose of the resources associated with the runtime.
+     */
+    readonly dispose: () => Promise<void>;
+    /**
+     * Dispose of the resources associated with the runtime.
+     */
+    readonly disposeEffect: Effect.Effect<void, never, never>;
+    readonly [Unify.typeSymbol]?: unknown;
+    readonly [Unify.unifySymbol]?: ManagedRuntimeUnify<this>;
+    readonly [Unify.ignoreSymbol]?: ManagedRuntimeUnifyIgnore;
+}
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ManagedRuntimeUnify<A extends {
+    [Unify.typeSymbol]?: any;
+}> extends Effect.EffectUnify<A> {
+    ManagedRuntime?: () => Extract<A[Unify.typeSymbol], ManagedRuntime<any, any>>;
+}
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface ManagedRuntimeUnifyIgnore extends Effect.EffectUnifyIgnore {
+    Effect?: true;
+}
+/**
+ * Convert a Layer into an ManagedRuntime, that can be used to run Effect's using
+ * your services.
+ *
+ * @since 2.0.0
+ * @category runtime class
+ * @example
+ * ```ts
+ * import { Console, Effect, Layer, ManagedRuntime } from "effect"
+ *
+ * class Notifications extends Effect.Tag("Notifications")<
+ *   Notifications,
+ *   { readonly notify: (message: string) => Effect.Effect<void> }
+ * >() {
+ *   static Live = Layer.succeed(this, { notify: (message) => Console.log(message) })
+ * }
+ *
+ * async function main() {
+ *   const runtime = ManagedRuntime.make(Notifications.Live)
+ *   await runtime.runPromise(Notifications.notify("Hello, world!"))
+ *   await runtime.dispose()
+ * }
+ *
+ * main()
+ * ```
+ */
+export declare const make: <R, E>(layer: Layer.Layer<R, E, never>, memoMap?: Layer.MemoMap | undefined) => ManagedRuntime<R, E>;
+//# sourceMappingURL=ManagedRuntime.d.ts.map