@microsoft/omnichannel-chat-widget 1.8.2-main.fc93d3d → 1.8.3-main.38c88a7

package/lib/esm/firstresponselatency/FirstMessageTrackerFromBot.js

@@ -7,54 +7,96 @@ import { createTrackingMessage } from "./util";
 //  with different timeline, therefore this is a functional approach to track the events, instead of a class based approach
 export const createTrackingForFirstMessage = () => {
   // Reset the tracking variables
-  let startTracking = false;
-  let stopTracking = false;
+  let isTracking = false;
   let startTime = 0;
   let stopTime = 0;
-  let stopTrackingMessage;
+  let stopTrackingMessage = null;
   let flag = false;
+  let trackingTimeoutId;
+
+  /**
+   * Checks if the message payload is from a valid sender (not an agent).
+   * Returns false if the message is from an agent (tag 'public'), true otherwise.
+   */
   const isMessageFromValidSender = payload => {
     var _payload$tags;
-    // agent scenario
     if (payload !== null && payload !== void 0 && (_payload$tags = payload.tags) !== null && _payload$tags !== void 0 && _payload$tags.includes("public")) {
       return false;
     }
     return true;
   };
+
+  /**
+   * Listener for widget load completion event.
+   * Starts tracking the time for the first bot message after widget loads.
+   * Sets a 5-second timeout to auto-reset if no bot message is received.
+   */
   const widgetLoadListener = BroadcastService.getMessageByEventName(TelemetryEvent.WidgetLoadComplete).subscribe(() => {
-    if (startTracking) return;
-    startTracking = true;
+    if (isTracking) return;
+    isTracking = true;
     startTime = new Date().getTime();
+    // Start a 5-second timeout to auto-stop tracking if not stopped
+    if (trackingTimeoutId) {
+      clearTimeout(trackingTimeoutId);
+    }
+    trackingTimeoutId = setTimeout(() => {
+      if (isTracking) {
+        // Reset state and disengage, no telemetry or FMLTrackingCompleted
+        isTracking = false;
+        startTime = 0;
+        stopTime = 0;
+        stopTrackingMessage = null;
+        trackingTimeoutId = undefined;
+        disconnectListener();
+      }
+    }, 10000); //adding more time since it meassures from widget load complete till message received
   });
+
+  /**
+   * Listener for new bot message event.
+   * If a valid bot message is received, stops tracking and logs telemetry.
+   * If the message is invalid, resets and disengages listeners.
+   */
   const newMessageListener = BroadcastService.getMessageByEventName(BroadcastEvent.NewMessageReceived).subscribe(message => {
     const payload = message.payload;
-
-    // we only care for bot, so we need to check if the message is from the bot
-    // pending to add typing message indicator signal detection
-
-    if (isMessageFromValidSender(payload)) {
-      if (startTracking && !stopTracking) {
-        stopTime = new Date().getTime();
-        const elapsedTime = stopTime - startTime;
-        stopTracking = true;
-        stopTrackingMessage = createTrackingMessage(payload, "botMessage");
-        notifyFMLTrackingCompleted();
-        TelemetryHelper.logActionEvent(LogLevel.INFO, {
-          Event: TelemetryEvent.BotFirstMessageLapTrack,
-          Description: "First Message from Bot latency tracking",
-          CustomProperties: {
-            elapsedTime,
-            widgetLoadedAt: startTime,
-            botMessage: stopTrackingMessage
-          }
-        });
+    if (!isMessageFromValidSender(payload)) {
+      // If not valid, stop everything and clean up
+      isTracking = false;
+      if (trackingTimeoutId) {
+        clearTimeout(trackingTimeoutId);
+        trackingTimeoutId = undefined;
       }
+      disconnectListener();
+      return;
+    }
+    if (isTracking) {
+      isTracking = false;
+      // Clear the timeout if it exists
+      if (trackingTimeoutId) {
+        clearTimeout(trackingTimeoutId);
+        trackingTimeoutId = undefined;
+      }
+      stopTime = new Date().getTime();
+      const elapsedTime = stopTime - startTime;
+      stopTrackingMessage = createTrackingMessage(payload, "botMessage");
+      notifyFMLTrackingCompleted();
+      TelemetryHelper.logActionEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.BotFirstMessageLapTrack,
+        Description: "First Message from Bot latency tracking",
+        CustomProperties: {
+          elapsedTime,
+          widgetLoadedAt: startTime,
+          botMessage: stopTrackingMessage
+        }
+      });
+      disconnectListener();
     }
-
-    // this track only first message, if coming from the bot or not
-    // the only difference is that it logs only those from bot
-    disconnectListener();
   });
+
+  /**
+   * Notifies that FML (First Message Latency) tracking is completed.
+   * Retries sending the completion event until acknowledged.
+   */
   const notifyFMLTrackingCompleted = () => {
     ackListener();
     // Retry sending until flag is true, but do not block the main thread
@@ -69,6 +111,11 @@ export const createTrackingForFirstMessage = () => {
       }
     }, 100);
   };
+
+  /**
+   * Listener for FMLTrackingCompletedAck event.
+   * Sets the flag to true when acknowledgment is received.
+   */
   const ackListener = () => {
     const listen = BroadcastService.getMessageByEventName(BroadcastEvent.FMLTrackingCompletedAck).subscribe(() => {
       flag = true;
@@ -78,22 +125,32 @@ export const createTrackingForFirstMessage = () => {
 
   // Rehydrate message is received when the widget is reloaded, this is to ensure that we are not tracking messages that are not part of the current conversation
   // No need to keep listerning for tracking, enforcing disconnection for the listners
+  /**
+   * Listener for widget rehydration event.
+   * Resets tracking and disconnects listeners when widget is reloaded.
+   */
   const rehydrateListener = BroadcastService.getMessageByEventName(TelemetryEvent.RehydrateMessageReceived).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
   });
 
   // Rehydrate message is received when the widget is reloaded, this is to ensure that we are not tracking messages that are not part of the current conversation
   // No need to keep listerning for tracking, enforcing disconnection for the listners
+  /**
+   * Listener for history message event.
+   * Resets tracking and disconnects listeners when history is loaded.
+   */
   const historyListener = BroadcastService.getMessageByEventName(BroadcastEvent.HistoryMessageReceived).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
   });
+
+  /**
+   * Listener for network disconnection event.
+   * Resets tracking, disconnects listeners, and logs a telemetry error.
+   */
   const offlineNetworkListener = BroadcastService.getMessageByEventName(TelemetryEvent.NetworkDisconnected).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
     TelemetryHelper.logActionEvent(LogLevel.INFO, {
       Event: TelemetryEvent.BotFirstMessageLapTrackError,
@@ -102,7 +159,15 @@ export const createTrackingForFirstMessage = () => {
   });
 
   // this is to ensure that we are not tracking messages that are not part of the current conversation
+  /**
+   * Disconnects all listeners and clears the tracking timeout.
+   * Used for cleanup when tracking is stopped or reset.
+   */
   const disconnectListener = () => {
+    if (trackingTimeoutId) {
+      clearTimeout(trackingTimeoutId);
+      trackingTimeoutId = undefined;
+    }
     historyListener.unsubscribe();
     rehydrateListener.unsubscribe();
     newMessageListener.unsubscribe();

package/lib/esm/firstresponselatency/FirstResponseLatencyTracker.js

@@ -11,14 +11,13 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
   function FirstResponseLatencyTracker() {
     _classCallCheck(this, FirstResponseLatencyTracker);
     _defineProperty(this, "isABotConversation", false);
-    _defineProperty(this, "isStarted", false);
-    _defineProperty(this, "isEnded", false);
+    _defineProperty(this, "isTracking", false);
     _defineProperty(this, "startTrackingMessage", void 0);
     _defineProperty(this, "stopTrackingMessage", void 0);
     _defineProperty(this, "isReady", false);
+    _defineProperty(this, "trackingTimeoutId", void 0);
     _defineProperty(this, "offlineNetworkListener", BroadcastService.getMessageByEventName(TelemetryEvent.NetworkDisconnected).subscribe(() => {
-      this.isStarted = false;
-      this.isEnded = false;
+      this.isTracking = false;
       TelemetryHelper.logActionEvent(LogLevel.INFO, {
         Event: TelemetryEvent.MessageStopLapTrackError,
         Description: "Tracker Stopped due to network disconnection"
@@ -66,7 +65,7 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function startTracking(payload) {
       if (!this.isReady) return;
       //  this prevents to initiate tracking for multiple incoming messages
-      if (this.isStarted) {
+      if (this.isTracking) {
         return;
       }
       // this is to ensure we track only messages where bot is engaged
@@ -74,10 +73,24 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
         return;
       }
       // control of states to prevent clashing of messages
-      this.isStarted = true;
-      this.isEnded = false;
+      this.isTracking = true;
       // The idea  of using types is to enrich telemetry data 
       this.startTrackingMessage = this.createTrackingMessage(payload, "userMessage");
+
+      // Start a 5-second timeout to auto-stop tracking if not stopped
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+      }
+      this.trackingTimeoutId = setTimeout(() => {
+        // this means the start process is in progress, but the end wasn't called within the time limit
+        if (this.isTracking) {
+          // Reset state variables and skip stopTracking
+          this.isTracking = false;
+          this.startTrackingMessage = undefined;
+          this.stopTrackingMessage = undefined;
+          this.trackingTimeoutId = undefined;
+        }
+      }, 5000);
     }
   }, {
     key: "handleAgentMessage",
@@ -93,13 +106,16 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function stopTracking(payload) {
       var _this$stopTrackingMes, _this$startTrackingMe;
       // this prevents execution for multiple incoming messages from the bot.
-      if (this.isEnded && !this.isStarted) {
+      if (!this.isTracking) {
         return;
       }
-
+      // Clear the timeout if it exists
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+        this.trackingTimeoutId = undefined;
+      }
       // control of states to prevent clashing of messages
-      this.isEnded = true;
-      this.isStarted = false;
+      this.isTracking = false;
 
       // The idea  of using types is to enrich telemetry data 
       this.stopTrackingMessage = this.createTrackingMessage(payload, "botMessage");
@@ -154,12 +170,16 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
         if (!payload || !payload.Id) {
           throw new Error("Invalid payload");
         }
-        if (!this.isMessageFromValidSender(payload)) return;
-        if (this.isABotConversation && this.isStarted) {
+
+        // Only allow stopTracking if sender is valid and tracking is active
+        if (!this.isMessageFromValidSender(payload)) {
+          // Do not change isTracking or stopTrackingMessage
+          return;
+        }
+        if (this.isABotConversation && this.isTracking) {
           this.stopTracking(payload);
         }
       } catch (e) {
-        console.error("FRL : error while trying to stop the tracker", e);
         TelemetryHelper.logActionEvent(LogLevel.ERROR, {
           Event: TelemetryEvent.MessageStopLapTrackError,
           Description: "Error while stopping the clock",
@@ -168,11 +188,6 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
             payload: payload
           }
         });
-        //reset state
-        this.startTrackingMessage = undefined;
-        this.stopTrackingMessage = undefined;
-        this.isStarted = false;
-        this.isEnded = false;
       }
     }
   }, {
@@ -180,10 +195,13 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function deregister() {
       // Reset State
       this.isABotConversation = false;
-      this.isStarted = false;
-      this.isEnded = false;
+      this.isTracking = false;
       this.startTrackingMessage = undefined;
       this.stopTrackingMessage = undefined;
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+        this.trackingTimeoutId = undefined;
+      }
       this.offlineNetworkListener.unsubscribe();
       this.fmltrackingListener.unsubscribe();
       this.rehydrateListener.unsubscribe();

package/lib/esm/firstresponselatency/util.js

@@ -1,5 +1,7 @@
 import { ScenarioType } from "./Constants";
 import { Constants } from "../common/Constants";
+const DELTA_WITHIN_LIMITS_IN_MS = 250;
+
 /**
  * Determines whether a given activity is a historical message.
  * 
@@ -17,19 +19,21 @@ import { Constants } from "../common/Constants";
  *   - If the ID is valid and the timestamp is older than the start time, the message is historical.
  */
 export const isHistoryMessage = (activity, startTime) => {
-  var _activity$channelData, _activity$channelData2;
+  var _activity$channelData;
   // Only process message activities
   if ((activity === null || activity === void 0 ? void 0 : activity.type) !== Constants.message) {
     return false;
   }
 
-  // Legacy check for history message tag
-  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(Constants.historyMessageTag)) {
+  // Prioritize legacy history tag
+  if (activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && _activity$channelData.tags && activity.channelData.tags.includes(Constants.historyMessageTag)) {
     return true;
   }
   const activityId = extractTimestampFromId(activity);
   const isValidId = !isNaN(activityId) && activityId > 0;
-  const isOlderThanStartTime = activityId < startTime;
+  const difference = startTime - activityId;
+  // Only consider historical if activityId < startTime and difference >= DELTA_WITHIN_LIMITS_IN_MS
+  const isOlderThanStartTime = activityId < startTime && difference >= DELTA_WITHIN_LIMITS_IN_MS;
   const isHistoryById = isValidId && isOlderThanStartTime;
   return isHistoryById;
 };
@@ -56,7 +60,7 @@ export const extractTimestampFromId = activity => {
   return activityId;
 };
 export const buildMessagePayload = (activity, userId) => {
-  var _text, _text2, _activity$channelData3, _activity$from;
+  var _text, _text2, _activity$channelData2, _activity$from;
   return {
     // To identify hidden contents vs empty content
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -64,7 +68,7 @@ export const buildMessagePayload = (activity, userId) => {
     type: activity === null || activity === void 0 ? void 0 : activity.type,
     timestamp: activity === null || activity === void 0 ? void 0 : activity.timestamp,
     userId: userId,
-    tags: activity === null || activity === void 0 ? void 0 : (_activity$channelData3 = activity.channelData) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.tags,
+    tags: (activity === null || activity === void 0 ? void 0 : (_activity$channelData2 = activity.channelData) === null || _activity$channelData2 === void 0 ? void 0 : _activity$channelData2.tags) || [],
     messageType: "",
     Id: activity === null || activity === void 0 ? void 0 : activity.id,
     role: activity === null || activity === void 0 ? void 0 : (_activity$from = activity.from) === null || _activity$from === void 0 ? void 0 : _activity$from.role,
@@ -88,9 +92,9 @@ export const polyfillMessagePayloadForEvent = (activity, payload, conversationId
   };
 };
 export const getScenarioType = activity => {
-  var _activity$from3, _activity$channelData4;
+  var _activity$from3, _activity$channelData3;
   const role = activity === null || activity === void 0 ? void 0 : (_activity$from3 = activity.from) === null || _activity$from3 === void 0 ? void 0 : _activity$from3.role;
-  const tags = activity === null || activity === void 0 ? void 0 : (_activity$channelData4 = activity.channelData) === null || _activity$channelData4 === void 0 ? void 0 : _activity$channelData4.tags;
+  const tags = activity === null || activity === void 0 ? void 0 : (_activity$channelData3 = activity.channelData) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.tags;
   if (role === Constants.userMessageTag) {
     return ScenarioType.UserSendMessageStrategy;
   }

package/lib/esm/plugins/createChatTranscript.js

@@ -700,10 +700,23 @@ const createChatTranscript = async function (transcript, facadeChatSDK) {
       reader.readAsDataURL(blob);
     });
   };
+
+  // Configure DOMPurify to remove target attribute from br tags
+  const hook = function (node) {
+    // eslint-disable-line @typescript-eslint/no-explicit-any
+    // Remove target attribute from br tags as it causes them to display as literal text
+    if (node.tagName === "BR" && node.hasAttribute("target")) {
+      node.removeAttribute("target");
+    }
+  };
+  DOMPurify.addHook("afterSanitizeAttributes", hook);
   let messages = transcriptMessages.filter(message => {
     message.content = DOMPurify.sanitize(message.content);
     return message;
   });
+
+  // Clean up the hook after processing all messages
+  DOMPurify.removeHook("afterSanitizeAttributes", hook);
   if (renderAttachments) {
     messages = await Promise.all(transcriptMessages.map(async message => {
       // eslint-disable-line @typescript-eslint/no-explicit-any

package/lib/types/common/Constants.d.ts

@@ -16,6 +16,7 @@ export declare class Constants {
     static readonly markdown = "markdown";
     static readonly actionType = "actionType";
     static readonly markDownSystemMessageClass = "webchat__basic-transcript__activity-markdown-body";
+    static readonly MARKDOWN_LIST_INDENTATION = "   ";
     static readonly String = "string";
     static readonly ChatMessagesJson = "chatMessagesJson";
     static readonly truePascal = "True";
@@ -83,8 +84,7 @@ export declare class Constants {
     static readonly TargetRelationship = "rel";
     static readonly TargetRelationshipAttributes = "noopener noreferrer";
     static readonly OpenLinkIconCssClass = "webchat__render-markdown__external-link-icon";
-    static readonly internetConnectionTestUrl = "https://ocsdk-prod.azureedge.net/public/connecttest.txt";
-    static readonly internetConnectionTestUrlText = "Omnichannel Connect Test";
+    static readonly internetConnectionTestPath = "/livechatwidget/version.txt";
     static readonly ChatWidgetStateChangedPrefix = "ChatWidgetStateChanged";
     static readonly PostChatLoadingDurationInMs = 2000;
     static readonly BrowserUnloadConfirmationMessage = "Do you want to leave chat?";
@@ -97,6 +97,12 @@ export declare class Constants {
     static readonly OCOriginalMessageId = "OriginalMessageId";
     static readonly WebchatSequenceIdAttribute = "webchat:sequence-id";
     static readonly MessageSequenceIdOverride = "MessageSequenceIdOverride";
+    static readonly sendCustomEvent = "sendCustomEvent";
+    static readonly onCustomEvent = "onCustomEvent";
+    static readonly customEventName = "customEventName";
+    static readonly customEventValue = "customEventValue";
+    static readonly Hidden = "Hidden";
+    static readonly EndConversationDueToOverflow = "endconversationduetooverflow";
 }
 export declare const Regex: {
     new (): {};

package/lib/types/common/telemetry/TelemetryConstants.d.ts

@@ -172,6 +172,7 @@ export declare enum TelemetryEvent {
     BotAuthActivityUndefinedSignInId = "BotAuthActivityUndefinedSignInId",
     ThirdPartyCookiesBlocked = "ThirdPartyCookiesBlocked",
     ParticipantsRemovedEvent = "ParticipantsRemovedEvent",
+    QueueOverflowEvent = "QueueOverflowEvent",
     ProcessingHTMLTextMiddlewareFailed = "ProcessingHTMLTextMiddlewareFailed",
     ProcessingSanitizationMiddlewareFailed = "ProcessingSanitizationMiddlewareFailed",
     FormatTagsMiddlewareJSONStringifyFailed = "FormatTagsMiddlewareJSONStringifyFailed",
@@ -210,6 +211,7 @@ export declare enum TelemetryEvent {
     SystemMessageReceived = "SystemMessageReceived",
     RehydrateMessageReceived = "RehydrateMessageReceived",
     CustomContextReceived = "CustomContextReceived",
+    CustomEventAction = "CustomEventAction",
     NetworkDisconnected = "NetworkDisconnected",
     NetworkReconnected = "NetworkReconnected",
     LinkModePostChatWorkflowStarted = "LinkModePostChatWorkflowStarted",

package/lib/types/common/utils.d.ts

@@ -1,5 +1,6 @@
 import { FacadeChatSDK } from "./facades/FacadeChatSDK";
 import { ITimer } from "./interfaces/ITimer";
+import * as CustomEventType from "../contexts/common/CustomEventType";
 export declare const setTabIndices: (elements: HTMLElement[] | null, tabIndexMap: Map<string, number>, shouldBeFocusable: boolean) => void;
 export declare const findParentFocusableElementsWithoutChildContainer: (elementId: string) => HTMLElement[] | null;
 export declare const findAllFocusableElement: (parent: string | HTMLElement) => any[] | null;
@@ -47,3 +48,10 @@ export declare const formatTemplateString: (templateMessage: string, values: any
 export declare const parseLowerCaseString: (property: string | boolean | undefined) => string;
 export declare const setOcUserAgent: (chatSDK: any) => void;
 export declare function getDeviceType(): string;
+export declare const isValidCustomEvent: (payload: object) => boolean;
+export declare const getCustomEventValue: (customEventPayload: CustomEventType.ICustomEvent) => string;
+export declare function isEndConversationDueToOverflowActivity(activity: {
+    channelData?: {
+        tags?: string[];
+    };
+}): boolean | undefined;

package/lib/types/components/livechatwidget/common/customEventHandler.d.ts

@@ -0,0 +1,4 @@
+import { FacadeChatSDK } from "../../../common/facades/FacadeChatSDK";
+import { BroadcastService } from "@microsoft/omnichannel-chat-components";
+export declare const customEventCallback: (facadeChatSDK: FacadeChatSDK) => (event: object) => void;
+export declare const subscribeToSendCustomEvent: (broadcastService: typeof BroadcastService, facadeChatSDK: FacadeChatSDK, customEventCallback: (fackageSdK: FacadeChatSDK) => (event: object) => void) => void;

package/lib/types/components/webchatcontainerstateful/common/utils/chatAdapterUtils.d.ts

@@ -2,8 +2,10 @@ import { Activity, Attachment, Message, User } from "botframework-directlinejs";
 import { Subscriber } from "rxjs/Subscriber";
 export declare const customerUser: User;
 export declare const botUser: User;
+export declare const agentUser: User;
 export declare const postEchoActivity: (activityObserver: Subscriber<Activity> | undefined, activity: Message, user: User, delay?: number) => void;
 export declare const postBotMessageActivity: (activityObserver: Subscriber<Activity> | undefined, text: string, tags?: string, delay?: number) => void;
+export declare const postAgentMessageActivity: (activityObserver: Subscriber<Activity> | undefined, text: string, tags?: string, delay?: number) => void;
 export declare const postSystemMessageActivity: (activityObserver: Subscriber<Activity> | undefined, text: string, delay?: number) => void;
 export declare const postBotTypingActivity: (activityObserver: Subscriber<Activity> | undefined, delay?: number) => void;
 export declare const postBotAttachmentActivity: (activityObserver: Subscriber<Activity> | undefined, attachments?: Attachment[], delay?: number) => void;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/callActionMiddleware.d.ts

@@ -0,0 +1,8 @@
+/******
+ * CallActionMiddleware
+ *
+ * Intercepts custom call actions and handles tel: URL navigation
+ ******/
+import { IWebChatAction } from "../../../interfaces/IWebChatAction";
+declare const createCallActionMiddleware: () => () => (next: any) => (action: IWebChatAction) => any;
+export default createCallActionMiddleware;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/customEventMiddleware.d.ts

@@ -0,0 +1,22 @@
+/******
+ * CustomEventMiddleware
+ *
+ * This middleware is invoked when a custom event is received.
+ * The callback is then invoked to handle the custom event.
+ ******/
+import { IWebChatAction } from "../../../interfaces/IWebChatAction";
+import { BroadcastService } from "@microsoft/omnichannel-chat-components";
+export declare const isValidCustomEvent: (activity: {
+    channelData?: {
+        metadata?: {
+            customEvent?: string;
+            customEventName?: string;
+            customEventValue?: unknown;
+        };
+    };
+    from?: {
+        role: string;
+    };
+}) => boolean;
+declare const createCustomEventMiddleware: (broadcastservice: typeof BroadcastService) => () => (next: (action: IWebChatAction) => void) => (action: IWebChatAction) => void;
+export default createCustomEventMiddleware;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/queueOverflowHandlerMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { IWebChatAction } from "../../../interfaces/IWebChatAction";
+import { ILiveChatWidgetContext } from "../../../../../contexts/common/ILiveChatWidgetContext";
+import { Dispatch } from "react";
+import { ILiveChatWidgetAction } from "../../../../../contexts/common/ILiveChatWidgetAction";
+export declare const createQueueOverflowMiddleware: (state: ILiveChatWidgetContext, dispatch: Dispatch<ILiveChatWidgetAction>) => () => (next: (action: IWebChatAction) => void) => (action: IWebChatAction) => void;

package/lib/types/contexts/common/CustomEventType.d.ts

@@ -0,0 +1,6 @@
+export interface ICustomEvent {
+    messageId?: string;
+    customEvent?: string;
+    customEventName: string;
+    customEventValue: unknown;
+}

package/lib/types/firstresponselatency/FirstResponseLatencyTracker.d.ts

@@ -1,11 +1,11 @@
 import { MessagePayload } from "./Constants";
 export declare class FirstResponseLatencyTracker {
     private isABotConversation;
-    private isStarted;
-    private isEnded;
+    private isTracking;
     private startTrackingMessage?;
     private stopTrackingMessage?;
     private isReady;
+    private trackingTimeoutId?;
     constructor();
     private createTrackingMessage;
     private startTracking;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/omnichannel-chat-widget",
-  "version": "1.8.2-main.fc93d3d",
+  "version": "1.8.3-main.38c88a7",
   "description": "Microsoft Omnichannel Chat Widget",
   "main": "lib/cjs/index.js",
   "types": "lib/types/index.d.ts",
@@ -86,8 +86,8 @@
   "dependencies": {
     "@azure/core-tracing": "^1.2.0",
     "@microsoft/applicationinsights-web": "^3.3.6",
-    "@microsoft/omnichannel-chat-components": "1.1.12",
-    "@microsoft/omnichannel-chat-sdk": "^1.11.4",
+    "@microsoft/omnichannel-chat-components": "1.1.13",
+    "@microsoft/omnichannel-chat-sdk": "^1.11.6",
     "@opentelemetry/api": "^1.9.0",
     "abort-controller": "^3",
     "abort-controller-es5": "^2.0.1",