@elliemae/pui-app-sdk 5.42.3 → 5.42.5

package/dist/cjs/view/modals/session-expiry/customHooks.js

@@ -22,36 +22,32 @@ __export(customHooks_exports, {
 });
 module.exports = __toCommonJS(customHooks_exports);
 var import_react = require("react");
-var import_date_fns = require("date-fns");
-var import_constants = require("../../../utils/constants.js");
-var import_config = require("../../../utils/app-config/config.js");
+var import_page_wake = require("../../../utils/page-wake.js");
+var import_session_timeout_config = require("../../../utils/session-timeout-config.js");
+const formatTimeLeft = (msLeft) => {
+  const totalSeconds = Math.max(0, Math.floor(msLeft / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(
+    2,
+    "0"
+  )}`;
+};
 const useTrackSessionExpiry = (warningNotifiedAt) => {
   const [timeData, setTimeData] = (0, import_react.useState)();
   (0, import_react.useEffect)(() => {
-    const timeLeftForExpiryAfterWarning = () => {
-      const userWarnInterval = (0, import_config.getAppConfigValue)(
-        "sessionTimeoutWarnInterval"
-      );
-      const userTimeoutInterval = (0, import_config.getAppConfigValue)(
-        "sessionTimeoutInterval"
-      );
-      const warnInterval = userWarnInterval ? parseFloat(userWarnInterval) : import_constants.SESSION_TIMEOUT_INTERVAL.WARN;
-      const sessionTimeout = userTimeoutInterval ? parseFloat(userTimeoutInterval) : import_constants.SESSION_TIMEOUT_INTERVAL.EXPIRY;
-      const diffTime = sessionTimeout - warnInterval;
-      const sessionExpiresIn = warningNotifiedAt + diffTime;
-      const seconds = (0, import_date_fns.getSeconds)(sessionExpiresIn - Date.now());
-      const minutes = (0, import_date_fns.differenceInMinutes)(sessionExpiresIn, Date.now());
-      return {
-        seconds: `0${seconds}`.slice(-2),
-        minutes: `0${minutes}`.slice(-2)
-      };
+    const warnInterval = (0, import_session_timeout_config.getSessionWarnIntervalMs)();
+    const sessionTimeout = (0, import_session_timeout_config.getSessionExpiryIntervalMs)();
+    const sessionExpiresAt = warningNotifiedAt + (sessionTimeout - warnInterval);
+    const updateTimeLeft = () => {
+      setTimeData(formatTimeLeft(sessionExpiresAt - Date.now()));
     };
-    const interval = setInterval(() => {
-      const { seconds, minutes } = timeLeftForExpiryAfterWarning();
-      setTimeData(`${minutes}:${seconds}`);
-    }, 1e3);
+    updateTimeLeft();
+    const interval = setInterval(updateTimeLeft, 1e3);
+    const removeWakeListener = (0, import_page_wake.subscribeToPageWake)(updateTimeLeft);
     return () => {
       clearInterval(interval);
+      removeWakeListener();
     };
   }, [warningNotifiedAt]);
   return timeData;

package/dist/cjs/view/modals/session-expiry/index.js

@@ -44,7 +44,7 @@ const SessionExpiry = (0, import_react.memo)(
     }, [open]);
     const resetSession = async () => {
       setIsOpen(false);
-      await (0, import_session.renewSession)();
+      await (0, import_session.renewSession)(true);
       (0, import_session.addEventListeners)();
       dispatch(import_actions.logout.cancel());
     };

package/dist/esm/utils/page-wake.js

@@ -0,0 +1,27 @@
+const subscribeToPageWake = (callback) => {
+  let scheduled = false;
+  const runCoalesced = () => {
+    if (scheduled) return;
+    scheduled = true;
+    queueMicrotask(() => {
+      scheduled = false;
+      callback();
+    });
+  };
+  const onVisibilityChange = () => {
+    if (!document.hidden) {
+      runCoalesced();
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  window.addEventListener("pageshow", runCoalesced);
+  window.addEventListener("focus", runCoalesced);
+  return () => {
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    window.removeEventListener("pageshow", runCoalesced);
+    window.removeEventListener("focus", runCoalesced);
+  };
+};
+export {
+  subscribeToPageWake
+};

package/dist/esm/utils/session-timeout-config.js

@@ -0,0 +1,40 @@
+import { getAppConfigValue } from "./app-config/config.js";
+import { SESSION_TIMEOUT_INTERVAL } from "./constants.js";
+let cachedWarnIntervalMs;
+let cachedExpiryIntervalMs;
+const resetSessionTimeoutCache = () => {
+  cachedWarnIntervalMs = void 0;
+  cachedExpiryIntervalMs = void 0;
+};
+const getSessionTimeoutMs = (key, fallback) => {
+  const value = getAppConfigValue(key);
+  if (value == null || value === "") return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+const getSessionWarnIntervalMs = () => {
+  if (cachedWarnIntervalMs === void 0) {
+    cachedWarnIntervalMs = getSessionTimeoutMs(
+      "sessionTimeoutWarnInterval",
+      SESSION_TIMEOUT_INTERVAL.WARN
+    );
+  }
+  return cachedWarnIntervalMs;
+};
+const getSessionExpiryIntervalMs = () => {
+  if (cachedExpiryIntervalMs === void 0) {
+    const warn = getSessionWarnIntervalMs();
+    const expiry = getSessionTimeoutMs(
+      "sessionTimeoutInterval",
+      SESSION_TIMEOUT_INTERVAL.EXPIRY
+    );
+    cachedExpiryIntervalMs = expiry > warn ? expiry : warn + 1;
+  }
+  return cachedExpiryIntervalMs;
+};
+export {
+  getSessionExpiryIntervalMs,
+  getSessionTimeoutMs,
+  getSessionWarnIntervalMs,
+  resetSessionTimeoutCache
+};

package/dist/esm/utils/session.js

@@ -5,32 +5,50 @@ import { introspectToken } from "../api/auth/index.js";
 import { getLogger } from "./logger.js";
 import { logRecords } from "./log-records.js";
 import { endSession } from "./auth/index.js";
-import { getAppConfigValue } from "./app-config/config.js";
+import { SESSION_RENEWAL_INTERVAL } from "./constants.js";
+import { subscribeToPageWake } from "./page-wake.js";
 import {
-  SESSION_TIMEOUT_INTERVAL,
-  SESSION_RENEWAL_INTERVAL
-} from "./constants.js";
+  getSessionWarnIntervalMs,
+  getSessionExpiryIntervalMs,
+  resetSessionTimeoutCache
+} from "./session-timeout-config.js";
 let lastUserActivityTimeStamp = Date.now();
 const warnListeners = [];
 const expiryListeners = [];
 const resetListeners = [];
 const userInteractionEvents = ["click", "scroll", "keypress", "touchstart"];
 let sessionExpiryWarningNotified = false;
+let sessionExpired = false;
 let timerHandle;
+let removeWakeListener;
 let sessionExpiryWarningNotifiedAt;
-const resetUserIdleTime = (resetWarningModal = false) => {
+const resetIdleStateFlags = () => {
+  sessionExpired = false;
   sessionExpiryWarningNotified = false;
   sessionExpiryWarningNotifiedAt = null;
+};
+const isPastWarningTime = () => Date.now() - lastUserActivityTimeStamp > getSessionWarnIntervalMs();
+const isPastSessionTimeoutTime = () => Date.now() - lastUserActivityTimeStamp > getSessionExpiryIntervalMs();
+const notifySessionExpiry = () => Promise.resolve().then(() => {
+  expiryListeners.forEach((listener) => listener());
+});
+const markUserActive = (resetWarningModal = false) => {
+  resetIdleStateFlags();
   lastUserActivityTimeStamp = Date.now();
   Promise.resolve().then(() => {
     resetListeners.forEach((listener) => listener(resetWarningModal));
   }).catch(() => {
   });
 };
-const renewSession = async () => {
+const resetUserIdleTime = (resetWarningModal = false) => {
+  if (!enforceIdleThresholds(resetWarningModal === true)) return;
+  markUserActive(resetWarningModal);
+};
+const renewSession = async (explicit = false) => {
+  if (!enforceIdleThresholds(explicit === true)) return;
   const loginParams = getLoginParams();
   try {
-    resetUserIdleTime(true);
+    markUserActive(true);
     if (loginParams?.clientId) {
       const authToken = getAuthorizationHeader();
       if (!authToken)
@@ -47,47 +65,57 @@ const renewSession = async () => {
   }
 };
 const renewSessionAtInterval = throttle(
-  renewSession,
+  () => {
+    renewSession().catch(() => {
+    });
+  },
   SESSION_RENEWAL_INTERVAL,
   {
     leading: true
   }
 );
-const isPastWarningTime = (warnInterval = getAppConfigValue("sessionTimeoutWarnInterval") || SESSION_TIMEOUT_INTERVAL.WARN) => Date.now() - lastUserActivityTimeStamp > warnInterval;
-const isPastSessionTimeoutTime = (sessionTimeout = getAppConfigValue("sessionTimeoutInterval") || SESSION_TIMEOUT_INTERVAL.EXPIRY) => Date.now() - lastUserActivityTimeStamp > sessionTimeout;
+const removeActivityEventListeners = () => {
+  userInteractionEvents.forEach((eventType) => {
+    document.removeEventListener(eventType, renewSessionAtInterval);
+  });
+};
 const notifySessionExpiryWarning = () => {
   sessionExpiryWarningNotified = true;
   sessionExpiryWarningNotifiedAt = Date.now();
+  removeActivityEventListeners();
   Promise.resolve().then(() => {
     warnListeners.forEach(
       (listener) => listener(sessionExpiryWarningNotifiedAt)
     );
-    userInteractionEvents.forEach((eventType) => {
-      document.removeEventListener(eventType, renewSessionAtInterval);
-    });
   }).catch(() => {
   });
 };
-const notifySessionExpiry = () => Promise.resolve().then(() => {
-  expiryListeners.forEach((listener) => listener());
-});
 const stopSessionMonitoring = () => {
-  userInteractionEvents.forEach((eventType) => {
-    document.removeEventListener(eventType, renewSessionAtInterval);
-  });
+  removeActivityEventListeners();
+  removeWakeListener?.();
+  removeWakeListener = void 0;
   clearInterval(timerHandle);
+  resetIdleStateFlags();
   warnListeners.length = 0;
   expiryListeners.length = 0;
 };
-const monitorSessionEvents = () => {
+function enforceIdleThresholds(ignoreActiveWarning = false) {
+  if (sessionExpired) return false;
   if (isPastSessionTimeoutTime()) {
+    sessionExpired = true;
     notifySessionExpiry().then(() => {
       stopSessionMonitoring();
     }).catch(() => {
     });
-  } else if (!sessionExpiryWarningNotified && isPastWarningTime())
+    return false;
+  }
+  if (!sessionExpiryWarningNotified && isPastWarningTime()) {
     notifySessionExpiryWarning();
-};
+    return false;
+  }
+  if (sessionExpiryWarningNotified && !ignoreActiveWarning) return false;
+  return true;
+}
 const removeListeners = (arr, cb) => {
   const idx = arr.findIndex((r) => r === cb);
   if (idx > -1) {
@@ -100,8 +128,14 @@ const addEventListeners = () => {
   });
 };
 const initSessionMonitoring = () => {
+  clearInterval(timerHandle);
+  removeWakeListener?.();
+  removeActivityEventListeners();
+  resetSessionTimeoutCache();
+  resetIdleStateFlags();
   addEventListeners();
-  timerHandle = setInterval(monitorSessionEvents, 1e3);
+  removeWakeListener = subscribeToPageWake(enforceIdleThresholds);
+  timerHandle = setInterval(enforceIdleThresholds, 1e3);
 };
 const subscribeToSessionExpiryWarning = (onSessionExpiryWarn) => {
   warnListeners.push(onSessionExpiryWarn);

package/dist/esm/view/modals/session-expiry/customHooks.js

@@ -1,34 +1,33 @@
 import { useEffect, useState } from "react";
-import { getSeconds, differenceInMinutes } from "date-fns";
-import { SESSION_TIMEOUT_INTERVAL } from "../../../utils/constants.js";
-import { getAppConfigValue } from "../../../utils/app-config/config.js";
+import { subscribeToPageWake } from "../../../utils/page-wake.js";
+import {
+  getSessionWarnIntervalMs,
+  getSessionExpiryIntervalMs
+} from "../../../utils/session-timeout-config.js";
+const formatTimeLeft = (msLeft) => {
+  const totalSeconds = Math.max(0, Math.floor(msLeft / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(
+    2,
+    "0"
+  )}`;
+};
 const useTrackSessionExpiry = (warningNotifiedAt) => {
   const [timeData, setTimeData] = useState();
   useEffect(() => {
-    const timeLeftForExpiryAfterWarning = () => {
-      const userWarnInterval = getAppConfigValue(
-        "sessionTimeoutWarnInterval"
-      );
-      const userTimeoutInterval = getAppConfigValue(
-        "sessionTimeoutInterval"
-      );
-      const warnInterval = userWarnInterval ? parseFloat(userWarnInterval) : SESSION_TIMEOUT_INTERVAL.WARN;
-      const sessionTimeout = userTimeoutInterval ? parseFloat(userTimeoutInterval) : SESSION_TIMEOUT_INTERVAL.EXPIRY;
-      const diffTime = sessionTimeout - warnInterval;
-      const sessionExpiresIn = warningNotifiedAt + diffTime;
-      const seconds = getSeconds(sessionExpiresIn - Date.now());
-      const minutes = differenceInMinutes(sessionExpiresIn, Date.now());
-      return {
-        seconds: `0${seconds}`.slice(-2),
-        minutes: `0${minutes}`.slice(-2)
-      };
+    const warnInterval = getSessionWarnIntervalMs();
+    const sessionTimeout = getSessionExpiryIntervalMs();
+    const sessionExpiresAt = warningNotifiedAt + (sessionTimeout - warnInterval);
+    const updateTimeLeft = () => {
+      setTimeData(formatTimeLeft(sessionExpiresAt - Date.now()));
     };
-    const interval = setInterval(() => {
-      const { seconds, minutes } = timeLeftForExpiryAfterWarning();
-      setTimeData(`${minutes}:${seconds}`);
-    }, 1e3);
+    updateTimeLeft();
+    const interval = setInterval(updateTimeLeft, 1e3);
+    const removeWakeListener = subscribeToPageWake(updateTimeLeft);
     return () => {
       clearInterval(interval);
+      removeWakeListener();
     };
   }, [warningNotifiedAt]);
   return timeData;

package/dist/esm/view/modals/session-expiry/index.js

@@ -29,7 +29,7 @@ const SessionExpiry = memo(
     }, [open]);
     const resetSession = async () => {
       setIsOpen(false);
-      await renewSession();
+      await renewSession(true);
       addEventListeners();
       dispatch(logout.cancel());
     };

package/dist/types/lib/utils/page-wake.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Subscribes to browser wake/resume signals and coalesces bursts of events
+ * (visibilitychange + pageshow + focus) into a single callback per tick.
+ * @param callback
+ */
+export declare const subscribeToPageWake: (callback: () => void) => (() => void);

package/dist/types/lib/utils/session-timeout-config.d.ts

@@ -0,0 +1,6 @@
+type SessionTimeoutKey = 'sessionTimeoutWarnInterval' | 'sessionTimeoutInterval';
+export declare const resetSessionTimeoutCache: () => void;
+export declare const getSessionTimeoutMs: (key: SessionTimeoutKey, fallback: number) => number;
+export declare const getSessionWarnIntervalMs: () => number;
+export declare const getSessionExpiryIntervalMs: () => number;
+export {};

package/dist/types/lib/utils/session.d.ts

@@ -9,95 +9,62 @@ type LISTENER = {
     (): void;
 };
 /**
- * Resets the user idle time counter.
- * Call this when user performs an action to extend their session.
- * @param resetWarningModal - If true, also resets the warning modal state (default: false)
- * @example
- * ```typescript
- * // Reset idle time on user interaction
- * document.addEventListener('click', () => {
- *   resetUserIdleTime();
- * });
- *
- * // Reset and close warning modal
- * resetUserIdleTime(true);
- * ```
+ * Resets the user idle clock without calling the auth introspection API.
+ * Used by the HTTP request interceptor. Runs through `enforceIdleThresholds()`
+ * first, so it cannot dismiss the warning modal or extend after expiry.
+ * @param {boolean} [resetWarningModal=false] - When true, notifies reset
+ *   listeners so the warning modal can close. Only for explicit user actions.
  */
 export declare const resetUserIdleTime: ResetUserIdleTimeFn;
 /**
- * Extends the PSS session (Encompass session) by introspecting the token.
- * Also resets the UI idle time counter.
- * @throws Error if authorization token is not found
- * @example
- * ```typescript
- * // Manually renew session
- * await renewSession();
- * ```
+ * Extends the PSS (Encompass) session via token introspection and resets idle.
+ * @param {boolean} [explicit=false] - Pass true for deliberate user actions
+ *   (session expiry modal Reset). False blocks renewal while warning is open.
+ *   Throttled handlers and `host.renewSessionTimer()` always use the default.
  * @internal
  */
-export declare const renewSession: () => Promise<void>;
+export declare const renewSession: (explicit?: boolean) => Promise<void>;
+/**
+ * Stops idle monitoring, removes listeners, and clears subscriber lists.
+ * Called automatically after session expiry.
+ */
 export declare const stopSessionMonitoring: () => void;
+/**
+ * Re-attaches host document activity listeners after the warning modal closes.
+ * Called by the session expiry modal after a successful explicit reset.
+ */
 export declare const addEventListeners: () => void;
-export declare const initSessionMonitoring: () => void;
 /**
- * Subscribes to session expiry warning events.
- * The callback is invoked when the session is about to expire (based on warning interval).
- * @param onSessionExpiryWarn - Callback function that receives the warning timestamp
- * @returns Unsubscribe function to remove the listener
- * @example
- * ```typescript
- * const unsubscribe = subscribeToSessionExpiryWarning((warningTime) => {
- *   console.log('Session expiring at:', warningTime);
- *   showWarningModal();
- * });
+ * Starts session idle monitoring on the host document.
  *
- * // Later, to unsubscribe
- * unsubscribe();
- * ```
+ * Safe to call more than once; clears previous listeners and timers first.
+ * Typically wired up once via the `SessionTimeout` component.
+ */
+export declare const initSessionMonitoring: () => void;
+/**
+ * Registers a callback when idle time crosses the warn threshold.
+ * @param {WARNLISTENER} onSessionExpiryWarn - Timestamp the warning was shown.
+ * @returns {Function} Unsubscribe function.
  */
 export declare const subscribeToSessionExpiryWarning: (onSessionExpiryWarn: WARNLISTENER) => () => void;
 /**
- * Subscribes to session expiry events.
- * The callback is invoked when the session has expired.
- * @param onSessionExpiry - Callback function invoked on session expiry
- * @returns Unsubscribe function to remove the listener
- * @example
- * ```typescript
- * const unsubscribe = subscribeToSessionExpiry(() => {
- *   console.log('Session expired');
- *   window.location.href = '/login';
- * });
- * ```
+ * Registers a callback when idle time crosses the expiry threshold.
+ * @param {LISTENER} onSessionExpiry - Invoked once when the session should end.
+ * @returns {Function} Unsubscribe function.
  */
 export declare const subscribeToSessionExpiry: (onSessionExpiry: LISTENER) => () => void;
 /**
- * Subscribes to session reset events.
- * The callback is invoked when the session idle time is reset.
- * @param onResetListener - Callback function that receives reset modal flag
- * @returns Unsubscribe function to remove the listener
- * @example
- * ```typescript
- * subscribeToResetSession((shouldResetModal) => {
- *   if (shouldResetModal) {
- *     closeWarningModal();
- *   }
- * });
- * ```
+ * Registers a callback when the idle clock is reset.
+ * @param {RESETLISTENER} onResetListener - Receives the resetWarningModal flag.
+ * @returns {Function} Unsubscribe function.
  */
 export declare const subscribeToResetSession: (onResetListener: RESETLISTENER) => () => void;
 /**
- * Starts tracking user activity for session management.
- * Monitors user interactions on the specified element and invokes callback.
- * @param element - DOM element to track activity on (typically document)
- * @param cb - Callback function to invoke on user activity
- * @returns Cleanup function to stop tracking
- * @example
- * ```typescript
- * const cleanup = trackActivity(document, renewSession);
- *
- * // Later, stop tracking
- * cleanup();
- * ```
+ * Tracks user interaction on a document and invokes a callback (iframe guests).
+ * Does not run `enforceIdleThresholds`; callback should use a guarded renewal path.
+ * @param {Document | null} element - Host or iframe document to listen on.
+ * @param {Function} cb - Invoked at most once per minute on activity.
+ * @returns {Function} Cleanup function that removes listeners.
  */
 export declare const trackActivity: (element: Document | null, cb: (...args: unknown[]) => unknown) => () => void;
 export {};

package/dist/types/lib/utils/tests/page-wake.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/tests/session-idle-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/tests/session-timeout-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/tests/session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/view/modals/session-expiry/tests/customHooks.test.d.ts

@@ -0,0 +1 @@
+export {};