@elliemae/pui-app-sdk 5.42.4 → 5.42.5

package/dist/esm/utils/session.js

@@ -5,34 +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_TIMEOUT_INTERVAL,
-  SESSION_RENEWAL_INTERVAL
-} from "./constants.js";
+import { SESSION_RENEWAL_INTERVAL } from "./constants.js";
 import { subscribeToPageWake } from "./page-wake.js";
+import {
+  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)
@@ -49,52 +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 removeActivityEventListeners = () => {
-  userInteractionEvents.forEach((eventType) => {
-    document.removeEventListener(eventType, renewSessionAtInterval);
-  });
-};
 const stopSessionMonitoring = () => {
   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) {
@@ -110,9 +131,11 @@ const initSessionMonitoring = () => {
   clearInterval(timerHandle);
   removeWakeListener?.();
   removeActivityEventListeners();
+  resetSessionTimeoutCache();
+  resetIdleStateFlags();
   addEventListeners();
-  removeWakeListener = subscribeToPageWake(monitorSessionEvents);
-  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,7 +1,9 @@
 import { useEffect, useState } from "react";
-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);
@@ -14,14 +16,8 @@ const formatTimeLeft = (msLeft) => {
 const useTrackSessionExpiry = (warningNotifiedAt) => {
   const [timeData, setTimeData] = useState();
   useEffect(() => {
-    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 warnInterval = getSessionWarnIntervalMs();
+    const sessionTimeout = getSessionExpiryIntervalMs();
     const sessionExpiresAt = warningNotifiedAt + (sessionTimeout - warnInterval);
     const updateTimeLeft = () => {
       setTimeData(formatTimeLeft(sessionExpiresAt - Date.now()));

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/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/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 {};