@microsoft/omnichannel-chat-widget 1.8.3 → 1.8.4-main.7bdb634

package/lib/esm/components/webchatcontainerstateful/hooks/usePersistentChatHistory.js

@@ -0,0 +1,51 @@
+import { LogLevel, TelemetryEvent } from "../../../common/telemetry/TelemetryConstants";
+import { useEffect, useRef } from "react";
+import ChatWidgetEvents from "../../livechatwidget/common/ChatWidgetEvents";
+import PersistentConversationHandler from "../../livechatwidget/common/PersistentConversationHandler";
+import { TelemetryHelper } from "../../../common/telemetry/TelemetryHelper";
+import dispatchCustomEvent from "../../../common/utils/dispatchCustomEvent";
+import SecureEventBus from "../../../common/utils/SecureEventBus";
+const usePersistentChatHistory = (facadeChatSDK, props) => {
+  const handlerRef = useRef(null);
+  useEffect(() => {
+    if (!facadeChatSDK) {
+      return;
+    }
+    TelemetryHelper.logLoadingEventToAllTelemetry(LogLevel.INFO, {
+      Event: TelemetryEvent.UXLCWPersistentChatHistoryInitialized,
+      Description: "Persistent chat history hook initialized"
+    });
+    handlerRef.current = new PersistentConversationHandler(facadeChatSDK, props);
+    const handler = async () => {
+      TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
+        Event: TelemetryEvent.LCWPersistentChatHistoryFetchStarted,
+        Description: "Persistent chat history fetch started"
+      });
+      try {
+        var _handlerRef$current;
+        await ((_handlerRef$current = handlerRef.current) === null || _handlerRef$current === void 0 ? void 0 : _handlerRef$current.pullHistory());
+        dispatchCustomEvent(ChatWidgetEvents.HIDE_LOADING_BANNER);
+        TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
+          Event: TelemetryEvent.LCWPersistentChatHistoryFetchCompleted,
+          Description: "Persistent chat history fetch completed successfully"
+        });
+      } catch (error) {
+        TelemetryHelper.logActionEventToAllTelemetry(LogLevel.ERROR, {
+          Event: TelemetryEvent.LCWPersistentChatHistoryFetchFailed,
+          Description: "Persistent chat history fetch failed",
+          ExceptionDetails: error
+        });
+      }
+    };
+
+    // Subscribe to the secure event bus instead of global window events
+    const eventBus = SecureEventBus.getInstance();
+    const unsubscribe = eventBus.subscribe(ChatWidgetEvents.FETCH_PERSISTENT_CHAT_HISTORY, handler);
+    return () => {
+      var _handlerRef$current2;
+      unsubscribe();
+      (_handlerRef$current2 = handlerRef.current) === null || _handlerRef$current2 === void 0 ? void 0 : _handlerRef$current2.destroy(); // Call destroy instead of reset to properly clean up
+    };
+  }, [facadeChatSDK]);
+};
+export default usePersistentChatHistory;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/WebChatEventSubscribers.js

@@ -0,0 +1,115 @@
+import { LogLevel, TelemetryEvent } from "../../../common/telemetry/TelemetryConstants";
+import { useEffect, useState } from "react";
+import ChatWidgetEvents from "../../livechatwidget/common/ChatWidgetEvents";
+import { Constants } from "../../../common/Constants";
+import { TelemetryHelper } from "../../../common/telemetry/TelemetryHelper";
+import { WebChatStoreLoader } from "./WebChatStoreLoader";
+import { createTimer } from "../../../common/utils";
+import dispatchCustomEvent from "../../../common/utils/dispatchCustomEvent";
+
+/**
+ * Component to handle persistent chat history events.
+ * Uses WebChatStoreLoader instead of hooks to avoid context issues.
+ */
+const WebChatEventSubscribers = props => {
+  const [isConnected, setIsConnected] = useState(false);
+  const [storeReady, setStoreReady] = useState(false);
+  const storeWaitTimer = createTimer();
+  useEffect(() => {
+    if (!props.persistentChatHistoryEnabled) {
+      return;
+    }
+    TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
+      Event: TelemetryEvent.LCWWebChatStorePollingStarted,
+      Description: "WebChat store polling started"
+    });
+
+    // Wait for WebChat store to be available
+    const waitForStore = () => {
+      if (WebChatStoreLoader.store) {
+        setStoreReady(true);
+        TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
+          Event: TelemetryEvent.LCWWebChatStoreReady,
+          Description: "WebChat store ready",
+          ElapsedTimeInMilliseconds: storeWaitTimer.milliSecondsElapsed
+        });
+        return true;
+      }
+      return false;
+    };
+
+    // Check if store is already available
+    if (!waitForStore()) {
+      // Poll for store availability
+      const storeCheckInterval = setInterval(() => {
+        if (waitForStore()) {
+          clearInterval(storeCheckInterval);
+        }
+      }, 100);
+      return () => {
+        clearInterval(storeCheckInterval);
+      };
+    }
+  }, [props.persistentChatHistoryEnabled]);
+  useEffect(() => {
+    if (!props.persistentChatHistoryEnabled || !storeReady) {
+      return;
+    }
+    const checkConnectionStatus = () => {
+      try {
+        if (WebChatStoreLoader.store) {
+          const state = WebChatStoreLoader.store.getState();
+          const connectivityStatus = state === null || state === void 0 ? void 0 : state.connectivityStatus;
+          const newIsConnected = connectivityStatus === "connected";
+          if (newIsConnected && !isConnected) {
+            setIsConnected(true);
+            TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
+              Event: TelemetryEvent.LCWWebChatConnected,
+              Description: "WebChat connection established, dispatching events"
+            });
+
+            // Dispatch events when connection is established
+            setTimeout(() => {
+              dispatchCustomEvent(ChatWidgetEvents.FETCH_PERSISTENT_CHAT_HISTORY);
+              dispatchCustomEvent(ChatWidgetEvents.ADD_ACTIVITY, {
+                activity: {
+                  from: {
+                    role: "bot"
+                  },
+                  timestamp: 0,
+                  type: "message",
+                  channelData: {
+                    tags: [Constants.persistentChatHistoryMessagePullTriggerTag]
+                  }
+                }
+              });
+            }, 2000);
+          } else if (!newIsConnected && isConnected) {
+            setIsConnected(false);
+            TelemetryHelper.logActionEventToAllTelemetry(LogLevel.WARN, {
+              Event: TelemetryEvent.LCWWebChatDisconnected,
+              Description: "WebChat connection lost"
+            });
+          }
+        }
+      } catch (error) {
+        TelemetryHelper.logActionEventToAllTelemetry(LogLevel.ERROR, {
+          Event: TelemetryEvent.LCWWebChatConnectionCheckFailed,
+          Description: "WebChat connection status check failed",
+          ExceptionDetails: error
+        });
+      }
+    };
+
+    // Check immediately
+    checkConnectionStatus();
+
+    // Set up interval to check connection status
+    const interval = setInterval(checkConnectionStatus, 1000);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [isConnected, props.persistentChatHistoryEnabled, storeReady]);
+  return null;
+};
+export default WebChatEventSubscribers;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/Constants.js

@@ -0,0 +1,3 @@
+export const LazyLoadActivityConstants = {
+  SCROLL_ID: ".webchat__basic-transcript__scrollable"
+};

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/ConversationDividerActivity.js

@@ -0,0 +1,10 @@
+import React from "react";
+import { defaultPersistentChatHistoryProps } from "../../../../../livechatwidget/common/defaultProps/defaultPersistentChatHistoryProps";
+import { mergeStyles } from "@fluentui/react";
+const ConversationDividerActivity = props => {
+  const styleApplied = mergeStyles(defaultPersistentChatHistoryProps.dividerActivityStyle, props.dividerActivityStyle);
+  return /*#__PURE__*/React.createElement("div", {
+    className: styleApplied
+  });
+};
+export default ConversationDividerActivity;