@duplojs/utils 1.6.0 → 1.6.2

package/dist/common/asserts.cjs

@@ -18,6 +18,18 @@ function asserts(input, predicate) {
         throw new AssertsError(input);
     }
 }
+function forwardAsserts(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => forwardAsserts(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (!theFunction(input)) {
+        throw new AssertsError(input);
+    }
+    return input;
+}
 
 exports.AssertsError = AssertsError;
 exports.asserts = asserts;
+exports.forwardAsserts = forwardAsserts;

package/dist/common/asserts.d.ts

@@ -33,4 +33,30 @@ export declare class AssertsError extends AssertsError_base {
  * 
  */
 export declare function asserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): asserts input is GenericPredicate;
+/**
+ * The forwardAsserts() function throws when a predicate fails and returns the validated input. It supports classic and curried forms, with type-guard and boolean predicates.
+ * 
+ * **Supported call styles:**
+ * - Classic: `forwardAsserts(input, predicate)` → returns the narrowed input or throws
+ * - Curried: `forwardAsserts(predicate)(input)` → returns the validated input or throws
+ * 
+ * It is useful when you want both runtime validation and a returned value you can keep using directly, especially inside `pipe()`. With a type guard predicate, the return type is narrowed. With a boolean predicate, the original input type is preserved. It throws an `AssertsError` with the failing input value.
+ * 
+ * ```ts
+ * const input = "demo" as string | number;
+ * const result = forwardAsserts(input, isType("string"));
+ * 
+ * const pipedResult = pipe(
+ * 	"admin" as string | number,
+ * 	forwardAsserts(isType("string")),
+ * );
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/forwardAsserts
+ * 
+ */
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(predicate: (input: GenericInput) => input is GenericPredicate): (input: GenericInput) => GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(predicate: (input: GenericInput) => boolean): (input: GenericInput) => GenericInput;
+export declare function forwardAsserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): GenericPredicate;
+export declare function forwardAsserts<GenericInput extends unknown>(input: GenericInput, predicate: (input: GenericInput) => boolean): GenericInput;
 export {};

package/dist/common/asserts.mjs

@@ -16,5 +16,16 @@ function asserts(input, predicate) {
         throw new AssertsError(input);
     }
 }
+function forwardAsserts(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => forwardAsserts(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (!theFunction(input)) {
+        throw new AssertsError(input);
+    }
+    return input;
+}
 
-export { AssertsError, asserts };
+export { AssertsError, asserts, forwardAsserts };

package/dist/common/callThen.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * {@include common/callThen/index.md}
+ */
+function callThen(input, TheFunction) {
+    if (input instanceof Promise) {
+        return input
+            .then(TheFunction);
+    }
+    return TheFunction(input);
+}
+
+exports.callThen = callThen;

package/dist/common/callThen.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The callThen() function applies a callback to a value immediately, or waits for a promise input before running the same callback.
+ * 
+ * Supported call styles:
+ * - Classic: `callThen(input, callback)` → returns a value or a promise depending on the input and callback
+ * 
+ * Behavior:
+ * - direct values call the callback synchronously
+ * - `Promise` inputs call the callback through `.then(...)`
+ * - callback promises are preserved for direct values and flattened for `Promise` inputs
+ * 
+ * ```ts
+ * const syncResult = callThen(
+ * 	2,
+ * 	(value) => value * 3,
+ * );
+ * // type: number
+ * 
+ * const asyncFromSync = callThen(
+ * 	"duplo",
+ * 	async(value) => Promise.resolve(value.toUpperCase()),
+ * );
+ * // type: Promise<string>
+ * 
+ * const asyncFromPromise = callThen(
+ * 	Promise.resolve({
+ * 		count: 2,
+ * 	}),
+ * 	({ count }) => count + 1,
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/callThen
+ * 
+ */
+export declare function callThen<GenericInput extends unknown, GenericOutput extends unknown>(input: GenericInput, TheFunction: (input: Awaited<GenericInput>) => GenericOutput): GenericInput extends Promise<unknown> ? Promise<Awaited<GenericOutput>> : GenericOutput;

package/dist/common/callThen.mjs

@@ -0,0 +1,12 @@
+/**
+ * {@include common/callThen/index.md}
+ */
+function callThen(input, TheFunction) {
+    if (input instanceof Promise) {
+        return input
+            .then(TheFunction);
+    }
+    return TheFunction(input);
+}
+
+export { callThen };

package/dist/common/index.d.ts

@@ -78,3 +78,5 @@ export * from "./path";
 export * from "./transformer";
 export * from "./toRegExp";
 export * from "./justExec";
+export * from "./callThen";
+export * from "./queue";

package/dist/common/queue.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var callThen = require('./callThen.cjs');
+var externalPromise = require('./externalPromise.cjs');
+var kind = require('./kind.cjs');
+var create = require('../either/left/create.cjs');
+
+const queueKind = kind.createKind("queue");
+/**
+ * {@include common/queue/index.md}
+ */
+function createQueue(params) {
+    const concurrency = params?.concurrency === undefined || params.concurrency < 1
+        ? 1
+        : params.concurrency;
+    let quantityRunning = 0;
+    let firstElement = undefined;
+    function add(theFunction) {
+        const externalPromise$1 = externalPromise.createExternalPromise();
+        const preparedFunction = () => {
+            quantityRunning++;
+            if (firstElement?.theFunction === preparedFunction) {
+                if (firstElement === firstElement.next) {
+                    firstElement = undefined;
+                }
+                else {
+                    const newFirst = firstElement.next;
+                    const last = firstElement.previous;
+                    newFirst.previous = last;
+                    last.next = newFirst;
+                    firstElement = newFirst;
+                }
+            }
+            let result = undefined;
+            try {
+                const MaybePromise = theFunction();
+                result = MaybePromise instanceof Promise
+                    ? MaybePromise.catch((error) => create.left("execution-error", error))
+                    : MaybePromise;
+            }
+            catch (error) {
+                result = create.left("execution-error", error);
+            }
+            callThen.callThen(result, (output) => {
+                externalPromise$1.resolve(output);
+                quantityRunning--;
+                firstElement?.theFunction();
+            });
+        };
+        if (quantityRunning < concurrency) {
+            void preparedFunction();
+        }
+        else if (firstElement === undefined) {
+            firstElement = {
+                theFunction: preparedFunction,
+                next: undefined,
+                previous: undefined,
+            };
+            firstElement.next = firstElement;
+            firstElement.previous = firstElement;
+        }
+        else {
+            const oldLast = firstElement.previous;
+            const newLastElement = {
+                theFunction: preparedFunction,
+                next: firstElement,
+                previous: firstElement.previous,
+            };
+            oldLast.next = newLastElement;
+            firstElement.previous = newLastElement;
+        }
+        return externalPromise$1.promise;
+    }
+    function addExternal() {
+        const externalPromiseToStart = externalPromise.createExternalPromise();
+        const externalPromiseToFinish = externalPromise.createExternalPromise();
+        void add(() => {
+            externalPromiseToStart.resolve(externalPromiseToFinish.resolve);
+            return externalPromiseToFinish.promise;
+        });
+        return externalPromiseToStart.promise;
+    }
+    return queueKind.setTo({
+        add,
+        addExternal,
+    });
+}
+
+exports.createQueue = createQueue;
+exports.queueKind = queueKind;

package/dist/common/queue.d.ts

@@ -0,0 +1,46 @@
+import { type Kind } from "./kind";
+import * as DEither from "../either";
+export declare const queueKind: import("./kind").KindHandler<import("./kind").KindDefinition<"queue", unknown>>;
+export interface Queue extends Kind<typeof queueKind.definition> {
+    add<GenericOutput extends unknown>(theFunction: () => GenericOutput): Promise<Awaited<GenericOutput> | DEither.Left<"execution-error", unknown>>;
+    addExternal(): Promise<() => void>;
+}
+export interface CreateQueueParams {
+    concurrency?: number;
+}
+/**
+ * The createQueue() function creates a FIFO queue object that limits how many tasks run at the same time and resolves each task result as a promise.
+ * 
+ * Supported call styles:
+ * - Classic: `createQueue()` → returns a queue object
+ * - Classic with options: `createQueue({ concurrency })` → returns a queue object
+ * 
+ * Behavior:
+ * - `queue.add(callback)` starts the callback immediately when a slot is available, otherwise it enqueues it
+ * - task results are always exposed through a promise
+ * - thrown errors and rejected promises are converted to `DEither.left("execution-error", error)`
+ * - `queue.addExternal()` reserves one slot and resolves with a release function
+ * 
+ * ```ts
+ * const defaultQueue = createQueue();
+ * const numberResult = await defaultQueue.add(() => 42);
+ * // type: 42 | Left<"execution-error", unknown>
+ * 
+ * const serialQueue = createQueue({
+ * 	concurrency: 1,
+ * });
+ * const textResult = await serialQueue.add(() => "hello" as const);
+ * // type: "hello" | Left<"execution-error", unknown>
+ * 
+ * const asyncQueue = createQueue();
+ * const asyncResult = await asyncQueue.add(
+ * 	async() => Promise.resolve("done" as const),
+ * );
+ * // type: "done" | Left<"execution-error", unknown>
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/queue
+ * 
+ */
+export declare function createQueue(params?: CreateQueueParams): Queue;

package/dist/common/queue.mjs

@@ -0,0 +1,87 @@
+import { callThen } from './callThen.mjs';
+import { createExternalPromise } from './externalPromise.mjs';
+import { createKind } from './kind.mjs';
+import { left } from '../either/left/create.mjs';
+
+const queueKind = createKind("queue");
+/**
+ * {@include common/queue/index.md}
+ */
+function createQueue(params) {
+    const concurrency = params?.concurrency === undefined || params.concurrency < 1
+        ? 1
+        : params.concurrency;
+    let quantityRunning = 0;
+    let firstElement = undefined;
+    function add(theFunction) {
+        const externalPromise = createExternalPromise();
+        const preparedFunction = () => {
+            quantityRunning++;
+            if (firstElement?.theFunction === preparedFunction) {
+                if (firstElement === firstElement.next) {
+                    firstElement = undefined;
+                }
+                else {
+                    const newFirst = firstElement.next;
+                    const last = firstElement.previous;
+                    newFirst.previous = last;
+                    last.next = newFirst;
+                    firstElement = newFirst;
+                }
+            }
+            let result = undefined;
+            try {
+                const MaybePromise = theFunction();
+                result = MaybePromise instanceof Promise
+                    ? MaybePromise.catch((error) => left("execution-error", error))
+                    : MaybePromise;
+            }
+            catch (error) {
+                result = left("execution-error", error);
+            }
+            callThen(result, (output) => {
+                externalPromise.resolve(output);
+                quantityRunning--;
+                firstElement?.theFunction();
+            });
+        };
+        if (quantityRunning < concurrency) {
+            void preparedFunction();
+        }
+        else if (firstElement === undefined) {
+            firstElement = {
+                theFunction: preparedFunction,
+                next: undefined,
+                previous: undefined,
+            };
+            firstElement.next = firstElement;
+            firstElement.previous = firstElement;
+        }
+        else {
+            const oldLast = firstElement.previous;
+            const newLastElement = {
+                theFunction: preparedFunction,
+                next: firstElement,
+                previous: firstElement.previous,
+            };
+            oldLast.next = newLastElement;
+            firstElement.previous = newLastElement;
+        }
+        return externalPromise.promise;
+    }
+    function addExternal() {
+        const externalPromiseToStart = createExternalPromise();
+        const externalPromiseToFinish = createExternalPromise();
+        void add(() => {
+            externalPromiseToStart.resolve(externalPromiseToFinish.resolve);
+            return externalPromiseToFinish.promise;
+        });
+        return externalPromiseToStart.promise;
+    }
+    return queueKind.setTo({
+        add,
+        addExternal,
+    });
+}
+
+export { createQueue, queueKind };

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;
         }