@iblai/web-utils 1.11.12 → 1.12.0

package/dist/auth/web-utils/src/features/tracking/time-tracker.d.ts

@@ -3,27 +3,78 @@ export interface TimeTrackerConfig {
     onTimeUpdate: (url: string, timeSpent: number) => void;
     getCurrentUrl: () => string;
     onRouteChange?: (callback: () => void) => () => void;
+    /**
+     * Seconds of no user interaction (mouse, keyboard, touch, scroll) after
+     * which the user is considered idle and time tracking pauses. Set to 0 to
+     * disable idle detection. Defaults to 120 (2 minutes).
+     */
+    idleTimeoutSeconds?: number;
+    /**
+     * Pause tracking while the page/tab is hidden (Page Visibility API).
+     * Defaults to true.
+     */
+    pauseOnHidden?: boolean;
+    /**
+     * Pause tracking while the window loses focus (e.g. user switched to another
+     * application or window). Defaults to true.
+     */
+    pauseOnBlur?: boolean;
 }
 export interface TimeTrackerState {
     currentUrl: string;
-    startTime: number;
     intervalId: number | null;
     routeUnsubscribe: (() => void) | null;
+    /** Active time (ms) banked since the last reset. */
+    accumulatedMs: number;
+    /** Timestamp the current active window started, or null while inactive. */
+    activeSince: number | null;
+    isVisible: boolean;
+    isFocused: boolean;
+    isIdle: boolean;
+    idleTimerId: number | null;
 }
 export declare class TimeTracker {
     private state;
     private config;
+    private readonly idleTimeoutMs;
+    private readonly pauseOnHidden;
+    private readonly pauseOnBlur;
+    private readonly idleDetectionEnabled;
+    private lastActivityAt;
+    private readonly handleActivity;
+    private readonly handleVisibilityChange;
+    private readonly handleWindowFocus;
+    private readonly handleWindowBlur;
     constructor(config: TimeTrackerConfig);
     private initialize;
-    private startTracking;
-    private clearInterval;
-    private resetTimer;
+    /** Whether time should currently be counted. */
+    private isActive;
+    /**
+     * 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.
+     */
+    private syncActiveWindow;
     private getTimeSpent;
+    private resetTimer;
+    private startTracking;
+    private clearTrackingInterval;
     private sendTimeUpdate;
     private handleRouteChange;
+    private attachActivityListeners;
+    private detachActivityListeners;
+    private startIdleTimer;
+    private clearIdleTimer;
+    private markIdle;
+    private onActivity;
+    private onVisibilityChange;
+    private onWindowFocus;
+    private onWindowBlur;
     pause(): void;
     resume(): void;
     destroy(): void;
     getCurrentUrl(): string;
     getTimeSpentSinceLastReset(): number;
+    /** Whether the user is currently considered active (present & interacting). */
+    getIsActive(): boolean;
 }

package/dist/index.d.ts

@@ -1101,7 +1101,7 @@ declare const isNode: () => string | false;
 declare const isExpo: () => any;
 declare const isTauri: () => boolean;
 declare function isSafariBrowser(): boolean;
-declare const getPlatform: () => "web" | "react-native" | "node" | "unknown";
+declare const getPlatform: () => "react-native" | "web" | "node" | "unknown";
 declare const safeRequire: (moduleName: string) => any;
 declare const getNextNavigation: () => any;
 
@@ -1294,29 +1294,80 @@ interface TimeTrackerConfig {
     onTimeUpdate: (url: string, timeSpent: number) => void;
     getCurrentUrl: () => string;
     onRouteChange?: (callback: () => void) => () => void;
+    /**
+     * Seconds of no user interaction (mouse, keyboard, touch, scroll) after
+     * which the user is considered idle and time tracking pauses. Set to 0 to
+     * disable idle detection. Defaults to 120 (2 minutes).
+     */
+    idleTimeoutSeconds?: number;
+    /**
+     * Pause tracking while the page/tab is hidden (Page Visibility API).
+     * Defaults to true.
+     */
+    pauseOnHidden?: boolean;
+    /**
+     * Pause tracking while the window loses focus (e.g. user switched to another
+     * application or window). Defaults to true.
+     */
+    pauseOnBlur?: boolean;
 }
 interface TimeTrackerState {
     currentUrl: string;
-    startTime: number;
     intervalId: number | null;
     routeUnsubscribe: (() => void) | null;
+    /** Active time (ms) banked since the last reset. */
+    accumulatedMs: number;
+    /** Timestamp the current active window started, or null while inactive. */
+    activeSince: number | null;
+    isVisible: boolean;
+    isFocused: boolean;
+    isIdle: boolean;
+    idleTimerId: number | null;
 }
 declare class TimeTracker {
     private state;
     private config;
+    private readonly idleTimeoutMs;
+    private readonly pauseOnHidden;
+    private readonly pauseOnBlur;
+    private readonly idleDetectionEnabled;
+    private lastActivityAt;
+    private readonly handleActivity;
+    private readonly handleVisibilityChange;
+    private readonly handleWindowFocus;
+    private readonly handleWindowBlur;
     constructor(config: TimeTrackerConfig);
     private initialize;
-    private startTracking;
-    private clearInterval;
-    private resetTimer;
+    /** Whether time should currently be counted. */
+    private isActive;
+    /**
+     * 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.
+     */
+    private syncActiveWindow;
     private getTimeSpent;
+    private resetTimer;
+    private startTracking;
+    private clearTrackingInterval;
     private sendTimeUpdate;
     private handleRouteChange;
+    private attachActivityListeners;
+    private detachActivityListeners;
+    private startIdleTimer;
+    private clearIdleTimer;
+    private markIdle;
+    private onActivity;
+    private onVisibilityChange;
+    private onWindowFocus;
+    private onWindowBlur;
     pause(): void;
     resume(): void;
     destroy(): void;
     getCurrentUrl(): string;
     getTimeSpentSinceLastReset(): number;
+    /** Whether the user is currently considered active (present & interacting). */
+    getIsActive(): boolean;
 }
 
 interface UseTimeTrackerConfig {

package/dist/index.esm.js

@@ -11894,46 +11894,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) {
@@ -11948,16 +12019,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;
@@ -11969,6 +12140,10 @@ class TimeTracker {
     getTimeSpentSinceLastReset() {
         return this.getTimeSpent();
     }
+    /** Whether the user is currently considered active (present & interacting). */
+    getIsActive() {
+        return this.isActive();
+    }
 }
 
 function useTimeTracker(config) {