@microsoft/omnichannel-chat-widget 1.8.4-main.cbab5fc → 1.8.4-main.cd79f08

package/lib/cjs/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/LazyLoadActivity.js

@@ -60,8 +60,10 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     // Temporary disable flag
     // The intersection observer instance
 
-    // Scroll operation state
-    // Current scroll operation tracking
+    // Scroll anchoring state (height-delta approach)
+    // scrollHeight before content loads
+    // scrollTop before content loads
+    // Tracks if the first batch has loaded
     // Prevents concurrent scroll operations (public for event handlers)
 
     // Timeout and queue management
@@ -105,6 +107,7 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     key: "directReset",
     value: function directReset() {
       LazyLoadHandler.resetPending = true;
+      LazyLoadHandler.initialLoadComplete = false; // New session — next batch is an initial load
       LazyLoadHandler.setHasMoreHistoryAvailable(true);
       LazyLoadHandler.unmount();
     }
@@ -408,16 +411,15 @@ let LazyLoadHandler = /*#__PURE__*/function () {
 
     /**
      * Main lazy load trigger handler
-     * 
+     *
      * This is the core method that executes when the trigger element becomes visible.
      * It coordinates the entire lazy loading process:
-     * 
+     *
      * 1. Sets flags to prevent concurrent operations
-     * 2. Dispatches event to fetch more chat history
-     * 3. Waits for content to load
-     * 4. Executes scroll adjustment to maintain user position
-     * 
-     * Timing: Uses 300ms delay to allow content loading before scroll adjustment
+     * 2. Captures scroll state BEFORE content loads (for height-delta anchoring)
+     * 3. Dispatches event to fetch more chat history
+     *
+     * Scroll anchoring is triggered by HISTORY_BATCH_LOADED event (not a blind timeout).
      */
   }, {
     key: "handleLazyLoadTrigger",
@@ -431,138 +433,60 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.pendingScrollAction = true; // Block new scroll actions
       LazyLoadHandler.paused = true; // Pause intersection observer
 
+      // Capture scroll geometry BEFORE new content loads — used for height-delta anchoring
+      const {
+        container,
+        isScrollable
+      } = LazyLoadHandler.findScrollContainer();
+      if (container && isScrollable) {
+        LazyLoadHandler.preLoadScrollHeight = container.scrollHeight;
+        LazyLoadHandler.preLoadScrollTop = container.scrollTop;
+      }
+      LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadTriggerFired, "Lazy load trigger fired — fetching history");
+
       // Dispatch custom event to trigger chat history fetching
-      // This event is handled by other parts of the chat system
       (0, _dispatchCustomEvent.default)(_ChatWidgetEvents.default.FETCH_PERSISTENT_CHAT_HISTORY);
-
-      // Wait for content to load before performing scroll adjustment
-      // 200ms provides good balance between responsiveness and content loading
-      const timeoutId = window.setTimeout(() => {
-        LazyLoadHandler.retryTimeouts.delete(timeoutId);
-        LazyLoadHandler.executeReliableScroll();
-      }, 200); // Reduced from 300ms to 200ms for faster response
-      LazyLoadHandler.retryTimeouts.add(timeoutId);
     }
 
     /**
-     * Executes reliable scroll with validation and retry logic
-     * 
-     * This method implements a robust scroll system that:
-     * 1. Finds and validates the scroll container
-     * 2. Calculates target scroll position (current + 35px)
-     * 3. Sets up scroll state for tracking and retries
-     * 4. Initiates the scroll attempt process
-     * 
-     * If no suitable container is found, schedules a retry.
+     * Applies height-delta scroll anchoring after new history content is prepended.
+     *
+     * When content is added above the viewport, the browser keeps scrollTop constant
+     * but the content shifts down — making the viewport drift upward.
+     * Fix: scrollTop = savedScrollTop + (newScrollHeight - savedScrollHeight)
+     * This keeps the user looking at the same content they had before.
      */
   }, {
-    key: "executeReliableScroll",
-    value: function executeReliableScroll() {
-      // Guard: Don't execute scroll if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-        LazyLoadHandler.finishScrollAction();
-        return;
-      }
-
-      // Find container using multiple fallback strategies
+    key: "applyScrollAnchor",
+    value: function applyScrollAnchor() {
       const {
         container,
         isScrollable
       } = LazyLoadHandler.findScrollContainer();
       if (!container || !isScrollable) {
-        LazyLoadHandler.scheduleScrollRetry();
-        return;
-      }
-
-      // Calculate scroll positions
-      const initialScrollTop = container.scrollTop;
-      const targetScrollTop = initialScrollTop + 35; // 35px down to maintain position
-
-      // Set up scroll state for tracking and retries
-      LazyLoadHandler.scrollState = {
-        container,
-        initialScrollTop,
-        targetScrollTop,
-        attemptCount: 0,
-        maxAttempts: 5 // Allow up to 5 retry attempts
-      };
-
-      // Begin the scroll attempt process
-      LazyLoadHandler.attemptScroll();
-    }
-
-    /**
-     * Attempts to perform scroll with verification and retry logic
-     * 
-     * This method implements a sophisticated scroll system:
-     * 
-     * 1. Uses requestAnimationFrame for smooth execution
-     * 2. Performs the scroll operation
-     * 3. Verifies scroll actually occurred (5px tolerance)
-     * 4. Retries with exponential backoff if failed
-     * 5. Continues operation after max attempts
-     * 
-     * The two-frame approach ensures scroll is applied and then verified
-     * after the browser has had time to process the scroll change.
-     */
-  }, {
-    key: "attemptScroll",
-    value: function attemptScroll() {
-      // Guard: Don't attempt scroll if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
         LazyLoadHandler.finishScrollAction();
         return;
       }
-      if (!LazyLoadHandler.scrollState) {
-        LazyLoadHandler.finishScrollAction();
-        return;
+      const newScrollHeight = container.scrollHeight;
+      const heightDelta = newScrollHeight - LazyLoadHandler.preLoadScrollHeight;
+      if (heightDelta > 0) {
+        container.scrollTop = LazyLoadHandler.preLoadScrollTop + heightDelta;
       }
-
-      // Extract current scroll state
-      const {
-        container,
-        targetScrollTop,
-        attemptCount,
-        maxAttempts
-      } = LazyLoadHandler.scrollState;
-      LazyLoadHandler.scrollState.attemptCount++;
-
-      // Perform scroll using requestAnimationFrame for smooth execution
-      // Frame 1: Apply the scroll
-      requestAnimationFrame(() => {
-        // Double-check history availability before applying scroll
-        if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-          LazyLoadHandler.finishScrollAction();
-          return;
-        }
-        if (container) {
-          container.scrollTop = targetScrollTop;
-        }
-
-        // Frame 2: Verify scroll occurred after browser has processed the change
-        requestAnimationFrame(() => {
-          // Triple-check history availability before verification
-          if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-            LazyLoadHandler.finishScrollAction();
-            return;
-          }
-          const actualScrollTop = container ? container.scrollTop : 0;
-          const scrollSucceeded = Math.abs(actualScrollTop - targetScrollTop) < 5; // 5px tolerance for success
-
-          if (scrollSucceeded) {
-            LazyLoadHandler.finishScrollAction();
-          } else if (attemptCount < maxAttempts) {
-            // Retry with exponential backoff (100ms * attempt number)
-            const timeoutId = window.setTimeout(() => {
-              LazyLoadHandler.retryTimeouts.delete(timeoutId);
-              LazyLoadHandler.attemptScroll();
-            }, 100 * attemptCount); // Exponential backoff
-            LazyLoadHandler.retryTimeouts.add(timeoutId);
-          } else {
-            LazyLoadHandler.finishScrollAction();
+      try {
+        _TelemetryHelper.TelemetryHelper.logActionEvent(_TelemetryConstants.LogLevel.INFO, {
+          Event: _TelemetryConstants.TelemetryEvent.LCWLazyLoadScrollAnchorApplied,
+          Description: "Scroll anchor applied after history batch",
+          CustomProperties: {
+            heightDelta,
+            preLoadScrollHeight: LazyLoadHandler.preLoadScrollHeight,
+            newScrollHeight,
+            newScrollTop: container.scrollTop
           }
         });
-      });
+      } catch {
+        // Silent fail — don't break scroll anchoring for telemetry issues
+      }
+      LazyLoadHandler.finishScrollAction();
     }
 
     /**
@@ -576,7 +500,6 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     key: "finishScrollAction",
     value: function finishScrollAction() {
       // Clean up scroll tracking state
-      LazyLoadHandler.scrollState = null;
       LazyLoadHandler.pendingScrollAction = false;
 
       // Schedule unpause and reset with delay for content stabilization
@@ -588,33 +511,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.retryTimeouts.add(timeoutId);
     }
 
-    /**
-     * Schedules retry for failed scroll operations
-     * 
-     * Used when scroll container is not available or scrollable.
-     * Provides a longer delay to allow container to become ready.
-     */
-  }, {
-    key: "scheduleScrollRetry",
-    value: function scheduleScrollRetry() {
-      // Don't schedule retry if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-        LazyLoadHandler.finishScrollAction();
-        return;
-      }
-      const timeoutId = window.setTimeout(() => {
-        LazyLoadHandler.retryTimeouts.delete(timeoutId);
-        // Only retry if we're still in a pending scroll action state and have more history
-        if (LazyLoadHandler.pendingScrollAction && LazyLoadHandler.hasMoreHistoryAvailable) {
-          LazyLoadHandler.executeReliableScroll();
-        }
-      }, 1000); // 1 second delay for container readiness
-      LazyLoadHandler.retryTimeouts.add(timeoutId);
-    }
-
     /**
      * Schedules observer reset for next lazy load cycle
-     * 
+     *
      * After a lazy load operation completes, the observer needs to be reset
      * to detect the next time the user scrolls to the top.
      */
@@ -732,7 +631,7 @@ let LazyLoadHandler = /*#__PURE__*/function () {
   }, {
     key: "moveScrollDown",
     value: function moveScrollDown() {
-      LazyLoadHandler.executeReliableScroll();
+      LazyLoadHandler.applyScrollAnchor();
     }
 
     /**
@@ -772,6 +671,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
   }, {
     key: "handleNoMoreHistoryAvailable",
     value: function handleNoMoreHistoryAvailable() {
+      if (!LazyLoadHandler.initialLoadComplete) {
+        LazyLoadHandler.initialLoadComplete = true;
+      }
       LazyLoadHandler.setHasMoreHistoryAvailable(false);
       LazyLoadHandler.paused = true;
       LazyLoadHandler.pendingScrollAction = false; // Reset this to prevent stuck states
@@ -789,9 +691,6 @@ let LazyLoadHandler = /*#__PURE__*/function () {
         LazyLoadHandler.observer.disconnect();
         LazyLoadHandler.observer = null;
       }
-
-      // Clear scroll state
-      LazyLoadHandler.scrollState = null;
     }
 
     /**
@@ -813,6 +712,8 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.setHasMoreHistoryAvailable(true); // Reset history availability flag
       LazyLoadHandler.initializationQueue = []; // Clear action queue
       LazyLoadHandler.resetPending = false; // Clear pending reset flag
+      // Note: initialLoadComplete is NOT reset here — it persists across observer cycles.
+      // It's only reset on new chat sessions (directReset / PersistentConversationReset).
 
       // Reinitialize with faster timing for better responsiveness
       const timeoutId = window.setTimeout(() => {
@@ -852,8 +753,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.initialized = false;
       LazyLoadHandler.paused = false;
       LazyLoadHandler.pendingScrollAction = false;
-      LazyLoadHandler.scrollState = null;
       LazyLoadHandler.isReady = false;
+      LazyLoadHandler.preLoadScrollHeight = 0;
+      LazyLoadHandler.preLoadScrollTop = 0;
       LazyLoadHandler.initializationQueue = [];
       // Note: Don't reset resetPending here as it needs to persist across unmount/mount cycles
     }
@@ -903,7 +805,9 @@ _defineProperty(LazyLoadHandler, "targetId", "lazy-load-trigger-element");
 _defineProperty(LazyLoadHandler, "initialized", false);
 _defineProperty(LazyLoadHandler, "paused", false);
 _defineProperty(LazyLoadHandler, "observer", null);
-_defineProperty(LazyLoadHandler, "scrollState", null);
+_defineProperty(LazyLoadHandler, "preLoadScrollHeight", 0);
+_defineProperty(LazyLoadHandler, "preLoadScrollTop", 0);
+_defineProperty(LazyLoadHandler, "initialLoadComplete", false);
 _defineProperty(LazyLoadHandler, "pendingScrollAction", false);
 _defineProperty(LazyLoadHandler, "retryTimeouts", new Set());
 _defineProperty(LazyLoadHandler, "resetPending", false);
@@ -911,6 +815,7 @@ _defineProperty(LazyLoadHandler, "initTimer", (0, _utils.createTimer)());
 _defineProperty(LazyLoadHandler, "resetEventListener", _omnichannelChatComponents.BroadcastService.getMessageByEventName(_TelemetryConstants.BroadcastEvent.PersistentConversationReset).subscribe(() => {
   LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadReset, "LazyLoad reset triggered");
   LazyLoadHandler.resetPending = true;
+  LazyLoadHandler.initialLoadComplete = false; // New session — next batch is an initial load
   LazyLoadHandler.setHasMoreHistoryAvailable(true); // Reset this immediately so activityMiddleware doesn't block rendering
   LazyLoadHandler.unmount(); // Clean up current state immediately
 }));
@@ -934,19 +839,11 @@ const LazyLoadActivity = props => {
       setHasMoreHistory(false);
     };
 
-    // Event listener for HISTORY_LOAD_ERROR - hides banner temporarily without disabling future loads
+    // Event listener for HISTORY_LOAD_ERROR — dismiss banner on any error
     const handleHistoryLoadError = () => {
-      // Temporarily hide the banner by pausing, but keep hasMoreHistory true to allow retry
-      LazyLoadHandler.paused = true;
-      LazyLoadHandler.pendingScrollAction = false;
-
-      // Re-enable after a delay to allow retry on next scroll
-      // Note: This timeout is intentionally not tracked as it's scoped to the component lifecycle
-      window.setTimeout(() => {
-        LazyLoadHandler.paused = false;
-      }, 2000); // 2 second delay before allowing retry
-
-      LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadHistoryError, "History load error - will retry on next scroll");
+      LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadHistoryError, `History load error - dismissing banner. initialLoadComplete: ${LazyLoadHandler.initialLoadComplete}`);
+      LazyLoadHandler.handleNoMoreHistoryAvailable();
+      setHasMoreHistory(false);
     };
 
     // Event listener for PersistentConversationReset to sync React state
@@ -957,6 +854,97 @@ const LazyLoadActivity = props => {
       setHasMoreHistory(true);
     };
 
+    // Event listener for HISTORY_BATCH_LOADED — applies scroll anchoring after batch is processed
+    const handleBatchLoaded = () => {
+      LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadBatchReceived, `Batch received — initialLoadComplete: ${LazyLoadHandler.initialLoadComplete}`);
+      if (!LazyLoadHandler.initialLoadComplete) {
+        // Initial load: use the same height-delta scroll anchoring as subsequent loads.
+        // This keeps the user at their current position while history is prepended above.
+        LazyLoadHandler.initialLoadComplete = true;
+        LazyLoadHandler.pendingScrollAction = false;
+        try {
+          const {
+            container
+          } = LazyLoadHandler.findScrollContainer();
+          if (container) {
+            const savedScrollTop = container.scrollTop;
+            const savedScrollHeight = container.scrollHeight;
+
+            // Freeze viewport while React renders new content above
+            container.style.overflow = "hidden";
+            let framesRemaining = 6;
+            const anchorScroll = () => {
+              const newScrollHeight = container.scrollHeight;
+              const heightDelta = newScrollHeight - savedScrollHeight;
+              if (heightDelta > 0) {
+                container.scrollTop = savedScrollTop + heightDelta;
+              }
+              framesRemaining--;
+              if (framesRemaining > 0) {
+                requestAnimationFrame(anchorScroll);
+              } else {
+                container.style.overflow = "";
+                LazyLoadHandler.paused = false;
+                LazyLoadHandler.scheduleReset();
+              }
+            };
+            requestAnimationFrame(anchorScroll);
+          } else {
+            LazyLoadHandler.paused = false;
+            LazyLoadHandler.scheduleReset();
+          }
+        } catch {
+          LazyLoadHandler.paused = false;
+          LazyLoadHandler.scheduleReset();
+        }
+        LazyLoadHandler.logLifecycleEvent(_TelemetryConstants.TelemetryEvent.LCWLazyLoadInitialLoadComplete, "Initial history load complete — scroll anchored to current position");
+        return;
+      }
+      // Pagination: apply height-delta scroll anchoring repeatedly across frames.
+      //
+      // react-scroll-to-bottom uses useEffect + rAF to auto-scroll to bottom when new content
+      // arrives. This fires at unpredictable timing relative to our callbacks, so a single
+      // scrollTop assignment gets overridden intermittently.
+      //
+      // Fix: re-apply the correct scrollTop across several animation frames. After a few frames,
+      // react-scroll-to-bottom detects the user is NOT at the bottom (sticky=false) and stops
+      // auto-scrolling. We also temporarily freeze overflow to prevent visible flicker.
+      try {
+        const {
+          container
+        } = LazyLoadHandler.findScrollContainer();
+        if (container) {
+          // Re-capture scrollTop — user may have scrolled during the API fetch
+          const savedScrollTop = container.scrollTop;
+          const savedScrollHeight = LazyLoadHandler.preLoadScrollHeight;
+
+          // Freeze viewport to prevent visible flicker between competing scroll positions
+          container.style.overflow = "hidden";
+          let framesRemaining = 6; // ~100ms at 60fps — enough for react-scroll-to-bottom to settle
+          const anchorScroll = () => {
+            const newScrollHeight = container.scrollHeight;
+            const heightDelta = newScrollHeight - savedScrollHeight;
+            if (heightDelta > 0) {
+              container.scrollTop = savedScrollTop + heightDelta;
+            }
+            framesRemaining--;
+            if (framesRemaining > 0) {
+              requestAnimationFrame(anchorScroll);
+            } else {
+              // All frames applied — restore overflow and finish
+              container.style.overflow = "";
+              LazyLoadHandler.finishScrollAction();
+            }
+          };
+          requestAnimationFrame(anchorScroll);
+        } else {
+          LazyLoadHandler.finishScrollAction();
+        }
+      } catch {
+        LazyLoadHandler.finishScrollAction();
+      }
+    };
+
     // Add secure event listener for no more history signal
     const eventBus = _SecureEventBus.default.getInstance();
     const unsubscribeNoMoreHistory = eventBus.subscribe(_ChatWidgetEvents.default.NO_MORE_HISTORY_AVAILABLE, handleNoMoreHistory);
@@ -964,6 +952,9 @@ const LazyLoadActivity = props => {
     // Add event listener for history load errors
     const unsubscribeHistoryError = eventBus.subscribe(_ChatWidgetEvents.default.HISTORY_LOAD_ERROR, handleHistoryLoadError);
 
+    // Add event listener for history batch loaded
+    const unsubscribeBatchLoaded = eventBus.subscribe(_ChatWidgetEvents.default.HISTORY_BATCH_LOADED, handleBatchLoaded);
+
     // Add event listener for persistent conversation reset
     const resetSubscription = _omnichannelChatComponents.BroadcastService.getMessageByEventName(_TelemetryConstants.BroadcastEvent.PersistentConversationReset).subscribe(handlePersistentConversationReset);
 
@@ -981,6 +972,7 @@ const LazyLoadActivity = props => {
       return () => {
         unsubscribeNoMoreHistory();
         unsubscribeHistoryError();
+        unsubscribeBatchLoaded();
         resetSubscription.unsubscribe();
       };
     }
@@ -1034,6 +1026,7 @@ const LazyLoadActivity = props => {
       // Remove event listeners
       unsubscribeNoMoreHistory();
       unsubscribeHistoryError();
+      unsubscribeBatchLoaded();
       resetSubscription.unsubscribe();
       if (container) {
         container.removeEventListener("scroll", handleScroll);

package/lib/cjs/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activityMiddleware.js

@@ -133,7 +133,7 @@ const createActivityMiddleware = (renderMarkdown, systemMessageStyleProps, userM
     if (isTagIncluded(card, _Constants.Constants.conversationDividerTag)) {
       const conversationDividerLabel = (localizedTexts === null || localizedTexts === void 0 ? void 0 : localizedTexts.CONVERSATION_DIVIDER_ARIA_LABEL) || _defaultMiddlewareLocalizedTexts.defaultMiddlewareLocalizedTexts.CONVERSATION_DIVIDER_ARIA_LABEL;
       // Pass the computed localized text to the divider component
-      return /*#__PURE__*/_react.default.createElement(_ConversationDividerActivity.default, {
+      return () => /*#__PURE__*/_react.default.createElement(_ConversationDividerActivity.default, {
         dividerActivityAriaLabel: conversationDividerLabel
       });
     }

package/lib/cjs/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/timestamps/NotDeliveredTimestamp.js

@@ -17,6 +17,8 @@ var _useChatContextStore = _interopRequireDefault(require("../../../../../../hoo
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const NotDeliveredTimestamp = _ref => {
   var _state$domainStates$r, _state$domainStates$r2, _state$domainStates$r3, _state$domainStates$r4, _state$domainStates$m, _state$domainStates$m2;

package/lib/cjs/contexts/common/LiveChatWidgetActionType.js

@@ -57,4 +57,5 @@ exports.LiveChatWidgetActionType = LiveChatWidgetActionType;
   LiveChatWidgetActionType[LiveChatWidgetActionType["SET_CONVERSATIONAL_SURVEY_DISPLAY"] = 47] = "SET_CONVERSATIONAL_SURVEY_DISPLAY";
   LiveChatWidgetActionType[LiveChatWidgetActionType["GET_IN_MEMORY_STATE"] = 48] = "GET_IN_MEMORY_STATE";
   LiveChatWidgetActionType[LiveChatWidgetActionType["SET_BOT_AVATAR_INITIALS"] = 49] = "SET_BOT_AVATAR_INITIALS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_USER_AUTHENTICATED"] = 50] = "SET_USER_AUTHENTICATED";
 })(LiveChatWidgetActionType || (exports.LiveChatWidgetActionType = LiveChatWidgetActionType = {}));

package/lib/cjs/contexts/common/LiveChatWidgetContextInitialState.js

@@ -44,6 +44,10 @@ const getLiveChatWidgetContextInitialState = props => {
     if (!initialStateFromCache.domainStates.botAvatarInitials) {
       initialStateFromCache.domainStates.botAvatarInitials = _defaultWebChatStyles.defaultWebChatStyles.botAvatarInitials;
     }
+    // Default isUserAuthenticated to false if not present in cache
+    if (initialStateFromCache.appStates.isUserAuthenticated === undefined) {
+      initialStateFromCache.appStates.isUserAuthenticated = false;
+    }
     return initialStateFromCache;
   }
   const LiveChatWidgetContextInitialState = {
@@ -93,7 +97,8 @@ const getLiveChatWidgetContextInitialState = props => {
       selectedSurveyMode: null,
       postChatParticipantType: undefined,
       isConversationalSurvey: false,
-      isConversationalSurveyEnabled: false
+      isConversationalSurveyEnabled: false,
+      isUserAuthenticated: false
     },
     uiStates: {
       showConfirmationPane: false,

package/lib/cjs/contexts/createReducer.js

@@ -716,6 +716,21 @@ const reducer = (state, action) => {
           isConversationalSurvey: action.payload
         }
       };
+    case _LiveChatWidgetActionType.LiveChatWidgetActionType.SET_USER_AUTHENTICATED:
+      inMemory = {
+        ...inMemory,
+        appStates: {
+          ...inMemory.appStates,
+          isUserAuthenticated: action.payload
+        }
+      };
+      return {
+        ...state,
+        appStates: {
+          ...state.appStates,
+          isUserAuthenticated: action.payload
+        }
+      };
     case _LiveChatWidgetActionType.LiveChatWidgetActionType.GET_IN_MEMORY_STATE:
       return inMemory;
     default:

package/lib/cjs/controller/componentController.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.shouldShowWebChatContainer = exports.shouldShowStartChatErrorPane = exports.shouldShowReconnectChatPane = exports.shouldShowProactiveChatPane = exports.shouldShowPreChatSurveyPane = exports.shouldShowPostChatSurveyPane = exports.shouldShowPostChatLoadingPane = exports.shouldShowOutOfOfficeHoursPane = exports.shouldShowLoadingPane = exports.shouldShowHeader = exports.shouldShowFooter = exports.shouldShowEmailTranscriptPane = exports.shouldShowConfirmationPane = exports.shouldShowChatButton = exports.shouldShowCallingContainer = void 0;
 var _ConversationState = require("../contexts/common/ConversationState");
+var _liveChatConfigUtils = require("../components/livechatwidget/common/liveChatConfigUtils");
 const shouldShowChatButton = state => {
   var _state$appStates;
   return (state.appStates.isMinimized || state.appStates.conversationState === _ConversationState.ConversationState.Closed) && (state === null || state === void 0 ? void 0 : (_state$appStates = state.appStates) === null || _state$appStates === void 0 ? void 0 : _state$appStates.hideStartChatButton) === false; // Do not show chat button in case of popout
@@ -27,7 +28,18 @@ const shouldShowEmailTranscriptPane = state => {
 };
 exports.shouldShowEmailTranscriptPane = shouldShowEmailTranscriptPane;
 const shouldShowWebChatContainer = state => {
-  return !state.appStates.isMinimized && state.appStates.conversationState === _ConversationState.ConversationState.Active || state.appStates.conversationState === _ConversationState.ConversationState.InActive || state.appStates.conversationState === _ConversationState.ConversationState.Postchat && state.appStates.isConversationalSurveyEnabled && state.appStates.isConversationalSurvey;
+  var _state$domainStates;
+  const extendedChatConfig = state === null || state === void 0 ? void 0 : (_state$domainStates = state.domainStates) === null || _state$domainStates === void 0 ? void 0 : _state$domainStates.liveChatConfig;
+  const persistentHistoryEnabled = (0, _liveChatConfigUtils.shouldLoadPersistentChatHistory)(extendedChatConfig);
+  const isActiveOrInactive = state.appStates.conversationState === _ConversationState.ConversationState.Active || state.appStates.conversationState === _ConversationState.ConversationState.InActive;
+  const isPostchatSurvey = state.appStates.conversationState === _ConversationState.ConversationState.Postchat && state.appStates.isConversationalSurveyEnabled && state.appStates.isConversationalSurvey;
+  if (persistentHistoryEnabled) {
+    // Keep WebChat in DOM even when minimized (CSS hides it via visibility)
+    // This preserves scroll position across minimize/maximize cycles
+    return isActiveOrInactive || isPostchatSurvey;
+  }
+  // Original behavior - hide WebChat when minimized
+  return !state.appStates.isMinimized && (isActiveOrInactive || isPostchatSurvey);
 };
 exports.shouldShowWebChatContainer = shouldShowWebChatContainer;
 const shouldShowLoadingPane = state => {

package/lib/cjs/plugins/newMessageEventHandler.js

@@ -20,6 +20,8 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
   // this is a workaround for the fact that we dont have a way to identify if a message is history or new, and it will provide consistency across different scenarios
 
   let isHistoryMessageReceivedEventRaised = false;
+  let isInQueue = false;
+  let agentJoinLogged = false;
   const onNewAdapterActivityHandler = activity => {
     raiseMessageEvent(activity);
   };
@@ -41,9 +43,14 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
     });
   };
   const systemMessageStrategy = activity => {
-    var _TelemetryManager$Int3;
+    var _activity$channelData, _activity$channelData2, _TelemetryManager$Int3;
     const payload = (0, _util.buildMessagePayload)(activity, userId);
     payload.messageType = _Constants2.Constants.systemMessageTag;
+
+    // Track queue entry for agent-join detection
+    if (activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && (_activity$channelData2 = _activity$channelData.tags) !== null && _activity$channelData2 !== void 0 && _activity$channelData2.includes(_Constants2.Constants.queuePositionMessageTag)) {
+      isInQueue = true;
+    }
     if ((0, _util.isHistoryMessage)(activity, startTime)) {
       var _TelemetryManager$Int2;
       historyMessageStrategy((0, _util.polyfillMessagePayloadForEvent)(activity, payload, (_TelemetryManager$Int2 = _TelemetryManager.TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int2 === void 0 ? void 0 : _TelemetryManager$Int2.conversationId));
@@ -76,11 +83,11 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
     }
   };
   const isValidMessage = activity => {
-    var _activity$channelData, _activity$channelData2, _activity$channelData3;
+    var _activity$channelData3, _activity$channelData4, _activity$channelData5;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const messageHasNoText = !(activity !== null && activity !== void 0 && activity.text);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const messageHasNoTags = !(activity !== null && activity !== void 0 && activity.channelData) || !(activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && _activity$channelData.tags) || (activity === null || activity === void 0 ? void 0 : (_activity$channelData2 = activity.channelData) === null || _activity$channelData2 === void 0 ? void 0 : (_activity$channelData3 = _activity$channelData2.tags) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.length) === 0;
+    const messageHasNoTags = !(activity !== null && activity !== void 0 && activity.channelData) || !(activity !== null && activity !== void 0 && (_activity$channelData3 = activity.channelData) !== null && _activity$channelData3 !== void 0 && _activity$channelData3.tags) || (activity === null || activity === void 0 ? void 0 : (_activity$channelData4 = activity.channelData) === null || _activity$channelData4 === void 0 ? void 0 : (_activity$channelData5 = _activity$channelData4.tags) === null || _activity$channelData5 === void 0 ? void 0 : _activity$channelData5.length) === 0;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const messageHasNoAttachments = !(activity !== null && activity !== void 0 && activity.attachments) || (activity === null || activity === void 0 ? void 0 : activity.attachments.length) === 0;
     if (messageHasNoTags && messageHasNoText && messageHasNoAttachments) {
@@ -102,6 +109,16 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
       historyMessageStrategy((0, _util.polyfillMessagePayloadForEvent)(activity, payload, (_TelemetryManager$Int4 = _TelemetryManager.TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int4 === void 0 ? void 0 : _TelemetryManager$Int4.conversationId));
       return;
     }
+
+    // Log agent joining when first non-history message is received after queue
+    if (isInQueue && !agentJoinLogged) {
+      agentJoinLogged = true;
+      isInQueue = false;
+      _TelemetryHelper.TelemetryHelper.logActionEvent(_TelemetryConstants.LogLevel.INFO, {
+        Event: _TelemetryConstants.TelemetryEvent.AgentJoinedConversation,
+        Description: "First message received from agent after queue"
+      });
+    }
     firstResponseLatencyTracker.stopClock(payload);
     const newMessageReceivedEvent = {
       eventName: _TelemetryConstants.BroadcastEvent.NewMessageReceived,

package/lib/esm/common/Constants.js

@@ -75,6 +75,8 @@ _defineProperty(Constants, "audioMediaRegex", /(\.)(aac|aiff|alac|amr|flac|mp2|m
 _defineProperty(Constants, "videoMediaRegex", /(\.)(avchd|avi|flv|mpe|mpeg|mpg|mpv|mp4|m4p|m4v|mov|qt|swf|webm|wmv)$/i);
 _defineProperty(Constants, "chromeSupportedInlineMediaRegex", /(\.)(aac|mp3|wav|mp4)$/i);
 _defineProperty(Constants, "firefoxSupportedInlineMediaRegex", /(\.)(aac|flac|mp3|wav|mp4|mov)$/i);
+_defineProperty(Constants, "AdaptiveCardType", "adaptivecard");
+_defineProperty(Constants, "SuggestedActionsType", "suggestedactions");
 // calling container event names
 _defineProperty(Constants, "CallAdded", "callAdded");
 _defineProperty(Constants, "LocalVideoStreamAdded", "localVideoStreamAdded");