@duplojs/utils 1.5.14 → 1.6.0

package/dist/flow/run.mjs

@@ -0,0 +1,136 @@
+import { theFlowKind } from './theFlow/index.mjs';
+import { deferKind } from './theFlow/defer.mjs';
+import { finalizerKind } from './theFlow/finalizer.mjs';
+import { createFlowKind } from './kind.mjs';
+import { dependenceHandlerKind } from './theFlow/dependence.mjs';
+import { breakKind } from './theFlow/break.mjs';
+import { exitKind } from './theFlow/exit.mjs';
+import { stepKind } from './theFlow/step.mjs';
+import { injectionKind } from './theFlow/injection.mjs';
+import { justExec } from '../common/justExec.mjs';
+import { kindHeritage } from '../common/kind.mjs';
+
+class MissingDependenceError extends kindHeritage("missing-dependence-error", createFlowKind("missing-dependence-error"), Error) {
+    dependenceHandler;
+    constructor(dependenceHandler) {
+        super({}, [`Missing 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)
+        : 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 (breakKind.has(result.value)) {
+                        result = await generator.return(breakKind.getValue(result.value).value);
+                        break;
+                    }
+                    else if (exitKind.has(result.value)) {
+                        result = await generator.return(exitKind.getValue(result.value).value);
+                        break;
+                    }
+                    else if (deferKind.has(result.value)) {
+                        deferFunctions ??= [];
+                        deferFunctions.push(deferKind.getValue(result.value));
+                    }
+                    else if (finalizerKind.has(result.value)) {
+                        deferFunctions ??= [];
+                        deferFunctions.push(finalizerKind.getValue(result.value));
+                    }
+                    else if (params?.includeDetails === true
+                        && stepKind.has(result.value)) {
+                        steps ??= [];
+                        steps.push(stepKind.getValue(result.value));
+                    }
+                    else if (injectionKind.has(result.value)) {
+                        const injectionProperties = injectionKind.getValue(result.value);
+                        const dependenceName = 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));
+                }
+            }
+        })();
+    }
+    try {
+        do {
+            result = generator.next();
+            if (result.done === true) {
+                break;
+            }
+            else if (breakKind.has(result.value)) {
+                result = generator.return(breakKind.getValue(result.value).value);
+                break;
+            }
+            else if (exitKind.has(result.value)) {
+                result = generator.return(exitKind.getValue(result.value).value);
+                break;
+            }
+            else if (deferKind.has(result.value)) {
+                deferFunctions ??= [];
+                deferFunctions.push(deferKind.getValue(result.value));
+            }
+            else if (finalizerKind.has(result.value)) {
+                deferFunctions ??= [];
+                deferFunctions.push(finalizerKind.getValue(result.value));
+            }
+            else if (params?.includeDetails === true
+                && stepKind.has(result.value)) {
+                steps ??= [];
+                steps.push(stepKind.getValue(result.value));
+            }
+            else if (injectionKind.has(result.value)) {
+                const injectionProperties = injectionKind.getValue(result.value);
+                const dependenceName = 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);
+        }
+    }
+}
+
+export { MissingDependenceError, run };

package/dist/flow/step.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var step$1 = require('./theFlow/step.cjs');
+
+/**
+ * {@include flow/step/index.md}
+ */
+function step(name, theFunction) {
+    const result = theFunction?.();
+    if (result instanceof Promise) {
+        return (async function* () {
+            yield step$1.createStep(name);
+            const awaitedResult = await result;
+            return awaitedResult;
+        })();
+    }
+    return (function* () {
+        yield step$1.createStep(name);
+        return result;
+    })();
+}
+
+exports.step = step;

package/dist/flow/step.d.ts

@@ -0,0 +1,39 @@
+import { type Step } from "./theFlow";
+/**
+ * Registers a named step in a flow and can optionally compute a value.
+ * 
+ * **Supported call styles:**
+ * - Classic without callback: `step(name)` -> yields a step effect and returns `undefined`
+ * - Classic with callback: `step(name, theFunction)` -> yields a step effect and returns the callback result
+ * 
+ * `step` records a named execution step that can be collected by `F.run(...)` when `includeDetails` is enabled.
+ * It can also wrap a synchronous or asynchronous callback and return its result while still emitting the step.
+ * Use it to make a flow easier to observe without changing its control flow.
+ * 
+ * ```ts
+ * F.run(
+ * 	function *() {
+ * 		yield *F.step("load config");
+ * 		return "done";
+ * 	},
+ * 	{ includeDetails: true },
+ * ); // { result: "done", steps: ["load config"] }
+ * 
+ * F.run(
+ * 	function *() {
+ * 		const user = yield *F.step("read cache", () => "user-1");
+ * 		return user;
+ * 	},
+ * ); // "user-1"
+ * ```
+ * 
+ * @remarks
+ * - Steps are only collected in the final result when `includeDetails` is enabled
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For collecting step details
+ * @see https://utils.duplojs.dev/en/v1/api/flow/step
+ * 
+ * @namespace F
+ * 
+ */
+export declare function step<GenericName extends string, GenericOutput extends unknown = void>(name: GenericName, theFunction?: () => GenericOutput): (GenericOutput extends Promise<unknown> ? AsyncGenerator<Step<GenericName>, Awaited<GenericOutput>> : Generator<Step<GenericName>, GenericOutput>);

package/dist/flow/step.mjs

@@ -0,0 +1,21 @@
+import { createStep } from './theFlow/step.mjs';
+
+/**
+ * {@include flow/step/index.md}
+ */
+function step(name, theFunction) {
+    const result = theFunction?.();
+    if (result instanceof Promise) {
+        return (async function* () {
+            yield createStep(name);
+            const awaitedResult = await result;
+            return awaitedResult;
+        })();
+    }
+    return (function* () {
+        yield createStep(name);
+        return result;
+    })();
+}
+
+export { step };

package/dist/flow/theFlow/break.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const breakKind = kind.createFlowKind("break");
+function createBreak(value = undefined) {
+    return breakKind.setTo({}, { value });
+}
+
+exports.breakKind = breakKind;
+exports.createBreak = createBreak;

package/dist/flow/theFlow/break.d.ts

@@ -0,0 +1,7 @@
+import { type Kind } from "../../common";
+export declare const breakKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/break", unknown>>;
+export interface Break<GenericValue extends unknown = unknown> extends Kind<typeof breakKind.definition, {
+    value: GenericValue;
+}> {
+}
+export declare function createBreak<GenericValue extends unknown = undefined>(value?: GenericValue): Break<GenericValue>;

package/dist/flow/theFlow/break.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const breakKind = createFlowKind("break");
+function createBreak(value = undefined) {
+    return breakKind.setTo({}, { value });
+}
+
+export { breakKind, createBreak };

package/dist/flow/theFlow/defer.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const deferKind = kind.createFlowKind("defer");
+function createDefer(value) {
+    return deferKind.setTo({}, value);
+}
+
+exports.createDefer = createDefer;
+exports.deferKind = deferKind;

package/dist/flow/theFlow/defer.d.ts

@@ -0,0 +1,5 @@
+import { type AnyFunction, type Kind } from "../../common";
+export declare const deferKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/defer", AnyFunction<[], unknown>>>;
+export interface Defer<GenericValue extends unknown = unknown> extends Kind<typeof deferKind.definition, () => GenericValue> {
+}
+export declare function createDefer<GenericOutput extends unknown>(value: () => GenericOutput): Defer<GenericOutput>;

package/dist/flow/theFlow/defer.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const deferKind = createFlowKind("defer");
+function createDefer(value) {
+    return deferKind.setTo({}, value);
+}
+
+export { createDefer, deferKind };

package/dist/flow/theFlow/dependence.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const dependenceHandlerKind = kind.createFlowKind("dependence-handler");
+/**
+ * {@include flow/createDependence/index.md}
+ */
+function createDependence(name) {
+    const dependenceHandler = function (implementation) {
+        return implementation;
+    };
+    return dependenceHandlerKind.setTo(dependenceHandler, name);
+}
+
+exports.createDependence = createDependence;
+exports.dependenceHandlerKind = dependenceHandlerKind;

package/dist/flow/theFlow/dependence.d.ts

@@ -0,0 +1,50 @@
+import { type Kind } from "../../common";
+export declare const dependenceHandlerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/dependence-handler", string>>;
+export interface DependenceHandlerKind<GenericName extends string = string> extends Kind<typeof dependenceHandlerKind.definition, GenericName> {
+}
+export type DependenceHandler<GenericName extends string = string, GenericType extends any = any> = (DependenceHandlerKind<GenericName> & ((implementation: GenericType) => GenericType));
+export type DependenceHandlerDefinition<GenericName extends string = string> = (DependenceHandlerKind<GenericName> & (<GenericType extends unknown>(implementation: GenericType) => GenericType));
+/**
+ * Creates a typed dependency handler for the flow system.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createDependence(name)` -> returns a typed dependence handler definition
+ * 
+ * `createDependence` creates a dependency descriptor identified by a string name.
+ * The returned handler is used with `inject(...)` and lets `run(...)` or `exec(...)` map a dependency bag to strongly typed values.
+ * At runtime, the handler also behaves like an identity function for the injected implementation.
+ * 
+ * ```ts
+ * const database = F.createDependence("database")<string>;
+ * 
+ * F.run(
+ * 	function *() {
+ * 		const connection = yield *F.inject(database);
+ * 		return connection;
+ * 	},
+ * 	{ dependencies: { database: database("main-db") } },
+ * ); // "main-db"
+ * 
+ * const apiClient = F.createDependence("apiClient")<{ baseUrl: string }>;
+ * 
+ * F.run(
+ * 	function *() {
+ * 		const client = yield *F.inject(apiClient);
+ * 		return client.baseUrl;
+ * 	},
+ * 	{ dependencies: { apiClient: apiClient({ baseUrl: "/api" }) } },
+ * ); // "/api"
+ * 
+ * database("replica-db"); // "replica-db"
+ * ```
+ * 
+ * @remarks
+ * - Use the returned dependence handler together with `inject(...)`
+ * 
+ * @see [`F.inject`](https://utils.duplojs.dev/en/v1/api/flow/inject) To request the dependency inside a flow
+ * @see https://utils.duplojs.dev/en/v1/api/flow/createDependence
+ * 
+ * @namespace F
+ * 
+ */
+export declare function createDependence<GenericName extends string>(name: GenericName): DependenceHandlerDefinition<GenericName>;

package/dist/flow/theFlow/dependence.mjs

@@ -0,0 +1,14 @@
+import { createFlowKind } from '../kind.mjs';
+
+const dependenceHandlerKind = createFlowKind("dependence-handler");
+/**
+ * {@include flow/createDependence/index.md}
+ */
+function createDependence(name) {
+    const dependenceHandler = function (implementation) {
+        return implementation;
+    };
+    return dependenceHandlerKind.setTo(dependenceHandler, name);
+}
+
+export { createDependence, dependenceHandlerKind };

package/dist/flow/theFlow/exit.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const exitKind = kind.createFlowKind("exit");
+function createExit(value = undefined) {
+    return exitKind.setTo({}, { value });
+}
+
+exports.createExit = createExit;
+exports.exitKind = exitKind;

package/dist/flow/theFlow/exit.d.ts

@@ -0,0 +1,7 @@
+import { type Kind } from "../../common";
+export declare const exitKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/exit", unknown>>;
+export interface Exit<GenericValue extends unknown = unknown> extends Kind<typeof exitKind.definition, {
+    value: GenericValue;
+}> {
+}
+export declare function createExit<GenericValue extends unknown = undefined>(value?: GenericValue): Exit<GenericValue>;

package/dist/flow/theFlow/exit.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const exitKind = createFlowKind("exit");
+function createExit(value = undefined) {
+    return exitKind.setTo({}, { value });
+}
+
+export { createExit, exitKind };

package/dist/flow/theFlow/finalizer.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const finalizerKind = kind.createFlowKind("finalizer");
+function createFinalizer(value) {
+    return finalizerKind.setTo({}, value);
+}
+
+exports.createFinalizer = createFinalizer;
+exports.finalizerKind = finalizerKind;

package/dist/flow/theFlow/finalizer.d.ts

@@ -0,0 +1,5 @@
+import { type AnyFunction, type Kind } from "../../common";
+export declare const finalizerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/finalizer", AnyFunction<[], unknown>>>;
+export interface Finalizer<GenericValue extends unknown = unknown> extends Kind<typeof finalizerKind.definition, () => GenericValue> {
+}
+export declare function createFinalizer<GenericOutput extends unknown>(value: () => GenericOutput): Finalizer<GenericOutput>;

package/dist/flow/theFlow/finalizer.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const finalizerKind = createFlowKind("finalizer");
+function createFinalizer(value) {
+    return finalizerKind.setTo({}, value);
+}
+
+export { createFinalizer, finalizerKind };

package/dist/flow/theFlow/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const theFlowKind = kind.createFlowKind("the-flow");
+/**
+ * {@include flow/create/index.md}
+ */
+function create(theFunction) {
+    return theFlowKind.setTo({}, { run: theFunction });
+}
+
+exports.create = create;
+exports.theFlowKind = theFlowKind;

package/dist/flow/theFlow/index.d.ts

@@ -0,0 +1,85 @@
+import { type GetKindValue, type Kind } from "../../common";
+import { type Step } from "./step";
+import { type Exit } from "./exit";
+import { type Injection } from "./injection";
+import { type Break } from "./break";
+import { type Defer } from "./defer";
+import { type Finalizer } from "./finalizer";
+import { type DependenceHandler, type dependenceHandlerKind } from "./dependence";
+export * from "./step";
+export * from "./exit";
+export * from "./break";
+export * from "./injection";
+export * from "./defer";
+export * from "./finalizer";
+export * from "./dependence";
+export type Effect = (Injection | Step | Exit | Break | Defer | Finalizer);
+export type TheFlowGenerator<GenericOutput extends unknown = unknown, GenericEffect extends Effect = Effect> = (Generator<GenericEffect, GenericOutput> | AsyncGenerator<GenericEffect, GenericOutput>);
+export type TheFlowFunction<GenericInput extends any = any, GenericGenerator extends TheFlowGenerator = TheFlowGenerator> = (input: GenericInput) => GenericGenerator;
+export interface TheFlowProperties<GenericFunction extends TheFlowFunction = TheFlowFunction> {
+    run: GenericFunction;
+}
+export declare const theFlowKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/the-flow", TheFlowProperties<TheFlowFunction<any, TheFlowGenerator<unknown, Effect>>>>>;
+export interface TheFlow<GenericFunction extends TheFlowFunction = TheFlowFunction> extends Kind<typeof theFlowKind.definition, TheFlowProperties<GenericFunction>> {
+}
+/**
+ * Creates a reusable flow object from a flow function.
+ * 
+ * **Supported call styles:**
+ * - Classic: `create(theFunction)` -> returns a flow instance that can be passed to `F.run(...)` or `F.exec(...)`
+ * 
+ * `create` wraps a generator-based flow function into a flow object understood by the flow runtime.
+ * The returned flow can be executed multiple times with different inputs and can be composed with `F.exec(...)`.
+ * Use it to name, share, and reuse flow definitions without executing them immediately.
+ * 
+ * ```ts
+ * const greetingFlow = F.create(
+ * 	function *(name: string) {
+ * 		return `hello ${name}`;
+ * 	},
+ * );
+ * 
+ * F.run(greetingFlow, { input: "Ada" }); // "hello Ada"
+ * 
+ * const breakableFlow = F.create(
+ * 	function *(value: number) {
+ * 		yield *F.breakIf(value, (current) => current === 0);
+ * 		return value * 2;
+ * 	},
+ * );
+ * 
+ * F.run(breakableFlow, { input: 0 }); // 0
+ * 
+ * F.run(
+ * 	function *() {
+ * 		return yield *F.exec(greetingFlow, { input: "Linus" });
+ * 	},
+ * ); // "hello Linus"
+ * 
+ * const asyncFlow = F.create(
+ * 	async function *(name: string) {
+ * 		const value = await name.toUpperCase();
+ * 		return value;
+ * 	},
+ * );
+ * 
+ * await F.run(asyncFlow, { input: "flow" }); // Promise<"FLOW">
+ * ```
+ * 
+ * @remarks
+ * - `create` does not execute the flow, it only wraps it for later use
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) To execute a created flow
+ * @see [`F.exec`](https://utils.duplojs.dev/en/v1/api/flow/exec) To execute a created flow inside another flow
+ * @see https://utils.duplojs.dev/en/v1/api/flow/create
+ * 
+ * @namespace F
+ * 
+ */
+export declare function create<GenericTheFlowFunction extends TheFlowFunction>(theFunction: GenericTheFlowFunction): TheFlow<GenericTheFlowFunction>;
+export type FlowInput<GenericFlow extends TheFlow> = GenericFlow extends TheFlow<infer InferredFunction> ? InferredFunction extends TheFlowFunction<infer InferredInput> ? InferredInput : never : never;
+export type WrapFlow<GenericFlow extends (TheFlow | TheFlowFunction | TheFlowGenerator)> = GenericFlow extends TheFlowGenerator ? TheFlow<TheFlowFunction<unknown, GenericFlow>> : GenericFlow extends TheFlowFunction ? TheFlow<GenericFlow> : GenericFlow;
+export type FlowDependencies<GenericFlow extends TheFlow> = (ExtractFlowGenerator<GenericFlow> extends TheFlowGenerator<any, infer InferredEffect> ? InferredEffect extends Injection<infer InferredDependenceHandler> ? InferredDependenceHandler : never : never) extends infer InferredDependenceHandler extends DependenceHandler ? {
+    [Dependence in InferredDependenceHandler as Extract<GetKindValue<typeof dependenceHandlerKind, Dependence>, string>]: ReturnType<InferredDependenceHandler>;
+} : never;
+export type ExtractFlowGenerator<GenericFlow extends TheFlow> = GenericFlow extends TheFlow<infer InferredFunction> ? InferredFunction extends TheFlowFunction<any, infer InferredGenerator> ? InferredGenerator : never : never;

package/dist/flow/theFlow/index.mjs

@@ -0,0 +1,11 @@
+import { createFlowKind } from '../kind.mjs';
+
+const theFlowKind = createFlowKind("the-flow");
+/**
+ * {@include flow/create/index.md}
+ */
+function create(theFunction) {
+    return theFlowKind.setTo({}, { run: theFunction });
+}
+
+export { create, theFlowKind };

package/dist/flow/theFlow/injection.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const injectionKind = kind.createFlowKind("injection");
+function createInjection(properties) {
+    return injectionKind.setTo({}, properties);
+}
+
+exports.createInjection = createInjection;
+exports.injectionKind = injectionKind;

package/dist/flow/theFlow/injection.d.ts

@@ -0,0 +1,10 @@
+import { type Kind } from "../../common";
+import { type DependenceHandler } from "./dependence";
+export interface InjectionProperties<GenericDependenceHandler extends DependenceHandler = DependenceHandler> {
+    dependenceHandler: GenericDependenceHandler;
+    inject(value: ReturnType<GenericDependenceHandler>): void;
+}
+export declare const injectionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/injection", InjectionProperties<DependenceHandler>>>;
+export interface Injection<GenericDependenceHandler extends DependenceHandler = DependenceHandler> extends Kind<typeof injectionKind.definition, InjectionProperties<GenericDependenceHandler>> {
+}
+export declare function createInjection<GenericDependenceHandler extends DependenceHandler = DependenceHandler>(properties: InjectionProperties<GenericDependenceHandler>): Injection<GenericDependenceHandler>;

package/dist/flow/theFlow/injection.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const injectionKind = createFlowKind("injection");
+function createInjection(properties) {
+    return injectionKind.setTo({}, properties);
+}
+
+export { createInjection, injectionKind };

package/dist/flow/theFlow/step.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const stepKind = kind.createFlowKind("step");
+function createStep(name) {
+    return stepKind.setTo({}, name);
+}
+
+exports.createStep = createStep;
+exports.stepKind = stepKind;

package/dist/flow/theFlow/step.d.ts

@@ -0,0 +1,5 @@
+import { type Kind } from "../../common";
+export declare const stepKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/step", string>>;
+export interface Step<GenericName extends string = string> extends Kind<typeof stepKind.definition, GenericName> {
+}
+export declare function createStep<GenericName extends string>(name: GenericName): Step<GenericName>;

package/dist/flow/theFlow/step.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const stepKind = createFlowKind("step");
+function createStep(name) {
+    return stepKind.setTo({}, name);
+}
+
+export { createStep, stepKind };

package/dist/flow/types/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.cjs

@@ -12,6 +12,7 @@ var index$8 = require('./dataParser/parsers/coerce/index.cjs');
 var index$9 = require('./dataParser/extended/index.cjs');
 var index$a = require('./date/index.cjs');
 var index$b = require('./clean/index.cjs');
+var index$c = require('./flow/index.cjs');
 var addWrappedProperties = require('./common/addWrappedProperties.cjs');
 var asyncPipe = require('./common/asyncPipe.cjs');
 var clone = require('./common/clone.cjs');
@@ -93,6 +94,8 @@ exports.D = index$a;
 exports.DDate = index$a;
 exports.C = index$b;
 exports.DClean = index$b;
+exports.DFlow = index$c;
+exports.F = index$c;
 exports.addWrappedProperties = addWrappedProperties.addWrappedProperties;
 exports.asyncPipe = asyncPipe.asyncPipe;
 exports.clone = clone.clone;

package/dist/index.d.ts

@@ -23,3 +23,5 @@ export * as D from "./date";
 export * as DDate from "./date";
 export * as C from "./clean";
 export * as DClean from "./clean";
+export * as F from "./flow";
+export * as DFlow from "./flow";

package/dist/index.mjs

@@ -34,6 +34,9 @@ export { index$a as DDate };
 import * as index$b from './clean/index.mjs';
 export { index$b as C };
 export { index$b as DClean };
+import * as index$c from './flow/index.mjs';
+export { index$c as DFlow };
+export { index$c as F };
 export { addWrappedProperties } from './common/addWrappedProperties.mjs';
 export { asyncPipe } from './common/asyncPipe.mjs';
 export { clone } from './common/clone.mjs';