@duplojs/utils 1.6.1 → 1.6.3

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

package/dist/flow/run.mjs

@@ -7,6 +7,12 @@ 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 { 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 { justExec } from '../common/justExec.mjs';
 import { kindHeritage } from '../common/kind.mjs';
 
@@ -17,6 +23,18 @@ class MissingDependenceError extends kindHeritage("missing-dependence-error", cr
         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}
  */
@@ -24,6 +42,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)
         : theFlowKind.getValue(theFlow).run(params?.input);
@@ -65,6 +87,79 @@ function run(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 params?.includeDetails === true
                     ? {
@@ -74,6 +169,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));
@@ -117,6 +219,16 @@ function run(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 (params?.includeDetails === true
             ? {
@@ -133,4 +245,4 @@ function run(theFlow, ...[params]) {
     }
 }
 
-export { MissingDependenceError, run };
+export { MissingDependenceError, calledByNextFunctionWeakStore, debounceResumerWeakStore, debounceTimeoutIdWeakStore, queuesWeakStore, run, throttlingLastTimeWeakStore, throttlingResumerWeakStore };

package/dist/flow/theFlow/calledByNext.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const calledByNextKind = kind.createFlowKind("called-by-next");
+function createCalledByNext(value) {
+    return calledByNextKind.setTo({}, value);
+}
+
+exports.calledByNextKind = calledByNextKind;
+exports.createCalledByNext = createCalledByNext;

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

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

package/dist/flow/theFlow/calledByNext.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const calledByNextKind = createFlowKind("called-by-next");
+function createCalledByNext(value) {
+    return calledByNextKind.setTo({}, value);
+}
+
+export { calledByNextKind, createCalledByNext };

package/dist/flow/theFlow/debounce.cjs

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

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

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common";
+export declare const debounceKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/debounce", unknown>>;
+export interface DebounceProperties<GenericValue extends unknown = unknown> {
+    time: number;
+    returnValue: GenericValue;
+}
+export interface Debounce<GenericValue extends unknown = unknown> extends Kind<typeof debounceKind.definition, DebounceProperties<GenericValue>> {
+}
+export declare function createDebounce<GenericValue extends unknown>(properties: DebounceProperties<GenericValue>): Debounce<GenericValue>;

package/dist/flow/theFlow/debounce.mjs

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

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

@@ -6,6 +6,10 @@ import { type Break } from "./break";
 import { type Defer } from "./defer";
 import { type Finalizer } from "./finalizer";
 import { type DependenceHandler, type dependenceHandlerKind } from "./dependence";
+import { type Throttling } from "./throttling";
+import { type CalledByNext } from "./calledByNext";
+import { type Queue } from "./queue";
+import { type Debounce } from "./debounce";
 export * from "./step";
 export * from "./exit";
 export * from "./break";
@@ -13,8 +17,12 @@ 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 * from "./throttling";
+export * from "./calledByNext";
+export * from "./queue";
+export * from "./debounce";
+export type Effect = (Injection | Step | Exit | Break | Defer | Finalizer | Throttling | CalledByNext | Queue | Debounce);
+export type TheFlowGenerator<GenericOutput extends unknown = unknown, GenericEffect extends Effect = Effect> = (Generator<Exclude<GenericEffect, (Queue | CalledByNext | Debounce)>, 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;
@@ -78,7 +86,7 @@ export interface TheFlow<GenericFunction extends TheFlowFunction = TheFlowFuncti
  */
 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 WrapFlow<GenericFlow extends (TheFlow | TheFlowFunction | TheFlowGenerator)> = GenericFlow extends TheFlowGenerator ? TheFlow<TheFlowFunction<unknown, GenericFlow>> : GenericFlow extends TheFlowFunction ? TheFlow<GenericFlow> : Extract<GenericFlow, TheFlow>;
 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;

package/dist/flow/theFlow/queue.cjs

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

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

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common";
+export declare const queueKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/queue", unknown>>;
+export interface QueueProperties {
+    concurrency: number;
+    injectResolver(resolver: () => void): void;
+}
+export interface Queue extends Kind<typeof queueKind.definition, QueueProperties> {
+}
+export declare function createQueue(properties: QueueProperties): Queue;

package/dist/flow/theFlow/queue.mjs

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

package/dist/flow/theFlow/throttling.cjs

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

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

@@ -0,0 +1,10 @@
+import { type Kind } from "../../common";
+export declare const throttlingKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/throttling", unknown>>;
+export interface ThrottlingProperties<GenericValue extends unknown = unknown> {
+    time: number;
+    returnValue: GenericValue;
+    keepLast: boolean;
+}
+export interface Throttling<GenericValue extends unknown = unknown> extends Kind<typeof throttlingKind.definition, ThrottlingProperties<GenericValue>> {
+}
+export declare function createThrottling<GenericValue extends unknown>(properties: ThrottlingProperties<GenericValue>): Throttling<GenericValue>;

package/dist/flow/theFlow/throttling.mjs

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

package/dist/flow/throttling.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var throttling$1 = require('./theFlow/throttling.cjs');
+
+/**
+ * {@include flow/throttling/index.md}
+ */
+function throttling(time, params) {
+    if (params?.keepLast === true) {
+        return (async function* () {
+            yield throttling$1.createThrottling({
+                time,
+                returnValue: params?.returnValue,
+                keepLast: true,
+            });
+        })();
+    }
+    return (function* () {
+        yield throttling$1.createThrottling({
+            time,
+            returnValue: params?.returnValue,
+            keepLast: false,
+        });
+    })();
+}
+
+exports.throttling = throttling;