@duplojs/utils 1.5.15 → 1.6.1

package/dist/flow/finalizer.d.ts

@@ -0,0 +1,47 @@
+import { type Finalizer } from "./theFlow";
+/**
+ * Registers a final callback handled by the flow runner.
+ * 
+ * **Supported call styles:**
+ * - Classic: `finalizer(theFunction)` -> yields a finalizer effect
+ * 
+ * `finalizer` registers logic that is executed by the flow runner when the flow completes.
+ * It is useful for cleanup or post-processing that should stay inside the flow effect system.
+ * Use it inside `F.run(...)` or inside subflows executed by `F.exec(...)`.
+ * 
+ * ```ts
+ * F.run(
+ * 	function *() {
+ * 		yield *F.finalizer(() => void console.log("close connection"));
+ * 		return "done";
+ * 	},
+ * ); // "done"
+ * 
+ * F.run(
+ * 	function *() {
+ * 		yield *F.finalizer(() => void console.log("clear cache"));
+ * 		yield *F.breakIf(2, (value) => value === 2);
+ * 		return "done";
+ * 	},
+ * ); // 2
+ * 
+ * await F.run(
+ * 	async function *() {
+ * 		yield *F.finalizer(async() => {
+ * 			await Promise.resolve();
+ * 		});
+ * 		return Promise.resolve("done");
+ * 	},
+ * ); // Promise<"done">
+ * ```
+ * 
+ * @remarks
+ * - Finalizers are collected by the flow runner and executed after the flow ends
+ * 
+ * @see [`F.defer`](https://utils.duplojs.dev/en/v1/api/flow/defer) For another cleanup-oriented effect
+ * @see https://utils.duplojs.dev/en/v1/api/flow/finalizer
+ * 
+ * @namespace F
+ * 
+ */
+export declare function finalizer<GenericOutput extends unknown>(theFunction: () => GenericOutput): (Generator<Finalizer<GenericOutput>, undefined> | (GenericOutput extends Promise<unknown> ? AsyncGenerator<Finalizer<GenericOutput>, undefined> : never));

package/dist/flow/finalizer.mjs

@@ -0,0 +1,10 @@
+import { createFinalizer } from './theFlow/finalizer.mjs';
+
+/**
+ * {@include flow/finalizer/index.md}
+ */
+function* finalizer(theFunction) {
+    yield createFinalizer(theFunction);
+}
+
+export { finalizer };

package/dist/flow/index.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var run = require('./run.cjs');
+var index = require('./theFlow/index.cjs');
+var breakIf = require('./breakIf.cjs');
+var defer$1 = require('./defer.cjs');
+var exec = require('./exec.cjs');
+var exitIf = require('./exitIf.cjs');
+var finalizer$1 = require('./finalizer.cjs');
+var inject = require('./inject.cjs');
+var step$1 = require('./step.cjs');
+var initializer = require('./initializer.cjs');
+var kind = require('./kind.cjs');
+var step = require('./theFlow/step.cjs');
+var exit = require('./theFlow/exit.cjs');
+var _break = require('./theFlow/break.cjs');
+var injection = require('./theFlow/injection.cjs');
+var defer = require('./theFlow/defer.cjs');
+var finalizer = require('./theFlow/finalizer.cjs');
+var dependence = require('./theFlow/dependence.cjs');
+
+
+
+exports.MissingDependenceError = run.MissingDependenceError;
+exports.run = run.run;
+exports.create = index.create;
+exports.theFlowKind = index.theFlowKind;
+exports.breakIf = breakIf.breakIf;
+exports.defer = defer$1.defer;
+exports.exec = exec.exec;
+exports.exitIf = exitIf.exitIf;
+exports.finalizer = finalizer$1.finalizer;
+exports.inject = inject.inject;
+exports.step = step$1.step;
+exports.createInitializer = initializer.createInitializer;
+exports.createFlowKind = kind.createFlowKind;
+exports.createStep = step.createStep;
+exports.stepKind = step.stepKind;
+exports.createExit = exit.createExit;
+exports.exitKind = exit.exitKind;
+exports.breakKind = _break.breakKind;
+exports.createBreak = _break.createBreak;
+exports.createInjection = injection.createInjection;
+exports.injectionKind = injection.injectionKind;
+exports.createDefer = defer.createDefer;
+exports.deferKind = defer.deferKind;
+exports.createFinalizer = finalizer.createFinalizer;
+exports.finalizerKind = finalizer.finalizerKind;
+exports.createDependence = dependence.createDependence;
+exports.dependenceHandlerKind = dependence.dependenceHandlerKind;

package/dist/flow/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types";
+export * from "./run";
+export * from "./theFlow";
+export * from "./breakIf";
+export * from "./defer";
+export * from "./exec";
+export * from "./exitIf";
+export * from "./finalizer";
+export * from "./inject";
+export * from "./step";
+export * from "./initializer";
+export * from "./kind";

package/dist/flow/index.mjs

@@ -0,0 +1,18 @@
+export { MissingDependenceError, run } from './run.mjs';
+export { create, theFlowKind } from './theFlow/index.mjs';
+export { breakIf } from './breakIf.mjs';
+export { defer } from './defer.mjs';
+export { exec } from './exec.mjs';
+export { exitIf } from './exitIf.mjs';
+export { finalizer } from './finalizer.mjs';
+export { inject } from './inject.mjs';
+export { step } from './step.mjs';
+export { createInitializer } from './initializer.mjs';
+export { createFlowKind } from './kind.mjs';
+export { createStep, stepKind } from './theFlow/step.mjs';
+export { createExit, exitKind } from './theFlow/exit.mjs';
+export { breakKind, createBreak } from './theFlow/break.mjs';
+export { createInjection, injectionKind } from './theFlow/injection.mjs';
+export { createDefer, deferKind } from './theFlow/defer.mjs';
+export { createFinalizer, finalizerKind } from './theFlow/finalizer.mjs';
+export { createDependence, dependenceHandlerKind } from './theFlow/dependence.mjs';

package/dist/flow/initializer.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var defer = require('./theFlow/defer.cjs');
+var finalizer = require('./theFlow/finalizer.cjs');
+
+/**
+ * {@include flow/createInitializer/index.md}
+ */
+function createInitializer(initializer, params) {
+    return (...args) => {
+        const result = initializer(...args);
+        const defer$1 = params.defer;
+        const finalizer$1 = params.finalizer;
+        if (result instanceof Promise) {
+            return (async function* () {
+                const awaitedResult = await result;
+                if (defer$1) {
+                    yield defer.createDefer(() => defer$1(awaitedResult));
+                }
+                if (finalizer$1) {
+                    yield finalizer.createFinalizer(() => finalizer$1(awaitedResult));
+                }
+                return awaitedResult;
+            })();
+        }
+        return (function* () {
+            if (defer$1) {
+                yield defer.createDefer(() => defer$1(result));
+            }
+            if (finalizer$1) {
+                yield finalizer.createFinalizer(() => finalizer$1(result));
+            }
+            return result;
+        })();
+    };
+}
+
+exports.createInitializer = createInitializer;

package/dist/flow/initializer.d.ts

@@ -0,0 +1,75 @@
+import { type AnyFunction, type IsExtends, type Or } from "../common";
+import { type RequireAtLeastOne } from "../object";
+import { type Defer, type Finalizer } from "./theFlow";
+export interface CreateInitializerParams<GenericOutput extends unknown = unknown> {
+    defer?(output: Awaited<GenericOutput>): unknown;
+    finalizer?(output: Awaited<GenericOutput>): unknown;
+}
+export type Initializer<GenericArgs extends unknown[], GenericOutput extends unknown, GenericParams extends CreateInitializerParams<GenericOutput>> = Extract<(...args: GenericArgs) => (((GenericParams["finalizer"] extends AnyFunction ? Finalizer<ReturnType<GenericParams["finalizer"]>> : never) | (GenericParams["defer"] extends AnyFunction ? Defer<ReturnType<GenericParams["defer"]>> : never)) extends infer InferredEffect ? (Generator<InferredEffect, Awaited<GenericOutput>> | (Or<[
+    IsExtends<GenericOutput, Promise<unknown>>,
+    IsExtends<InferredEffect, Finalizer<Promise<unknown>>>,
+    IsExtends<InferredEffect, Defer<Promise<unknown>>>
+]> extends true ? AsyncGenerator<InferredEffect, Awaited<GenericOutput>> : never)) : never), any>;
+/**
+ * Creates an initializer that returns a value and automatically registers flow cleanup effects.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createInitializer(initializer, params)` -> returns a function that can be yielded inside a flow
+ * 
+ * `createInitializer` wraps an initializer function and turns its result into a flow-friendly generator.
+ * Depending on the provided options, it can register a `defer` callback, a `finalizer` callback, or both, using the produced value.
+ * The returned initializer can then be executed inside `F.run(...)` like any other flow generator.
+ * 
+ * ```ts
+ * const userInitializer = F.createInitializer(
+ * 	(name: string) => ({ name }),
+ * 	{ defer: (user) => void console.log(`close:${user.name}`) },
+ * );
+ * 
+ * F.run(
+ * 	function *() {
+ * 		return yield *userInitializer("Ada");
+ * 	},
+ * ); // { name: "Ada" }
+ * 
+ * const finalizerLogs: string[] = [];
+ * const tokenInitializer = F.createInitializer(
+ * 	(id: number) => `token-${id}`,
+ * 	{ finalizer: (token) => finalizerLogs.push(token) },
+ * );
+ * 
+ * F.run(
+ * 	function *() {
+ * 		return yield *tokenInitializer(42);
+ * 	},
+ * ); // "token-42"
+ * 
+ * const asyncInitializer = F.createInitializer(
+ * 	(name: string) => Promise.resolve({
+ * 		name,
+ * 		ready: true,
+ * 	}),
+ * 	{ defer: (user) => void console.log(`async:${user.name}`) },
+ * );
+ * 
+ * void await F.run(
+ * 	async function *() {
+ * 		const value = yield *asyncInitializer("Linus");
+ * 		// Promise<{ name: string; ready: true }>
+ * 
+ * 		return;
+ * 	},
+ * );
+ * ```
+ * 
+ * @remarks
+ * - `createInitializer` is useful when a setup step should also declare matching cleanup logic
+ * 
+ * @see [`F.defer`](https://utils.duplojs.dev/en/v1/api/flow/defer) For cleanup callbacks
+ * @see [`F.finalizer`](https://utils.duplojs.dev/en/v1/api/flow/finalizer) For final callbacks
+ * @see https://utils.duplojs.dev/en/v1/api/flow/createInitializer
+ * 
+ * @namespace F
+ * 
+ */
+export declare function createInitializer<GenericArgs extends unknown[], GenericOutput extends unknown, GenericParams extends CreateInitializerParams<GenericOutput>>(initializer: (...args: GenericArgs) => GenericOutput, params: GenericParams & RequireAtLeastOne<GenericParams, keyof CreateInitializerParams>): Initializer<GenericArgs, GenericOutput, GenericParams>;

package/dist/flow/initializer.mjs

@@ -0,0 +1,36 @@
+import { createDefer } from './theFlow/defer.mjs';
+import { createFinalizer } from './theFlow/finalizer.mjs';
+
+/**
+ * {@include flow/createInitializer/index.md}
+ */
+function createInitializer(initializer, params) {
+    return (...args) => {
+        const result = initializer(...args);
+        const defer = params.defer;
+        const finalizer = params.finalizer;
+        if (result instanceof Promise) {
+            return (async function* () {
+                const awaitedResult = await result;
+                if (defer) {
+                    yield createDefer(() => defer(awaitedResult));
+                }
+                if (finalizer) {
+                    yield createFinalizer(() => finalizer(awaitedResult));
+                }
+                return awaitedResult;
+            })();
+        }
+        return (function* () {
+            if (defer) {
+                yield createDefer(() => defer(result));
+            }
+            if (finalizer) {
+                yield createFinalizer(() => finalizer(result));
+            }
+            return result;
+        })();
+    };
+}
+
+export { createInitializer };

package/dist/flow/inject.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var injection = require('./theFlow/injection.cjs');
+
+/**
+ * {@include flow/inject/index.md}
+ */
+function* inject(dependenceHandler) {
+    let dependence = undefined;
+    yield injection.createInjection({
+        dependenceHandler,
+        inject: (value) => {
+            dependence = value;
+        },
+    });
+    return dependence;
+}
+
+exports.inject = inject;

package/dist/flow/inject.d.ts

@@ -0,0 +1,46 @@
+import { type DependenceHandler, type Injection } from "./theFlow";
+/**
+ * Requests a dependency from the flow runner.
+ * 
+ * **Supported call styles:**
+ * - Classic: `inject(dependenceHandler)` -> yields an injection effect and returns the injected value
+ * 
+ * `inject` lets a flow declare that it needs a dependency by using a dependence handler created with `F.createDependence(...)`.
+ * When `F.run(...)` or `F.exec(...)` receives matching dependencies, the requested value is injected back into the flow.
+ * If the dependency is missing, the runner throws a missing dependence error.
+ * 
+ * ```ts
+ * const database = F.createDependence("database")<string>;
+ * 
+ * F.run(
+ * 	function *() {
+ * 		const connection = yield *F.inject(database);
+ * 		return connection;
+ * 	},
+ * 	{ dependencies: { database: "main-db" } },
+ * ); // "main-db"
+ * 
+ * F.run(
+ * 	function *() {
+ * 		return yield *F.exec(
+ * 			function *() {
+ * 				const connection = yield *F.inject(database);
+ * 				return connection;
+ * 			},
+ * 			{ dependencies: { database: "replica-db" } },
+ * 		);
+ * 	},
+ * 	{ dependencies: { database: "main-db" } },
+ * ); // "replica-db"
+ * ```
+ * 
+ * @remarks
+ * - `inject` keeps dependencies explicit in flow definitions
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For providing dependencies
+ * @see https://utils.duplojs.dev/en/v1/api/flow/inject
+ * 
+ * @namespace F
+ * 
+ */
+export declare function inject<GenericDependenceHandler extends DependenceHandler>(dependenceHandler: GenericDependenceHandler): Generator<Injection<GenericDependenceHandler>, ReturnType<GenericDependenceHandler>>;

package/dist/flow/inject.mjs

@@ -0,0 +1,17 @@
+import { createInjection } from './theFlow/injection.mjs';
+
+/**
+ * {@include flow/inject/index.md}
+ */
+function* inject(dependenceHandler) {
+    let dependence = undefined;
+    yield createInjection({
+        dependenceHandler,
+        inject: (value) => {
+            dependence = value;
+        },
+    });
+    return dependence;
+}
+
+export { inject };

package/dist/flow/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const createFlowKind = kind.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsFlow");
+
+exports.createFlowKind = createFlowKind;

package/dist/flow/kind.d.ts

@@ -0,0 +1 @@
+export declare const createFlowKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsFlow/${GenericName}`, GenericKindValue>>;

package/dist/flow/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '../common/kind.mjs';
+
+const createFlowKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsFlow");
+
+export { createFlowKind };

package/dist/flow/run.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+var index = require('./theFlow/index.cjs');
+var defer = require('./theFlow/defer.cjs');
+var finalizer = require('./theFlow/finalizer.cjs');
+var kind$1 = require('./kind.cjs');
+var dependence = require('./theFlow/dependence.cjs');
+var _break = require('./theFlow/break.cjs');
+var exit = require('./theFlow/exit.cjs');
+var step = require('./theFlow/step.cjs');
+var injection = require('./theFlow/injection.cjs');
+var justExec = require('../common/justExec.cjs');
+var kind = require('../common/kind.cjs');
+
+class MissingDependenceError extends kind.kindHeritage("missing-dependence-error", kind$1.createFlowKind("missing-dependence-error"), Error) {
+    dependenceHandler;
+    constructor(dependenceHandler) {
+        super({}, [`Missing dependence : ${dependence.dependenceHandlerKind.getValue(dependenceHandler)}`]);
+        this.dependenceHandler = dependenceHandler;
+    }
+}
+/**
+ * {@include flow/run/index.md}
+ */
+function run(theFlow, ...[params]) {
+    let result = undefined;
+    let deferFunctions = undefined;
+    let steps = undefined;
+    const generator = typeof theFlow === "function"
+        ? theFlow(params?.input)
+        : index.theFlowKind.getValue(theFlow).run(params?.input);
+    if (Symbol.asyncIterator in generator) {
+        return (async function () {
+            try {
+                do {
+                    result = await generator.next();
+                    if (result.done === true) {
+                        break;
+                    }
+                    else if (_break.breakKind.has(result.value)) {
+                        result = await generator.return(_break.breakKind.getValue(result.value).value);
+                        break;
+                    }
+                    else if (exit.exitKind.has(result.value)) {
+                        result = await generator.return(exit.exitKind.getValue(result.value).value);
+                        break;
+                    }
+                    else if (defer.deferKind.has(result.value)) {
+                        deferFunctions ??= [];
+                        deferFunctions.push(defer.deferKind.getValue(result.value));
+                    }
+                    else if (finalizer.finalizerKind.has(result.value)) {
+                        deferFunctions ??= [];
+                        deferFunctions.push(finalizer.finalizerKind.getValue(result.value));
+                    }
+                    else if (params?.includeDetails === true
+                        && step.stepKind.has(result.value)) {
+                        steps ??= [];
+                        steps.push(step.stepKind.getValue(result.value));
+                    }
+                    else if (injection.injectionKind.has(result.value)) {
+                        const injectionProperties = injection.injectionKind.getValue(result.value);
+                        const dependenceName = dependence.dependenceHandlerKind.getValue(injectionProperties.dependenceHandler);
+                        if (!params?.dependencies
+                            || !(dependenceName in params.dependencies)) {
+                            throw new MissingDependenceError(injectionProperties.dependenceHandler);
+                        }
+                        injectionProperties.inject(params.dependencies[dependenceName]);
+                    }
+                } while (true);
+                return params?.includeDetails === true
+                    ? {
+                        result: result.value,
+                        steps: steps ?? [],
+                    }
+                    : result.value;
+            }
+            finally {
+                await generator.return(undefined);
+                if (deferFunctions) {
+                    await Promise.all(deferFunctions.map(justExec.justExec));
+                }
+            }
+        })();
+    }
+    try {
+        do {
+            result = generator.next();
+            if (result.done === true) {
+                break;
+            }
+            else if (_break.breakKind.has(result.value)) {
+                result = generator.return(_break.breakKind.getValue(result.value).value);
+                break;
+            }
+            else if (exit.exitKind.has(result.value)) {
+                result = generator.return(exit.exitKind.getValue(result.value).value);
+                break;
+            }
+            else if (defer.deferKind.has(result.value)) {
+                deferFunctions ??= [];
+                deferFunctions.push(defer.deferKind.getValue(result.value));
+            }
+            else if (finalizer.finalizerKind.has(result.value)) {
+                deferFunctions ??= [];
+                deferFunctions.push(finalizer.finalizerKind.getValue(result.value));
+            }
+            else if (params?.includeDetails === true
+                && step.stepKind.has(result.value)) {
+                steps ??= [];
+                steps.push(step.stepKind.getValue(result.value));
+            }
+            else if (injection.injectionKind.has(result.value)) {
+                const injectionProperties = injection.injectionKind.getValue(result.value);
+                const dependenceName = dependence.dependenceHandlerKind.getValue(injectionProperties.dependenceHandler);
+                if (!params?.dependencies
+                    || !(dependenceName in params.dependencies)) {
+                    throw new MissingDependenceError(injectionProperties.dependenceHandler);
+                }
+                injectionProperties.inject(params.dependencies[dependenceName]);
+            }
+        } while (true);
+        return (params?.includeDetails === true
+            ? {
+                result: result.value,
+                steps: steps ?? [],
+            }
+            : result.value);
+    }
+    finally {
+        generator.return(undefined);
+        if (deferFunctions) {
+            deferFunctions.map(justExec.justExec);
+        }
+    }
+}
+
+exports.MissingDependenceError = MissingDependenceError;
+exports.run = run;

package/dist/flow/run.d.ts

@@ -0,0 +1,80 @@
+import { type SimplifyTopLevel, type IsEqual, type IsExtends, type Or } from "../common";
+import { type TheFlow, type TheFlowFunction, type FlowInput, type WrapFlow, type TheFlowGenerator, type Exit, type Break, type Step, type FlowDependencies, type DependenceHandler, type ExtractFlowGenerator } from "./theFlow";
+type ComputeRunParams<GenericInput extends unknown, GenericDependencies extends Record<string, unknown>> = SimplifyTopLevel<(Or<[
+    IsEqual<GenericInput, unknown>,
+    IsEqual<GenericInput, never>,
+    IsExtends<GenericInput, undefined>
+]> extends true ? {
+    input?: GenericInput;
+} : {
+    input: GenericInput;
+}) & {
+    includeDetails?: boolean;
+} & ({} extends GenericDependencies ? {
+    dependencies?: GenericDependencies;
+} : {
+    dependencies: GenericDependencies;
+})>;
+export interface FlowDetails<GenericValue extends unknown, GenericStepName extends string> {
+    result: GenericValue;
+    steps: GenericStepName[];
+}
+export type RunResult<GenericFlow extends TheFlow, GenericIncludeDetails extends boolean = false> = (GenericFlow extends TheFlow<infer InferredFunction> ? InferredFunction extends TheFlowFunction<any, infer InferredGenerator> ? InferredGenerator extends TheFlowGenerator<infer InferredOutput, infer InferredEffect> ? ((InferredEffect extends Exit<infer InferredValue> ? InferredValue : InferredEffect extends Break<infer InferredValue> ? InferredValue : never) | InferredOutput) extends infer InferredResult ? IsEqual<GenericIncludeDetails, true> extends true ? FlowDetails<InferredResult, InferredEffect extends Step<infer InferredName> ? InferredName : never> : InferredResult : never : never : never : never) extends infer InferredResult ? ExtractFlowGenerator<GenericFlow> extends AsyncGenerator ? Promise<InferredResult> : InferredResult : never;
+declare const MissingDependenceError_base: new (params: {
+    "@DuplojsUtilsFlow/missing-dependence-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"missing-dependence-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsFlow/missing-dependence-error", unknown>, unknown>;
+export declare class MissingDependenceError extends MissingDependenceError_base {
+    dependenceHandler: DependenceHandler;
+    constructor(dependenceHandler: DependenceHandler);
+}
+/**
+ * Runs a flow and resolves its final result.
+ * 
+ * **Supported call styles:**
+ * - Classic with a flow function: `run(theFlow, params?)` -> executes the provided flow function
+ * - Classic with a flow instance: `run(theFlow, params?)` -> executes a flow created with `F.create(...)`
+ * 
+ * `run` is the entry point of the flow system.
+ * It executes synchronous or asynchronous flows, handles break and exit effects, collects steps when `includeDetails` is enabled, runs deferred and finalizer callbacks, and injects declared dependencies.
+ * Use `run` to start a top-level flow and get its final value.
+ * 
+ * ```ts
+ * F.run(
+ * 	function *(input: string) {
+ * 		return input.toUpperCase();
+ * 	},
+ * 	{ input: "hello" },
+ * ); // "HELLO"
+ * 
+ * F.run(
+ * 	function *() {
+ * 		yield *F.step("check cache");
+ * 		yield *F.breakIf(2, (value) => value === 2);
+ * 		return "done";
+ * 	},
+ * 	{ includeDetails: true },
+ * ); // { result: 2, steps: ["check cache"] }
+ * 
+ * const service = F.createDependence("service")<string>;
+ * 
+ * F.run(
+ * 	function *() {
+ * 		const currentService = yield *F.inject(service);
+ * 		yield *F.finalizer(() => currentService.toUpperCase());
+ * 		return currentService;
+ * 	},
+ * 	{ dependencies: { service: "api" } },
+ * ); // "api"
+ * ```
+ * 
+ * @remarks
+ * - `run` returns a `Promise` when the executed flow is asynchronous
+ * 
+ * @see [`F.exec`](https://utils.duplojs.dev/en/v1/api/flow/exec) To run a nested flow from inside another flow
+ * @see https://utils.duplojs.dev/en/v1/api/flow/run
+ * 
+ * @namespace F
+ * 
+ */
+export declare function run<GenericFlow extends (TheFlowFunction | TheFlow), GenericWrapFlow extends WrapFlow<GenericFlow>, const GenericParams extends ComputeRunParams<FlowInput<GenericWrapFlow>, FlowDependencies<GenericWrapFlow>>>(theFlow: GenericFlow, ...[params]: ({} extends GenericParams ? [params?: GenericParams] : [params: GenericParams])): RunResult<GenericWrapFlow, IsEqual<GenericParams["includeDetails"], true>>;
+export {};