@iblai/web-utils 1.11.12 → 1.12.0

package/dist/index.js

@@ -11914,46 +11914,117 @@ const selectIsReasoning = (state) => state.chatSliceShared.currentStreamingMessa
 // NEW: Get streaming tool calls
 const selectStreamingToolCalls = (state) => state.chatSliceShared.currentStreamingMessage.toolCalls;
 
+const DEFAULT_IDLE_TIMEOUT_SECONDS = 120;
+// Minimum gap between idle-timer resets. Interaction events like mousemove fire
+// rapidly; there's no need to restart the (minutes-long) idle countdown more
+// than once per second.
+const ACTIVITY_THROTTLE_MS = 1000;
+// User interactions that count as activity and keep the user "present".
+const ACTIVITY_EVENTS = [
+    "mousemove",
+    "mousedown",
+    "keydown",
+    "wheel",
+    "scroll",
+    "touchstart",
+    "pointerdown",
+];
 class TimeTracker {
     constructor(config) {
+        var _a, _b, _c;
         this.state = {
             currentUrl: "",
-            startTime: 0,
             intervalId: null,
             routeUnsubscribe: null,
+            accumulatedMs: 0,
+            activeSince: null,
+            isVisible: true,
+            isFocused: true,
+            isIdle: false,
+            idleTimerId: null,
         };
+        // Timestamp of the last activity that reset the idle timer (for throttling).
+        this.lastActivityAt = 0;
+        // Bound listeners kept so they can be removed on destroy.
+        this.handleActivity = () => this.onActivity();
+        this.handleVisibilityChange = () => this.onVisibilityChange();
+        this.handleWindowFocus = () => this.onWindowFocus();
+        this.handleWindowBlur = () => this.onWindowBlur();
         this.config = config;
+        this.idleTimeoutMs =
+            ((_a = config.idleTimeoutSeconds) !== null && _a !== void 0 ? _a : DEFAULT_IDLE_TIMEOUT_SECONDS) * 1000;
+        this.pauseOnHidden = (_b = config.pauseOnHidden) !== null && _b !== void 0 ? _b : true;
+        this.pauseOnBlur = (_c = config.pauseOnBlur) !== null && _c !== void 0 ? _c : true;
+        this.idleDetectionEnabled =
+            this.idleTimeoutMs > 0 &&
+                typeof window !== "undefined" &&
+                typeof document !== "undefined";
         this.initialize();
     }
     initialize() {
         this.state.currentUrl = this.config.getCurrentUrl();
+        // Seed activity signals from the current environment.
+        if (this.pauseOnHidden && typeof document !== "undefined") {
+            this.state.isVisible = !document.hidden;
+        }
+        this.state.isFocused = true;
+        this.state.isIdle = false;
+        this.attachActivityListeners();
         this.startTracking();
+        this.startIdleTimer();
         if (this.config.onRouteChange) {
             this.state.routeUnsubscribe = this.config.onRouteChange(() => {
                 this.handleRouteChange();
             });
         }
     }
+    // --- Active time accounting -------------------------------------------------
+    /** Whether time should currently be counted. */
+    isActive() {
+        return this.state.isVisible && this.state.isFocused && !this.state.isIdle;
+    }
+    /**
+     * Reconcile the active window with the current activity signals: open a new
+     * window when the user becomes active, or bank the elapsed time when they
+     * become inactive.
+     */
+    syncActiveWindow() {
+        const active = this.isActive();
+        if (active && this.state.activeSince === null) {
+            this.state.activeSince = Date.now();
+        }
+        else if (!active && this.state.activeSince !== null) {
+            this.state.accumulatedMs += Date.now() - this.state.activeSince;
+            this.state.activeSince = null;
+        }
+    }
+    getTimeSpent() {
+        let total = this.state.accumulatedMs;
+        if (this.state.activeSince !== null) {
+            total += Date.now() - this.state.activeSince;
+        }
+        return total;
+    }
+    resetTimer() {
+        this.state.accumulatedMs = 0;
+        this.state.activeSince = this.isActive() ? Date.now() : null;
+    }
     startTracking() {
-        this.state.startTime = Date.now();
-        this.clearInterval();
+        this.clearTrackingInterval();
+        this.resetTimer();
+        if (typeof window === "undefined")
+            return;
         this.state.intervalId = window.setInterval(() => {
             this.sendTimeUpdate();
             this.resetTimer();
         }, this.config.intervalSeconds * 1000);
     }
-    clearInterval() {
+    clearTrackingInterval() {
         if (this.state.intervalId !== null) {
             clearInterval(this.state.intervalId);
             this.state.intervalId = null;
         }
     }
-    resetTimer() {
-        this.state.startTime = Date.now();
-    }
-    getTimeSpent() {
-        return Date.now() - this.state.startTime;
-    }
     sendTimeUpdate() {
         const timeSpent = this.getTimeSpent();
         if (timeSpent > 0) {
@@ -11968,16 +12039,116 @@ class TimeTracker {
             this.resetTimer();
         }
     }
+    // --- Activity / inactivity detection ---------------------------------------
+    attachActivityListeners() {
+        if (typeof window !== "undefined" && window.addEventListener) {
+            if (this.idleDetectionEnabled) {
+                for (const event of ACTIVITY_EVENTS) {
+                    window.addEventListener(event, this.handleActivity, {
+                        passive: true,
+                    });
+                }
+            }
+            if (this.pauseOnBlur) {
+                window.addEventListener("focus", this.handleWindowFocus);
+                window.addEventListener("blur", this.handleWindowBlur);
+            }
+        }
+        if (this.pauseOnHidden &&
+            typeof document !== "undefined" &&
+            document.addEventListener) {
+            document.addEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+    }
+    detachActivityListeners() {
+        if (typeof window !== "undefined" && window.removeEventListener) {
+            for (const event of ACTIVITY_EVENTS) {
+                window.removeEventListener(event, this.handleActivity);
+            }
+            window.removeEventListener("focus", this.handleWindowFocus);
+            window.removeEventListener("blur", this.handleWindowBlur);
+        }
+        if (typeof document !== "undefined" && document.removeEventListener) {
+            document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+    }
+    startIdleTimer() {
+        if (!this.idleDetectionEnabled)
+            return;
+        this.clearIdleTimer();
+        this.lastActivityAt = Date.now();
+        this.state.idleTimerId = window.setTimeout(() => {
+            this.markIdle();
+        }, this.idleTimeoutMs);
+    }
+    clearIdleTimer() {
+        if (this.state.idleTimerId !== null) {
+            clearTimeout(this.state.idleTimerId);
+            this.state.idleTimerId = null;
+        }
+    }
+    markIdle() {
+        if (this.state.isIdle)
+            return;
+        this.state.isIdle = true;
+        this.syncActiveWindow();
+    }
+    onActivity() {
+        // Returning from idle must always restart the countdown immediately.
+        if (this.state.isIdle) {
+            this.state.isIdle = false;
+            this.syncActiveWindow();
+            this.startIdleTimer();
+            return;
+        }
+        // Otherwise throttle: no need to reset a minutes-long timer on every
+        // mousemove.
+        if (Date.now() - this.lastActivityAt < ACTIVITY_THROTTLE_MS)
+            return;
+        this.startIdleTimer();
+    }
+    onVisibilityChange() {
+        if (typeof document === "undefined")
+            return;
+        this.state.isVisible = !document.hidden;
+        if (this.state.isVisible) {
+            // Returning to the tab counts as being present again.
+            this.state.isIdle = false;
+            this.startIdleTimer();
+        }
+        this.syncActiveWindow();
+    }
+    onWindowFocus() {
+        this.state.isFocused = true;
+        this.state.isIdle = false;
+        this.startIdleTimer();
+        this.syncActiveWindow();
+    }
+    onWindowBlur() {
+        this.state.isFocused = false;
+        this.syncActiveWindow();
+    }
+    // --- Public API -------------------------------------------------------------
     pause() {
         this.sendTimeUpdate();
-        this.clearInterval();
+        this.clearTrackingInterval();
+        this.clearIdleTimer();
+        // Stop accounting until resumed.
+        this.state.accumulatedMs = 0;
+        this.state.activeSince = null;
     }
     resume() {
+        // Treat resume as a fresh, present start so a stale idle flag can't keep
+        // the tracker from counting.
+        this.state.isIdle = false;
         this.startTracking();
+        this.startIdleTimer();
     }
     destroy() {
         this.sendTimeUpdate();
-        this.clearInterval();
+        this.clearTrackingInterval();
+        this.clearIdleTimer();
+        this.detachActivityListeners();
         if (this.state.routeUnsubscribe) {
             this.state.routeUnsubscribe();
             this.state.routeUnsubscribe = null;
@@ -11989,6 +12160,10 @@ class TimeTracker {
     getTimeSpentSinceLastReset() {
         return this.getTimeSpent();
     }
+    /** Whether the user is currently considered active (present & interacting). */
+    getIsActive() {
+        return this.isActive();
+    }
 }
 
 function useTimeTracker(config) {