@nu-art/ts-common 0.204.99 → 0.204.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.204.99",
+  "version": "0.204.100",
   "description": "js and ts infra",
   "keywords": [
     "TacB0sS",

package/utils/ui-tools.d.ts

@@ -28,6 +28,7 @@
  * // or at least once after 1000ms, regardless of continuous calls.
  */
 export declare const debounce: <Args extends any[]>(func: (...params: Args) => any | Promise<any>, timeout?: number, maxTimeout?: number) => (...args: Args) => void;
+export declare const queuedDebounce: <Args extends any[]>(func: (...params: Args) => any | Promise<any>, timeout?: number, maxTimeout?: number) => (...args: Args) => void;
 export type AwaitedDebounceInstance<Args extends any[], ReturnValue> = (...args: Args) => Promise<ReturnValue | undefined>;
 type DebounceParams<Args extends any[], ReturnValue = any> = {
     func: (...params: Args) => Promise<ReturnValue>;

package/utils/ui-tools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitedDebounce = exports.debounce = void 0;
+exports.awaitedDebounce = exports.queuedDebounce = exports.debounce = void 0;
 /**
  * Creates a debounced function that delays invoking the provided function until after a specified
  * timeout has elapsed since the last time the debounced function was called. It also ensures that
@@ -49,6 +49,41 @@ const debounce = (func, timeout = 500, maxTimeout = 1000) => {
     };
 };
 exports.debounce = debounce;
+const queuedDebounce = (func, timeout = 500, maxTimeout = 1000) => {
+    let timer;
+    let defaultTimer;
+    let running = false;
+    const debounceFunc = (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+            clearTimeout(defaultTimer);
+            defaultTimer = undefined;
+            await execFunc(...args);
+        }, timeout);
+        if (!defaultTimer) {
+            defaultTimer = setTimeout(async () => {
+                defaultTimer = undefined;
+                await execFunc(...args);
+            }, maxTimeout);
+        }
+    };
+    const execFunc = async (...args) => {
+        if (running) {
+            clearTimeout(defaultTimer);
+            defaultTimer = undefined;
+            return debounceFunc(...args);
+        }
+        try {
+            running = true;
+            await func(...args);
+        }
+        finally {
+            running = false;
+        }
+    };
+    return debounceFunc;
+};
+exports.queuedDebounce = queuedDebounce;
 const awaitedDebounce = (params) => {
     const timers = {};
     const _clearTimeout = (timer) => {