git-watchtower 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {

package/src/utils/async.js

@@ -175,6 +175,18 @@ function sleep(ms) {
 
 /**
  * Debounce a function - only execute after delay with no calls
+ *
+ * cancel() both clears the pending timer and sets an internal flag
+ * that the scheduled callback checks at the top. Without the flag,
+ * cancel() racing with a timer whose callback has already been
+ * dequeued (the timer fired, but the callback hadn't executed yet)
+ * was a no-op — clearTimeout can't recall a callback that libuv
+ * has already promoted — so fn would run anyway and write into
+ * state the caller had just asked to abandon.
+ *
+ * Calling debounced(...) re-arms: the cancelled flag resets so a new
+ * schedule is not pre-squelched by a prior cancel().
+ *
  * @template {(...args: any[]) => void} T
  * @param {T} fn - Function to debounce
  * @param {number} delay - Delay in milliseconds
@@ -182,18 +194,22 @@ function sleep(ms) {
  */
 function debounce(fn, delay) {
   let timeoutId = null;
+  let cancelled = false;
 
   const debounced = (...args) => {
     if (timeoutId) {
       clearTimeout(timeoutId);
     }
+    cancelled = false;
     timeoutId = setTimeout(() => {
-      fn(...args);
       timeoutId = null;
+      if (cancelled) return;
+      fn(...args);
     }, delay);
   };
 
   debounced.cancel = () => {
+    cancelled = true;
     if (timeoutId) {
       clearTimeout(timeoutId);
       timeoutId = null;
@@ -206,17 +222,24 @@ function debounce(fn, delay) {
 
 /**
  * Throttle a function - execute at most once per interval
+ *
+ * Mirrors debounce() in returning a wrapped function with a `.cancel()`
+ * method. If a trailing call has been scheduled (throttle fires on the
+ * leading edge and coalesces further calls during the interval into a
+ * single trailing call), cancel() drops it. Wire cancel() into shutdown
+ * paths so a UI-event-driven throttle can't fire a deferred call after
+ * the target module has torn down and leave state partially written.
+ *
  * @template {(...args: any[]) => void} T
  * @param {T} fn - Function to throttle
  * @param {number} interval - Minimum interval between calls in milliseconds
- * @returns {T}
+ * @returns {T & { cancel: () => void }}
  */
 function throttle(fn, interval) {
   let lastCall = 0;
   let timeoutId = null;
 
-  // @ts-ignore - TypeScript can't verify generic function return type
-  return (...args) => {
+  const throttled = (...args) => {
     const now = Date.now();
     const timeSinceLastCall = now - lastCall;
 
@@ -232,6 +255,16 @@ function throttle(fn, interval) {
       }, interval - timeSinceLastCall);
     }
   };
+
+  throttled.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+
+  // @ts-ignore - TypeScript can't verify generic function augmentation
+  return throttled;
 }
 
 module.exports = {