@duplojs/utils 1.6.1 → 1.6.3

package/dist/dataParser/parsers/union.mjs

@@ -1,5 +1,5 @@
-import { dataParserInit, SymbolDataParserError } from '../base.mjs';
-import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { dataParserInit } from '../base.mjs';
+import { setErrorPath, SymbolDataParserError, addIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 import { some } from '../../array/some.mjs';
 import { createOverride } from '../../common/override.mjs';
@@ -15,22 +15,40 @@ function union(options, definition) {
         options,
     }, {
         sync: (data, error, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = dataParser.exec(data, error);
+            const unionError = {
+                ...error,
+                currentPath: [...error.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = dataParser.exec(data, unionError);
                 if (result !== SymbolDataParserError) {
                     return result;
                 }
             }
-            return SymbolDataParserErrorIssue;
+            error.issues.push(...unionError.issues);
+            return addIssue(error, "respect at least one union value", data, self.definition.errorMessage);
         },
         async: async (data, error, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = await dataParser.asyncExec(data, error);
+            const unionError = {
+                ...error,
+                currentPath: [...error.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = await dataParser.asyncExec(data, unionError);
                 if (result !== SymbolDataParserError) {
                     return result;
                 }
             }
-            return SymbolDataParserErrorIssue;
+            error.issues.push(...unionError.issues);
+            return addIssue(error, "respect at least one union value", data, self.definition.errorMessage);
         },
         isAsynchronous: (self) => some(self.definition.options, (element) => element.isAsynchronous()),
     }, union.overrideHandler);

package/dist/flow/calledByNext.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var calledByNext$1 = require('./theFlow/calledByNext.cjs');
+
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * {@include flow/calledByNext/index.md}
+ */
+async function* calledByNext(theFunction) {
+    yield calledByNext$1.createCalledByNext(theFunction);
+}
+
+exports.calledByNext = calledByNext;

package/dist/flow/calledByNext.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Registers a callback that the flow runner can execute before the next overlapping async run of the same flow continues.
+ * 
+ * **Supported call styles:**
+ * - Classic: `calledByNext(theFunction)` -> yields a `called-by-next` effect
+ * 
+ * `calledByNext` declares a side callback on the current flow execution.
+ * When the same async flow starts again while a previous callback is still registered, the runner executes the previous callback and replaces it with the new one.
+ * This helper is mainly useful for cross-run invalidation or deferred refresh logic tied to async flow re-entry.
+ * 
+ * ```ts
+ * const loadUsersFlow = F.create(
+ * 	async function *(page: number) {
+ * 		const controller = new AbortController();
+ * 
+ * 		yield *F.calledByNext(() => void controller.abort());
+ * 
+ * 		const response = await fetch(
+ * 			`/api/users?page=${page}`,
+ * 			{
+ * 				signal: controller.signal,
+ * 			},
+ * 		);
+ * 
+ * 		return response.json();
+ * 	},
+ * );
+ * const loadUsers = F.toFunction(loadUsersFlow);
+ * 
+ * const firstRequest = loadUsers(1);
+ * const secondRequest = loadUsers(2);
+ * // The second call aborts the first pending fetch.
+ * 
+ * ```
+ * 
+ * @remarks
+ * - `calledByNext` is only observable through the async flow runner behavior
+ * - Use a stable flow reference such as `F.create(...)` or `F.toFunction(...)` when you expect cross-run behavior
+ * - If the same flow execution yields `calledByNext(...)` multiple times, only the first yielded effect is applied by the runner
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For the runtime behavior that consumes this effect
+ * @see https://utils.duplojs.dev/en/v1/api/flow/calledByNext
+ * 
+ * @namespace F
+ * 
+ */
+export declare function calledByNext<GenericOutput extends unknown>(theFunction: () => GenericOutput): AsyncGenerator<import("./theFlow").CalledByNext<GenericOutput>, void, unknown>;

package/dist/flow/calledByNext.mjs

@@ -0,0 +1,11 @@
+import { createCalledByNext } from './theFlow/calledByNext.mjs';
+
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * {@include flow/calledByNext/index.md}
+ */
+async function* calledByNext(theFunction) {
+    yield createCalledByNext(theFunction);
+}
+
+export { calledByNext };

package/dist/flow/debounce.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var debounce$1 = require('./theFlow/debounce.cjs');
+
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * {@include flow/debounce/index.md}
+ */
+async function* debounce(time, params) {
+    yield debounce$1.createDebounce({
+        time,
+        returnValue: params?.returnValue,
+    });
+}
+
+exports.debounce = debounce;

package/dist/flow/debounce.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Delays a flow execution and cancels the previous run when a new one arrives before the delay ends.
+ * 
+ * **Supported call styles:**
+ * - Classic: `debounce(time)` -> yields a debounce effect
+ * - Classic with options: `debounce(time, params)` -> yields a debounce effect with a fallback return value
+ * 
+ * `debounce` lets the runner wait before continuing the current run of the same flow.
+ * If another run starts during that delay, the previous run is cancelled and can return `params.returnValue`.
+ * This makes it useful for search inputs, refresh triggers, or any async flow where only the latest call should continue.
+ * 
+ * ```ts
+ * const searchFlow = F.create(
+ * 	async function *(query: string) {
+ * 		yield *F.debounce(
+ * 			300,
+ * 			{ returnValue: "skipped" as const },
+ * 		);
+ * 		return Promise.resolve(query);
+ * 	},
+ * );
+ * const runSearch = F.toFunction(searchFlow);
+ * 
+ * void runSearch("first"); // Promise<"first" | "skipped">
+ * 
+ * void runSearch("second"); // Promise<"second" | "skipped">
+ * 
+ * const refreshFlow = F.create(
+ * 	async function *(section: string) {
+ * 		yield *F.debounce(500);
+ * 		return Promise.resolve(section);
+ * 	},
+ * );
+ * const runRefresh = F.toFunction(refreshFlow);
+ * await runRefresh("users"); // Promise<"users" | undefined>
+ * 
+ * const saveFlow = F.create(
+ * 	async function *(name: string) {
+ * 		yield *F.debounce(
+ * 			200,
+ * 			{ returnValue: "cancelled" as const },
+ * 		);
+ * 		return Promise.resolve(`saved:${name}` as const);
+ * 	},
+ * );
+ * const runSave = F.toFunction(saveFlow);
+ * await runSave("alice"); // Promise<`saved:${string}` | "cancelled">
+ * ```
+ * 
+ * @remarks
+ * - `debounce` is an async generator because the runner always waits before continuing the preserved run
+ * - Debounce state is attached to the flow reference, so examples should reuse the same created flow or wrapped function
+ * - If the same flow execution yields `debounce(...)` multiple times, only the first yielded effect is applied by the runner
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For the debounce behavior implemented by the runner
+ * @see https://utils.duplojs.dev/en/v1/api/flow/debounce
+ * 
+ * @namespace F
+ * 
+ */
+export declare function debounce<GenericValue extends unknown = undefined>(time: number, params?: {
+    returnValue?: GenericValue;
+}): AsyncGenerator<import("./theFlow").Debounce<GenericValue | undefined>, void, unknown>;

package/dist/flow/debounce.mjs

@@ -0,0 +1,14 @@
+import { createDebounce } from './theFlow/debounce.mjs';
+
+/* eslint-disable @typescript-eslint/require-await */
+/**
+ * {@include flow/debounce/index.md}
+ */
+async function* debounce(time, params) {
+    yield createDebounce({
+        time,
+        returnValue: params?.returnValue,
+    });
+}
+
+export { debounce };

package/dist/flow/exec.cjs

@@ -3,12 +3,19 @@
 var index = require('./theFlow/index.cjs');
 var defer = require('./theFlow/defer.cjs');
 var finalizer = require('./theFlow/finalizer.cjs');
+var run = require('./run.cjs');
 var justExec = require('../common/justExec.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 dependence = require('./theFlow/dependence.cjs');
+var throttling = require('./theFlow/throttling.cjs');
+var externalPromise = require('../common/externalPromise.cjs');
+var calledByNext = require('./theFlow/calledByNext.cjs');
+var queue = require('./theFlow/queue.cjs');
+var queue$1 = require('../common/queue.cjs');
+var debounce = require('./theFlow/debounce.cjs');
 var forward = require('../common/forward.cjs');
 
 /**
@@ -17,6 +24,10 @@ var forward = require('../common/forward.cjs');
 function exec(theFlow, ...[params]) {
     let result = undefined;
     let deferFunctions = undefined;
+    let alreadyUseThrottling = undefined;
+    let alreadyUseDebounce = undefined;
+    let alreadyUseCalledByNext = undefined;
+    let alreadyUseQueue = undefined;
     const generator = justExec.justExec(() => {
         if (Symbol.asyncIterator in theFlow || Symbol.iterator in theFlow) {
             return forward.forward(theFlow);
@@ -64,10 +75,90 @@ function exec(theFlow, ...[params]) {
                             injectionProperties.inject(params.dependencies[dependenceName]);
                         }
                     }
+                    else if (throttling.throttlingKind.has(result.value)) {
+                        if (alreadyUseThrottling) {
+                            continue;
+                        }
+                        alreadyUseThrottling = true;
+                        const { time, keepLast, returnValue } = throttling.throttlingKind.getValue(result.value);
+                        const lastTime = run.throttlingLastTimeWeakStore.get(theFlow);
+                        const now = Date.now();
+                        run.throttlingLastTimeWeakStore.set(theFlow, now);
+                        if (typeof lastTime === "number" && (lastTime + time) > now) {
+                            if (keepLast === true) {
+                                const resumer = run.throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(false);
+                                const externalPromise$1 = externalPromise.createExternalPromise();
+                                run.throttlingResumerWeakStore.set(theFlow, externalPromise$1.resolve);
+                                if (await externalPromise$1.promise) {
+                                    continue;
+                                }
+                            }
+                            result = await generator.return(returnValue);
+                            break;
+                        }
+                        else if (keepLast === true) {
+                            setTimeout(() => {
+                                const resumer = run.throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(true);
+                            }, time);
+                        }
+                    }
+                    else if (calledByNext.calledByNextKind.has(result.value)) {
+                        if (alreadyUseCalledByNext) {
+                            continue;
+                        }
+                        alreadyUseCalledByNext = calledByNext.calledByNextKind.getValue(result.value);
+                        const lastFunction = run.calledByNextFunctionWeakStore.get(theFlow);
+                        const lastResult = lastFunction?.();
+                        if (lastResult instanceof Promise) {
+                            await lastResult;
+                        }
+                        run.calledByNextFunctionWeakStore.set(theFlow, alreadyUseCalledByNext);
+                    }
+                    else if (queue.queueKind.has(result.value)) {
+                        if (alreadyUseQueue) {
+                            continue;
+                        }
+                        const { concurrency, injectResolver } = queue.queueKind.getValue(result.value);
+                        let queue$2 = run.queuesWeakStore.get(theFlow);
+                        if (queue$2 === undefined) {
+                            queue$2 = queue$1.createQueue({ concurrency });
+                            run.queuesWeakStore.set(theFlow, queue$2);
+                        }
+                        alreadyUseQueue = await queue$2.addExternal();
+                        injectResolver(alreadyUseQueue);
+                    }
+                    else if (debounce.debounceKind.has(result.value)) {
+                        if (alreadyUseDebounce) {
+                            continue;
+                        }
+                        alreadyUseDebounce = true;
+                        const { time, returnValue } = debounce.debounceKind.getValue(result.value);
+                        const lastTimeout = run.debounceTimeoutIdWeakStore.get(theFlow);
+                        clearTimeout(lastTimeout);
+                        const lastResumer = run.debounceResumerWeakStore.get(theFlow);
+                        lastResumer?.(false);
+                        const externalPromise$1 = externalPromise.createExternalPromise();
+                        run.debounceTimeoutIdWeakStore.set(theFlow, setTimeout(() => void externalPromise$1.resolve(true), time));
+                        run.debounceResumerWeakStore.set(theFlow, externalPromise$1.resolve);
+                        if (await externalPromise$1.promise) {
+                            continue;
+                        }
+                        result = await generator.return(returnValue);
+                        break;
+                    }
                 } while (true);
                 return result.value;
             }
             finally {
+                if (alreadyUseCalledByNext
+                    && run.calledByNextFunctionWeakStore.get(theFlow) === alreadyUseCalledByNext) {
+                    run.calledByNextFunctionWeakStore.delete(theFlow);
+                }
+                if (alreadyUseQueue) {
+                    alreadyUseQueue();
+                }
                 await generator.return(undefined);
                 if (deferFunctions) {
                     await Promise.all(deferFunctions.map(justExec.justExec));
@@ -110,6 +201,16 @@ function exec(theFlow, ...[params]) {
                         injectionProperties.inject(params.dependencies[dependenceName]);
                     }
                 }
+                else if (throttling.throttlingKind.has(result.value)) {
+                    const { time, returnValue } = throttling.throttlingKind.getValue(result.value);
+                    const lastTime = run.throttlingLastTimeWeakStore.get(theFlow);
+                    const now = Date.now();
+                    run.throttlingLastTimeWeakStore.set(theFlow, now);
+                    if (typeof lastTime === "number" && (lastTime + time) > now) {
+                        result = generator.return(returnValue);
+                        break;
+                    }
+                }
             } while (true);
             return result.value;
         }

package/dist/flow/exec.d.ts

@@ -1,5 +1,6 @@
 import { type SimplifyTopLevel, type IsEqual, type IsExtends, type Or } from "../common";
-import { type TheFlowGenerator, type TheFlow, type TheFlowFunction, type FlowInput, type WrapFlow, type Exit, type Break, type Injection, type Step, type FlowDependencies } from "./theFlow";
+import { type TheFlowGenerator, type TheFlow, type TheFlowFunction, type FlowInput, type WrapFlow, type Exit, type Break, type Injection, type Step, type FlowDependencies, type Throttling, type Debounce } from "./theFlow";
+import { type Defer } from "./theFlow/defer";
 import { type Finalizer } from "./theFlow/finalizer";
 type ComputeExecParams<GenericInput extends unknown, GenericDependencies extends Record<string, unknown>> = SimplifyTopLevel<(Or<[
     IsEqual<GenericInput, unknown>,
@@ -13,7 +14,7 @@ type ComputeExecParams<GenericInput extends unknown, GenericDependencies extends
     dependencies?: GenericDependencies;
 }>;
 export type ExecResult<GenericFlow extends TheFlow> = GenericFlow extends TheFlow<infer InferredFunction> ? InferredFunction extends TheFlowFunction<any, infer InferredGenerator> ? InferredGenerator extends TheFlowGenerator<infer InferredOutput, infer InferredEffect> ? [
-    ((InferredEffect extends Break<infer InferredValue> ? InferredValue : never) | InferredOutput),
+    ((InferredEffect extends Break<infer InferredValue> ? InferredValue : InferredEffect extends Throttling<infer InferredValue> ? InferredValue : InferredEffect extends Debounce<infer InferredValue> ? InferredValue : never) | InferredOutput),
     Extract<InferredEffect, Exit | Injection | Finalizer | Step>
 ] extends [
     infer InferredOutput,
@@ -79,5 +80,5 @@ export type ExecResult<GenericFlow extends TheFlow> = GenericFlow extends TheFlo
  * @namespace F
  * 
  */
-export declare function exec<GenericFlow extends (TheFlowFunction | TheFlow | TheFlowGenerator), GenericWrapFlow extends WrapFlow<GenericFlow>, const GenericParams extends ComputeExecParams<FlowInput<GenericWrapFlow>, FlowDependencies<GenericWrapFlow>>>(theFlow: GenericFlow, ...[params]: ({} extends GenericParams ? [params?: GenericParams] : [params: GenericParams])): ExecResult<WrapFlow<GenericFlow>>;
+export declare function exec<GenericFlow extends (TheFlowFunction<any, TheFlowGenerator<unknown, Injection | Step | Exit | Break | Defer | Finalizer>> | TheFlow | TheFlowGenerator<unknown, Injection | Step | Exit | Break | Defer | Finalizer>), GenericWrapFlow extends WrapFlow<GenericFlow>, const GenericParams extends ComputeExecParams<FlowInput<GenericWrapFlow>, FlowDependencies<GenericWrapFlow>>>(theFlow: GenericFlow, ...[params]: ({} extends GenericParams ? [params?: GenericParams] : [params: GenericParams])): ExecResult<WrapFlow<GenericFlow>>;
 export {};

package/dist/flow/exec.mjs

@@ -1,12 +1,19 @@
 import { theFlowKind } from './theFlow/index.mjs';
 import { deferKind } from './theFlow/defer.mjs';
 import { finalizerKind } from './theFlow/finalizer.mjs';
+import { throttlingLastTimeWeakStore, throttlingResumerWeakStore, calledByNextFunctionWeakStore, queuesWeakStore, debounceTimeoutIdWeakStore, debounceResumerWeakStore } from './run.mjs';
 import { justExec } from '../common/justExec.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 { dependenceHandlerKind } from './theFlow/dependence.mjs';
+import { throttlingKind } from './theFlow/throttling.mjs';
+import { createExternalPromise } from '../common/externalPromise.mjs';
+import { calledByNextKind } from './theFlow/calledByNext.mjs';
+import { queueKind } from './theFlow/queue.mjs';
+import { createQueue } from '../common/queue.mjs';
+import { debounceKind } from './theFlow/debounce.mjs';
 import { forward } from '../common/forward.mjs';
 
 /**
@@ -15,6 +22,10 @@ import { forward } from '../common/forward.mjs';
 function exec(theFlow, ...[params]) {
     let result = undefined;
     let deferFunctions = undefined;
+    let alreadyUseThrottling = undefined;
+    let alreadyUseDebounce = undefined;
+    let alreadyUseCalledByNext = undefined;
+    let alreadyUseQueue = undefined;
     const generator = justExec(() => {
         if (Symbol.asyncIterator in theFlow || Symbol.iterator in theFlow) {
             return forward(theFlow);
@@ -62,10 +73,90 @@ function exec(theFlow, ...[params]) {
                             injectionProperties.inject(params.dependencies[dependenceName]);
                         }
                     }
+                    else if (throttlingKind.has(result.value)) {
+                        if (alreadyUseThrottling) {
+                            continue;
+                        }
+                        alreadyUseThrottling = true;
+                        const { time, keepLast, returnValue } = throttlingKind.getValue(result.value);
+                        const lastTime = throttlingLastTimeWeakStore.get(theFlow);
+                        const now = Date.now();
+                        throttlingLastTimeWeakStore.set(theFlow, now);
+                        if (typeof lastTime === "number" && (lastTime + time) > now) {
+                            if (keepLast === true) {
+                                const resumer = throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(false);
+                                const externalPromise = createExternalPromise();
+                                throttlingResumerWeakStore.set(theFlow, externalPromise.resolve);
+                                if (await externalPromise.promise) {
+                                    continue;
+                                }
+                            }
+                            result = await generator.return(returnValue);
+                            break;
+                        }
+                        else if (keepLast === true) {
+                            setTimeout(() => {
+                                const resumer = throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(true);
+                            }, time);
+                        }
+                    }
+                    else if (calledByNextKind.has(result.value)) {
+                        if (alreadyUseCalledByNext) {
+                            continue;
+                        }
+                        alreadyUseCalledByNext = calledByNextKind.getValue(result.value);
+                        const lastFunction = calledByNextFunctionWeakStore.get(theFlow);
+                        const lastResult = lastFunction?.();
+                        if (lastResult instanceof Promise) {
+                            await lastResult;
+                        }
+                        calledByNextFunctionWeakStore.set(theFlow, alreadyUseCalledByNext);
+                    }
+                    else if (queueKind.has(result.value)) {
+                        if (alreadyUseQueue) {
+                            continue;
+                        }
+                        const { concurrency, injectResolver } = queueKind.getValue(result.value);
+                        let queue = queuesWeakStore.get(theFlow);
+                        if (queue === undefined) {
+                            queue = createQueue({ concurrency });
+                            queuesWeakStore.set(theFlow, queue);
+                        }
+                        alreadyUseQueue = await queue.addExternal();
+                        injectResolver(alreadyUseQueue);
+                    }
+                    else if (debounceKind.has(result.value)) {
+                        if (alreadyUseDebounce) {
+                            continue;
+                        }
+                        alreadyUseDebounce = true;
+                        const { time, returnValue } = debounceKind.getValue(result.value);
+                        const lastTimeout = debounceTimeoutIdWeakStore.get(theFlow);
+                        clearTimeout(lastTimeout);
+                        const lastResumer = debounceResumerWeakStore.get(theFlow);
+                        lastResumer?.(false);
+                        const externalPromise = createExternalPromise();
+                        debounceTimeoutIdWeakStore.set(theFlow, setTimeout(() => void externalPromise.resolve(true), time));
+                        debounceResumerWeakStore.set(theFlow, externalPromise.resolve);
+                        if (await externalPromise.promise) {
+                            continue;
+                        }
+                        result = await generator.return(returnValue);
+                        break;
+                    }
                 } while (true);
                 return result.value;
             }
             finally {
+                if (alreadyUseCalledByNext
+                    && calledByNextFunctionWeakStore.get(theFlow) === alreadyUseCalledByNext) {
+                    calledByNextFunctionWeakStore.delete(theFlow);
+                }
+                if (alreadyUseQueue) {
+                    alreadyUseQueue();
+                }
                 await generator.return(undefined);
                 if (deferFunctions) {
                     await Promise.all(deferFunctions.map(justExec));
@@ -108,6 +199,16 @@ function exec(theFlow, ...[params]) {
                         injectionProperties.inject(params.dependencies[dependenceName]);
                     }
                 }
+                else if (throttlingKind.has(result.value)) {
+                    const { time, returnValue } = throttlingKind.getValue(result.value);
+                    const lastTime = throttlingLastTimeWeakStore.get(theFlow);
+                    const now = Date.now();
+                    throttlingLastTimeWeakStore.set(theFlow, now);
+                    if (typeof lastTime === "number" && (lastTime + time) > now) {
+                        result = generator.return(returnValue);
+                        break;
+                    }
+                }
             } while (true);
             return result.value;
         }

package/dist/flow/index.cjs

@@ -11,6 +11,11 @@ var inject = require('./inject.cjs');
 var step$1 = require('./step.cjs');
 var initializer = require('./initializer.cjs');
 var kind = require('./kind.cjs');
+var calledByNext$1 = require('./calledByNext.cjs');
+var queue$1 = require('./queue.cjs');
+var throttling$1 = require('./throttling.cjs');
+var toFunction = require('./toFunction.cjs');
+var debounce$1 = require('./debounce.cjs');
 var step = require('./theFlow/step.cjs');
 var exit = require('./theFlow/exit.cjs');
 var _break = require('./theFlow/break.cjs');
@@ -18,11 +23,21 @@ var injection = require('./theFlow/injection.cjs');
 var defer = require('./theFlow/defer.cjs');
 var finalizer = require('./theFlow/finalizer.cjs');
 var dependence = require('./theFlow/dependence.cjs');
+var throttling = require('./theFlow/throttling.cjs');
+var calledByNext = require('./theFlow/calledByNext.cjs');
+var queue = require('./theFlow/queue.cjs');
+var debounce = require('./theFlow/debounce.cjs');
 
 
 
 exports.MissingDependenceError = run.MissingDependenceError;
+exports.calledByNextFunctionWeakStore = run.calledByNextFunctionWeakStore;
+exports.debounceResumerWeakStore = run.debounceResumerWeakStore;
+exports.debounceTimeoutIdWeakStore = run.debounceTimeoutIdWeakStore;
+exports.queuesWeakStore = run.queuesWeakStore;
 exports.run = run.run;
+exports.throttlingLastTimeWeakStore = run.throttlingLastTimeWeakStore;
+exports.throttlingResumerWeakStore = run.throttlingResumerWeakStore;
 exports.create = index.create;
 exports.theFlowKind = index.theFlowKind;
 exports.breakIf = breakIf.breakIf;
@@ -34,6 +49,11 @@ exports.inject = inject.inject;
 exports.step = step$1.step;
 exports.createInitializer = initializer.createInitializer;
 exports.createFlowKind = kind.createFlowKind;
+exports.calledByNext = calledByNext$1.calledByNext;
+exports.queue = queue$1.queue;
+exports.throttling = throttling$1.throttling;
+exports.toFunction = toFunction.toFunction;
+exports.debounce = debounce$1.debounce;
 exports.createStep = step.createStep;
 exports.stepKind = step.stepKind;
 exports.createExit = exit.createExit;
@@ -48,3 +68,11 @@ exports.createFinalizer = finalizer.createFinalizer;
 exports.finalizerKind = finalizer.finalizerKind;
 exports.createDependence = dependence.createDependence;
 exports.dependenceHandlerKind = dependence.dependenceHandlerKind;
+exports.createThrottling = throttling.createThrottling;
+exports.throttlingKind = throttling.throttlingKind;
+exports.calledByNextKind = calledByNext.calledByNextKind;
+exports.createCalledByNext = calledByNext.createCalledByNext;
+exports.createQueue = queue.createQueue;
+exports.queueKind = queue.queueKind;
+exports.createDebounce = debounce.createDebounce;
+exports.debounceKind = debounce.debounceKind;

package/dist/flow/index.d.ts

@@ -10,3 +10,8 @@ export * from "./inject";
 export * from "./step";
 export * from "./initializer";
 export * from "./kind";
+export * from "./calledByNext";
+export * from "./queue";
+export * from "./throttling";
+export * from "./toFunction";
+export * from "./debounce";

package/dist/flow/index.mjs

@@ -1,4 +1,4 @@
-export { MissingDependenceError, run } from './run.mjs';
+export { MissingDependenceError, calledByNextFunctionWeakStore, debounceResumerWeakStore, debounceTimeoutIdWeakStore, queuesWeakStore, run, throttlingLastTimeWeakStore, throttlingResumerWeakStore } from './run.mjs';
 export { create, theFlowKind } from './theFlow/index.mjs';
 export { breakIf } from './breakIf.mjs';
 export { defer } from './defer.mjs';
@@ -9,6 +9,11 @@ export { inject } from './inject.mjs';
 export { step } from './step.mjs';
 export { createInitializer } from './initializer.mjs';
 export { createFlowKind } from './kind.mjs';
+export { calledByNext } from './calledByNext.mjs';
+export { queue } from './queue.mjs';
+export { throttling } from './throttling.mjs';
+export { toFunction } from './toFunction.mjs';
+export { debounce } from './debounce.mjs';
 export { createStep, stepKind } from './theFlow/step.mjs';
 export { createExit, exitKind } from './theFlow/exit.mjs';
 export { breakKind, createBreak } from './theFlow/break.mjs';
@@ -16,3 +21,7 @@ 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';
+export { createThrottling, throttlingKind } from './theFlow/throttling.mjs';
+export { calledByNextKind, createCalledByNext } from './theFlow/calledByNext.mjs';
+export { createQueue, queueKind } from './theFlow/queue.mjs';
+export { createDebounce, debounceKind } from './theFlow/debounce.mjs';

package/dist/flow/queue.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var queue$1 = require('./theFlow/queue.cjs');
+
+/**
+ * {@include flow/queue/index.md}
+ */
+async function* queue(params) {
+    let resolver = undefined;
+    yield queue$1.createQueue({
+        concurrency: params?.concurrency ?? 1,
+        injectResolver: (injectResolver) => {
+            resolver = injectResolver;
+        },
+    });
+    return resolver;
+}
+
+exports.queue = queue;