@duplojs/utils 1.6.0 → 1.6.2

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/initializer.d.ts

@@ -21,7 +21,7 @@ export type Initializer<GenericArgs extends unknown[], GenericOutput extends unk
  * The returned initializer can then be executed inside `F.run(...)` like any other flow generator.
  * 
  * ```ts
- * const userInitializer = createInitializer(
+ * const userInitializer = F.createInitializer(
  * 	(name: string) => ({ name }),
  * 	{ defer: (user) => void console.log(`close:${user.name}`) },
  * );
@@ -33,7 +33,7 @@ export type Initializer<GenericArgs extends unknown[], GenericOutput extends unk
  * ); // { name: "Ada" }
  * 
  * const finalizerLogs: string[] = [];
- * const tokenInitializer = createInitializer(
+ * const tokenInitializer = F.createInitializer(
  * 	(id: number) => `token-${id}`,
  * 	{ finalizer: (token) => finalizerLogs.push(token) },
  * );
@@ -44,7 +44,7 @@ export type Initializer<GenericArgs extends unknown[], GenericOutput extends unk
  * 	},
  * ); // "token-42"
  * 
- * const asyncInitializer = createInitializer(
+ * const asyncInitializer = F.createInitializer(
  * 	(name: string) => Promise.resolve({
  * 		name,
  * 		ready: true,

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;

package/dist/flow/queue.d.ts

@@ -0,0 +1,47 @@
+import { type OnlyLiteralNumber } from "../common";
+/**
+ * Reserves execution through the async flow queue and returns a resolver that releases the reserved slot.
+ * 
+ * **Supported call styles:**
+ * - Classic: `queue()` -> yields a queue effect with concurrency `1`
+ * - Classic with options: `queue({ concurrency })` -> yields a queue effect with the provided concurrency
+ * 
+ * `queue` is an async flow helper consumed by the runner.
+ * It asks the runner to serialize or limit concurrent executions of the same flow.
+ * When the slot is granted, the helper returns a `release` function that should be called once the protected section is finished.
+ * 
+ * ```ts
+ * const saveFlow = F.create(
+ * 	async function *(name: string) {
+ * 		const release = yield *F.queue({
+ * 			concurrency: 1,
+ * 		});
+ * 
+ * 		try {
+ * 			return await Promise.resolve(`saved:${name}` as const);
+ * 		} finally {
+ * 			release();
+ * 		}
+ * 	},
+ * );
+ * const saveUser = F.toFunction(saveFlow);
+ * 
+ * await saveUser("alice"); // Promise<"saved:alice">
+ * 
+ * await saveUser("bob"); // Promise<"saved:bob">
+ * ```
+ * 
+ * @remarks
+ * - `queue` is meaningful only in asynchronous flows handled by `F.run(...)`
+ * - Reuse the same flow reference to share the same queue across runs
+ * - If the same flow execution yields `queue(...)` 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 queue-aware execution
+ * @see https://utils.duplojs.dev/en/v1/api/flow/queue
+ * 
+ * @namespace F
+ * 
+ */
+export declare function queue<GenericConcurrency extends number>(params?: {
+    concurrency?: GenericConcurrency & OnlyLiteralNumber<GenericConcurrency>;
+}): AsyncGenerator<import("./theFlow").Queue, () => void, unknown>;

package/dist/flow/queue.mjs

@@ -0,0 +1,17 @@
+import { createQueue } from './theFlow/queue.mjs';
+
+/**
+ * {@include flow/queue/index.md}
+ */
+async function* queue(params) {
+    let resolver = undefined;
+    yield createQueue({
+        concurrency: params?.concurrency ?? 1,
+        injectResolver: (injectResolver) => {
+            resolver = injectResolver;
+        },
+    });
+    return resolver;
+}
+
+export { queue };

package/dist/flow/run.cjs

@@ -9,6 +9,12 @@ 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 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 justExec = require('../common/justExec.cjs');
 var kind = require('../common/kind.cjs');
 
@@ -19,6 +25,18 @@ class MissingDependenceError extends kind.kindHeritage("missing-dependence-error
         this.dependenceHandler = dependenceHandler;
     }
 }
+/** @internal */
+const throttlingLastTimeWeakStore = new WeakMap();
+/** @internal */
+const throttlingResumerWeakStore = new WeakMap();
+/** @internal */
+const debounceTimeoutIdWeakStore = new WeakMap();
+/** @internal */
+const debounceResumerWeakStore = new WeakMap();
+/** @internal */
+const calledByNextFunctionWeakStore = new WeakMap();
+/** @internal */
+const queuesWeakStore = new WeakMap();
 /**
  * {@include flow/run/index.md}
  */
@@ -26,6 +44,10 @@ function run(theFlow, ...[params]) {
     let result = undefined;
     let deferFunctions = undefined;
     let steps = undefined;
+    let alreadyUseThrottling = undefined;
+    let alreadyUseDebounce = undefined;
+    let alreadyUseCalledByNext = undefined;
+    let alreadyUseQueue = undefined;
     const generator = typeof theFlow === "function"
         ? theFlow(params?.input)
         : index.theFlowKind.getValue(theFlow).run(params?.input);
@@ -67,6 +89,79 @@ function run(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 = 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$1 = externalPromise.createExternalPromise();
+                                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 = throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(true);
+                            }, time);
+                        }
+                    }
+                    else if (calledByNext.calledByNextKind.has(result.value)) {
+                        if (alreadyUseCalledByNext) {
+                            continue;
+                        }
+                        alreadyUseCalledByNext = calledByNext.calledByNextKind.getValue(result.value);
+                        const lastFunction = calledByNextFunctionWeakStore.get(theFlow);
+                        const lastResult = lastFunction?.();
+                        if (lastResult instanceof Promise) {
+                            await lastResult;
+                        }
+                        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 = queuesWeakStore.get(theFlow);
+                        if (queue$2 === undefined) {
+                            queue$2 = queue$1.createQueue({ concurrency });
+                            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 = debounceTimeoutIdWeakStore.get(theFlow);
+                        clearTimeout(lastTimeout);
+                        const lastResumer = debounceResumerWeakStore.get(theFlow);
+                        lastResumer?.(false);
+                        const externalPromise$1 = externalPromise.createExternalPromise();
+                        debounceTimeoutIdWeakStore.set(theFlow, setTimeout(() => void externalPromise$1.resolve(true), time));
+                        debounceResumerWeakStore.set(theFlow, externalPromise$1.resolve);
+                        if (await externalPromise$1.promise) {
+                            continue;
+                        }
+                        result = await generator.return(returnValue);
+                        break;
+                    }
                 } while (true);
                 return params?.includeDetails === true
                     ? {
@@ -76,6 +171,13 @@ function run(theFlow, ...[params]) {
                     : 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.justExec));
@@ -119,6 +221,16 @@ function run(theFlow, ...[params]) {
                 }
                 injectionProperties.inject(params.dependencies[dependenceName]);
             }
+            else if (throttling.throttlingKind.has(result.value)) {
+                const { time, returnValue } = throttling.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 (params?.includeDetails === true
             ? {
@@ -136,4 +248,10 @@ function run(theFlow, ...[params]) {
 }
 
 exports.MissingDependenceError = MissingDependenceError;
+exports.calledByNextFunctionWeakStore = calledByNextFunctionWeakStore;
+exports.debounceResumerWeakStore = debounceResumerWeakStore;
+exports.debounceTimeoutIdWeakStore = debounceTimeoutIdWeakStore;
+exports.queuesWeakStore = queuesWeakStore;
 exports.run = run;
+exports.throttlingLastTimeWeakStore = throttlingLastTimeWeakStore;
+exports.throttlingResumerWeakStore = throttlingResumerWeakStore;

package/dist/flow/run.d.ts

@@ -1,6 +1,8 @@
 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<[
+import { type TheFlow, type TheFlowFunction, type FlowInput, type WrapFlow, type TheFlowGenerator, type Exit, type Break, type Step, type FlowDependencies, type DependenceHandler, type ExtractFlowGenerator, type Throttling, type Injection, type Debounce } from "./theFlow";
+import { type Defer } from "./theFlow/defer";
+import { type Finalizer } from "./theFlow/finalizer";
+type ComputeRunParams<GenericInput extends unknown = unknown, GenericDependencies extends Record<string, unknown> = Record<string, unknown>> = SimplifyTopLevel<(Or<[
     IsEqual<GenericInput, unknown>,
     IsEqual<GenericInput, never>,
     IsExtends<GenericInput, undefined>
@@ -19,7 +21,7 @@ export interface FlowDetails<GenericValue extends unknown, GenericStepName exten
     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;
+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 : InferredEffect extends Throttling<infer InferredValue> ? InferredValue : InferredEffect extends Debounce<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>;
@@ -76,5 +78,5 @@ export declare class MissingDependenceError extends MissingDependenceError_base
  * @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 declare function run<GenericFlow extends (TheFlowFunction<any, TheFlowGenerator<unknown, Injection | Step | Exit | Break | Defer | Finalizer>> | 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 {};