Smarter waitForDebounce that resolve only with the last promise

src/tools/waitForDebounce.ts

@@ -1,27 +1,42 @@
 import { Deferred } from "evt/tools/Deferred";
-import { assert } from "tsafe/assert";
 
 export function waitForDebounceFactory(params: { delay: number }) {
     const { delay } = params;
 
-    let d: Deferred<void | never> | undefined = undefined;
+    let curr: { timer: ReturnType<typeof setTimeout>; startTime: number; } | undefined = undefined;
 
     function waitForDebounce(): Promise<void | never> {
 
-        if (d !== undefined) {
-            return new Promise<void>(() => { /* Never resolve */ });
-        }
+        const dOut = new Deferred<void | never>();
+
+        const timerCallback = () => {
+            curr = undefined;
+            dOut.resolve();
+
+        };
+
+        if (curr !== undefined) {
+
+            clearTimeout(curr.timer);
+
+            curr.timer = setTimeout(timerCallback, delay - (Date.now() - curr.startTime));
 
-        d = new Deferred();
+            return dOut.pr;
 
-        setTimeout(() => {
-            assert(d !== undefined);
-            d.resolve();
-            d = undefined;
-        }, delay);
+        } else {
 
-        return d.pr;
+            const startTime = Date.now();
+
+            curr = {
+                "timer": setTimeout(timerCallback, delay),
+                startTime
+            };
+
+        }
+
+        return dOut.pr;
     }
 
     return { waitForDebounce };
 }
+