@microsoft/omnichannel-chat-widget 0.1.0-main.1a61ea0

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/htmlTextMiddleware.js

@@ -0,0 +1,131 @@
+/******
+ * HTMLTextMiddleware
+ * 
+ * Ensures that links within messages are processed so that the caller website cannot be traced.
+ ******/
+import { Constants, HtmlAttributeNames } from "../../../../../common/Constants";
+import DOMPurify from "dompurify";
+import { WebChatActionType } from "../../enums/WebChatActionType";
+import { TelemetryHelper } from "../../../../../common/telemetry/TelemetryHelper";
+import { LogLevel, TelemetryEvent } from "../../../../../common/telemetry/TelemetryConstants"; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+const convertTextToHtmlNode = text => {
+  if (!text) return "";
+  const element = document.createElement(HtmlAttributeNames.div);
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    text = DOMPurify.sanitize(text);
+    element.innerHTML = text;
+  } catch (e) {
+    const errorMessage = `Failed to purify and set innertHTML with text: ${text}`;
+    TelemetryHelper.logActionEvent(LogLevel.ERROR, {
+      Event: TelemetryEvent.ProcessingHTMLTextMiddlewareFailed,
+      ExceptionDetails: {
+        ErrorData: errorMessage,
+        Exception: e
+      }
+    });
+  }
+
+  return element;
+}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+const processHTMLText = (action, text) => {
+  const htmlNode = convertTextToHtmlNode(text);
+  const aNodes = htmlNode.getElementsByTagName(HtmlAttributeNames.aTagName);
+
+  if ((aNodes === null || aNodes === void 0 ? void 0 : aNodes.length) > 0) {
+    try {
+      for (let index = 0; index < aNodes.length; index++) {
+        var _aNode$tagName;
+
+        const aNode = aNodes[index]; // Skip if the node is not valid or the node's tag name is not equal to 'a', or the node href is empty.
+
+        if (((_aNode$tagName = aNode.tagName) === null || _aNode$tagName === void 0 ? void 0 : _aNode$tagName.toLowerCase()) !== HtmlAttributeNames.aTagName || !aNode.href) {
+          continue;
+        } // Add target to 'a' node if target is missing or does not equal to blank
+
+
+        if (!aNode.target || aNode.target !== Constants.blank) {
+          aNode.target = Constants.blank;
+        } // If rel is missing or rel does not include noopener and noreferrer, add them
+
+
+        if (!aNode.rel) {
+          aNode.rel = `${HtmlAttributeNames.noopenerTag} ${HtmlAttributeNames.noreferrerTag}`;
+        } else {
+          if (aNode.rel.indexOf(HtmlAttributeNames.noopenerTag) === -1) {
+            aNode.rel += ` ${HtmlAttributeNames.noopenerTag}`;
+          }
+
+          if (aNode.rel.indexOf(HtmlAttributeNames.noreferrerTag) === -1) {
+            aNode.rel += ` ${HtmlAttributeNames.noreferrerTag}`;
+          }
+        }
+      } // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+      action = window.simpleUpdateIn(action, [Constants.payload, Constants.activity, Constants.text], () => htmlNode.innerHTML);
+    } catch (e) {
+      let errorMessage = "Failed to apply action: ";
+
+      try {
+        errorMessage += JSON.stringify(action);
+      } catch (e) {
+        errorMessage += " (unable to stringify action)";
+      }
+
+      TelemetryHelper.logActionEvent(LogLevel.ERROR, {
+        Event: TelemetryEvent.ProcessingHTMLTextMiddlewareFailed,
+        ExceptionDetails: {
+          ErrorData: errorMessage,
+          Exception: e
+        }
+      });
+    }
+  }
+
+  return action;
+}; // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+
+
+const htmlTextMiddleware = _ref => {
+  let {
+    dispatch
+  } = _ref;
+  return next => action => {
+    if (action.type === WebChatActionType.DIRECT_LINE_INCOMING_ACTIVITY) {
+      try {
+        var _action$payload, _action$payload$activ;
+
+        const text = (_action$payload = action.payload) === null || _action$payload === void 0 ? void 0 : (_action$payload$activ = _action$payload.activity) === null || _action$payload$activ === void 0 ? void 0 : _action$payload$activ.text;
+
+        if (text) {
+          action = processHTMLText(action, text);
+        }
+      } catch (e) {
+        let errorMessage = "Failed to validate action.";
+
+        try {
+          errorMessage += JSON.stringify(action);
+        } catch (e) {
+          errorMessage += " (unable to stringify action)";
+        }
+
+        TelemetryHelper.logActionEvent(LogLevel.ERROR, {
+          Event: TelemetryEvent.ProcessingHTMLTextMiddlewareFailed,
+          ExceptionDetails: {
+            ErrorData: errorMessage,
+            Exception: e
+          }
+        });
+      }
+    }
+
+    return next(action);
+  };
+};
+
+export default htmlTextMiddleware;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/maxMessageSizeValidator.js

@@ -0,0 +1,33 @@
+/******
+ * MaxMessageSizeValidator
+ * 
+ * Enforces a max character limit that the sender can send to comply to Omnichannel chat services' limitation.
+ ******/
+import { NotificationHandler } from "../../notification/NotificationHandler";
+import { NotificationScenarios } from "../../enums/NotificationScenarios";
+import { WebChatActionType } from "../../enums/WebChatActionType";
+import { WebChatMiddlewareConstants } from "../../../../../common/Constants"; // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+
+const createMaxMessageSizeValidator = localizedTexts => _ref => {
+  let {
+    dispatch
+  } = _ref;
+  return next => action => {
+    if (action.type === WebChatActionType.WEB_CHAT_SET_SEND_BOX) {
+      var _action$payload, _action$payload$text;
+
+      const textLength = ((_action$payload = action.payload) === null || _action$payload === void 0 ? void 0 : (_action$payload$text = _action$payload.text) === null || _action$payload$text === void 0 ? void 0 : _action$payload$text.length) || 0;
+
+      if (textLength > WebChatMiddlewareConstants.maxTextLength) {
+        NotificationHandler.notifyError(NotificationScenarios.MaxSizeError, localizedTexts.MIDDLEWARE_MAX_CHARACTER_COUNT_EXCEEDED);
+        return next(action);
+      } else {
+        NotificationHandler.dismissNotification(NotificationScenarios.MaxSizeError);
+      }
+    }
+
+    return next(action);
+  };
+};
+
+export default createMaxMessageSizeValidator;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/preProcessingMiddleware.js

@@ -0,0 +1,44 @@
+/******
+ * PreProcessingMiddleware
+ * 
+ * Adds necessary fields for the activity for the other middlewares to function as expected.
+ ******/
+import { Constants } from "../../../../../common/Constants";
+import { WebChatActionType } from "../../enums/WebChatActionType"; // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+
+const preProcessingMiddleware = _ref => {
+  let {
+    dispatch
+  } = _ref;
+  return next => async action => {
+    if (action.type === WebChatActionType.DIRECT_LINE_POST_ACTIVITY) {
+      const {
+        activity
+      } = action.payload;
+
+      if (!activity.from || activity.from.role === Constants.userMessageTag) {
+        action = { ...action,
+          payload: { ...action.payload,
+            activity: { ...action.payload.activity,
+              textFormat: Constants.markdown
+            }
+          }
+        };
+      }
+    }
+
+    if (action.type === WebChatActionType.DIRECT_LINE_INCOMING_ACTIVITY) {
+      const {
+        activity
+      } = action.payload;
+
+      if (activity) {
+        action.payload.activity[Constants.actionType] = WebChatActionType.DIRECT_LINE_INCOMING_ACTIVITY;
+      }
+    }
+
+    return next(action);
+  };
+};
+
+export default preProcessingMiddleware;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/sanitizationMiddleware.js

@@ -0,0 +1,53 @@
+/******
+ * SanitizationMiddleware
+ * 
+ * Sanitizes the text.
+ ******/
+import DOMPurify from "dompurify";
+import { LogLevel, TelemetryEvent } from "../../../../../common/telemetry/TelemetryConstants";
+import { TelemetryHelper } from "../../../../../common/telemetry/TelemetryHelper";
+import { WebChatActionType } from "../../enums/WebChatActionType"; // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+
+const sanitizationMiddleware = _ref => {
+  let {
+    dispatch
+  } = _ref;
+  return next => action => {
+    if (action.type === WebChatActionType.WEB_CHAT_SEND_MESSAGE) {
+      try {
+        var _action$payload;
+
+        let text = (_action$payload = action.payload) === null || _action$payload === void 0 ? void 0 : _action$payload.text;
+
+        if (text) {
+          text = DOMPurify.sanitize(text) ?? " ";
+        }
+      } catch (e) {
+        const copyDataForTelemetry = { ...action,
+          payload: { ...action.payload,
+            text: undefined
+          }
+        };
+        let errorMessage = "Failed to apply action: ";
+
+        try {
+          errorMessage += JSON.stringify(copyDataForTelemetry);
+        } catch (e) {
+          errorMessage += " (unable to stringify action)";
+        }
+
+        TelemetryHelper.logActionEvent(LogLevel.ERROR, {
+          Event: TelemetryEvent.ProcessingSanitizationMiddlewareFailed,
+          ExceptionDetails: {
+            ErrorData: errorMessage,
+            Exception: e
+          }
+        });
+      }
+    }
+
+    return next(action);
+  };
+};
+
+export default sanitizationMiddleware;

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/notification/NotificationHandler.js

@@ -0,0 +1,81 @@
+import { HtmlClassNames, HtmlIdNames } from "../../../../common/Constants";
+import { NotificationLevel } from "../enums/NotificationLevel";
+import { WebChatActionType } from "../enums/WebChatActionType";
+import { WebChatStoreLoader } from "../WebChatStoreLoader";
+import { setFocusOnSendBox } from "../../../../common/utils";
+export class NotificationHandler {
+  static notify(id, level, message) {
+    if (WebChatStoreLoader.store) {
+      WebChatStoreLoader.store.dispatch({
+        type: WebChatActionType.WEB_CHAT_SET_NOTIFICATION,
+        payload: {
+          id,
+          level,
+          message
+        }
+      });
+      NotificationHandler.setFocusOnNotificationCloseButton();
+    }
+  }
+
+  static dismissNotification(id) {
+    if (WebChatStoreLoader.store) {
+      WebChatStoreLoader.store.dispatch({
+        type: WebChatActionType.WEB_CHAT_DISMISS_NOTIFICATION,
+        payload: {
+          id
+        }
+      });
+    }
+  }
+
+  static notifyError(id, message) {
+    this.notify(id, NotificationLevel.Error, message);
+  }
+
+  static notifyWarning(id, message) {
+    this.notify(id, NotificationLevel.Warning, message);
+  }
+
+  static notifyInfo(id, message) {
+    this.notify(id, NotificationLevel.Info, message);
+  }
+
+  static notifySuccess(id, message) {
+    this.notify(id, NotificationLevel.Success, message);
+  }
+
+  static notifyWithLevel(id, message, level) {
+    if (!level) {
+      this.notifyInfo(id, message);
+    } else {
+      this.notify(id, level, message);
+    }
+  }
+  /* Bypass WebChat behavior and focus on banner close button */
+
+
+  static setFocusOnNotificationCloseButton() {
+    const expandButton = document.querySelector(`#${HtmlIdNames.MSLiveChatWidget} .${HtmlClassNames.webChatBannerExpandButton}`);
+
+    if (expandButton) {
+      expandButton.focus();
+      return;
+    }
+
+    const closeButton = document.querySelector(`#${HtmlIdNames.MSLiveChatWidget} .${HtmlClassNames.webChatBannerCloseButton}`);
+
+    if (closeButton) {
+      closeButton.focus();
+      NotificationHandler.registerOnCloseEvent(closeButton);
+      return;
+    }
+  }
+
+  static registerOnCloseEvent(button) {
+    button.onclick = () => {
+      setFocusOnSendBox();
+    };
+  }
+
+}

package/lib/esm/contexts/ChatAdapterStore.js

@@ -0,0 +1,3 @@
+import { createContext } from "react"; // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+
+export const ChatAdapterStore = /*#__PURE__*/createContext([undefined, adapter => {}]);

package/lib/esm/contexts/ChatContextStore.js

@@ -0,0 +1,3 @@
+import { createContext } from "react"; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+export const ChatContextStore = /*#__PURE__*/createContext(undefined);

package/lib/esm/contexts/ChatSDKStore.js

@@ -0,0 +1,3 @@
+import { createContext } from "react"; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+export const ChatSDKStore = /*#__PURE__*/createContext(undefined);

package/lib/esm/contexts/common/ConversationState.js

@@ -0,0 +1,12 @@
+export let ConversationState;
+
+(function (ConversationState) {
+  ConversationState[ConversationState["Prechat"] = 0] = "Prechat";
+  ConversationState[ConversationState["Loading"] = 1] = "Loading";
+  ConversationState[ConversationState["ReconnectChat"] = 2] = "ReconnectChat";
+  ConversationState[ConversationState["OutOfOffice"] = 3] = "OutOfOffice";
+  ConversationState[ConversationState["ProactiveChat"] = 4] = "ProactiveChat";
+  ConversationState[ConversationState["Active"] = 5] = "Active";
+  ConversationState[ConversationState["Postchat"] = 6] = "Postchat";
+  ConversationState[ConversationState["Closed"] = 7] = "Closed";
+})(ConversationState || (ConversationState = {}));

package/lib/esm/contexts/common/ILiveChatWidgetAction.js

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

package/lib/esm/contexts/common/ILiveChatWidgetContext.js

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

package/lib/esm/contexts/common/ILiveChatWidgetLocalizedTexts.js

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

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

@@ -0,0 +1,32 @@
+export let LiveChatWidgetActionType;
+
+(function (LiveChatWidgetActionType) {
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_WIDGET_ELEMENT_ID"] = 0] = "SET_WIDGET_ELEMENT_ID";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_RENDERING_MIDDLEWARE_PROPS"] = 1] = "SET_RENDERING_MIDDLEWARE_PROPS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_MIDDLEWARE_LOCALIZED_TEXTS"] = 2] = "SET_MIDDLEWARE_LOCALIZED_TEXTS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_GLOBAL_DIR"] = 3] = "SET_GLOBAL_DIR";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_MINIMIZED"] = 4] = "SET_MINIMIZED";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_CONVERSATION_STATE"] = 5] = "SET_CONVERSATION_STATE";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_PREVIOUS_FOCUSED_ELEMENT"] = 6] = "SET_PREVIOUS_FOCUSED_ELEMENT";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_OUTSIDE_OPERATING_HOURS"] = 7] = "SET_OUTSIDE_OPERATING_HOURS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_PRE_CHAT_SURVEY_RESPONSE"] = 8] = "SET_PRE_CHAT_SURVEY_RESPONSE";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_SHOW_CONFIRMATION"] = 9] = "SET_SHOW_CONFIRMATION";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_SHOW_EMAIL_TRANSCRIPT_PANE"] = 10] = "SET_SHOW_EMAIL_TRANSCRIPT_PANE";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_PRECHAT_RESPONSE_EMAIL"] = 11] = "SET_PRECHAT_RESPONSE_EMAIL";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_AUDIO_NOTIFICATION"] = 12] = "SET_AUDIO_NOTIFICATION";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_E2VV_ENABLED"] = 13] = "SET_E2VV_ENABLED";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_POST_CHAT_CONTEXT"] = 14] = "SET_POST_CHAT_CONTEXT";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_SHOULD_SHOW_POST_CHAT"] = 15] = "SET_SHOULD_SHOW_POST_CHAT";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SHOW_CALLING_CONTAINER"] = 16] = "SHOW_CALLING_CONTAINER";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_INCOMING_CALL"] = 17] = "SET_INCOMING_CALL";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["DISABLE_VIDEO_CALL"] = 18] = "DISABLE_VIDEO_CALL";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["DISABLE_LOCAL_VIDEO"] = 19] = "DISABLE_LOCAL_VIDEO";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["DISABLE_REMOTE_VIDEO"] = 20] = "DISABLE_REMOTE_VIDEO";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_CHAT_TOKEN"] = 21] = "SET_CHAT_TOKEN";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_SKIP_CHAT_BUTTON_RENDERING"] = 22] = "SET_SKIP_CHAT_BUTTON_RENDERING";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_PROACTIVE_CHAT_PARAMS"] = 23] = "SET_PROACTIVE_CHAT_PARAMS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_TELEMETRY_DATA"] = 24] = "SET_TELEMETRY_DATA";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_RECONNECT_ID"] = 25] = "SET_RECONNECT_ID";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_UNREAD_MESSAGE_COUNT"] = 26] = "SET_UNREAD_MESSAGE_COUNT";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_FOCUS_CHAT_BUTTON"] = 27] = "SET_FOCUS_CHAT_BUTTON";
+})(LiveChatWidgetActionType || (LiveChatWidgetActionType = {}));

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

@@ -0,0 +1,49 @@
+import { ConversationState } from "./ConversationState";
+import { defaultMiddlewareLocalizedTexts } from "../../components/webchatcontainerstateful/common/defaultProps/defaultMiddlewareLocalizedTexts";
+export const getLiveChatWidgetContextInitialState = props => {
+  var _props$webChatContain;
+
+  const LiveChatWidgetContextInitialState = {
+    domainStates: {
+      liveChatConfig: props.chatConfig,
+      widgetElementId: "",
+      renderingMiddlewareProps: (_props$webChatContain = props.webChatContainerProps) === null || _props$webChatContain === void 0 ? void 0 : _props$webChatContain.renderingMiddlewareProps,
+      middlewareLocalizedTexts: defaultMiddlewareLocalizedTexts,
+      preChatSurveyResponse: "{}",
+      chatToken: undefined,
+      postChatContext: undefined,
+      telemetryInternalData: {},
+      globalDir: "ltr"
+    },
+    appStates: {
+      conversationState: ConversationState.Closed,
+      isMinimized: false,
+      previousElementOnFocusBeforeModalOpen: null,
+      outsideOperatingHours: false,
+      shouldShowPostChat: false,
+      preChatResponseEmail: "",
+      isAudioMuted: null,
+      newMessage: false,
+      skipChatButtonRendering: false,
+      reconnectId: undefined,
+      proactiveChatStates: {
+        proactiveChatBodyTitle: "",
+        proactiveChatEnablePrechat: false,
+        proactiveChatInNewWindow: false
+      },
+      e2vvEnabled: false,
+      unreadMessageCount: 0
+    },
+    uiStates: {
+      showConfirmationPane: false,
+      showEmailTranscriptPane: false,
+      showCallingPopup: false,
+      isIncomingCall: true,
+      disableVideoCall: true,
+      disableRemoteVideo: true,
+      disableSelfVideo: true,
+      focusChatButton: false
+    }
+  };
+  return props.liveChatContextFromCache ?? LiveChatWidgetContextInitialState;
+};

package/lib/esm/contexts/createReducer.js

@@ -0,0 +1,217 @@
+/* eslint-disable indent */
+import { LiveChatWidgetActionType } from "./common/LiveChatWidgetActionType";
+import { TelemetryManager } from "../common/telemetry/TelemetryManager";
+export const createReducer = () => {
+  const reducer = (state, action) => {
+    var _action$payload, _action$payload2, _action$payload3;
+
+    switch (action.type) {
+      case LiveChatWidgetActionType.SET_WIDGET_ELEMENT_ID:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            widgetElementId: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_RENDERING_MIDDLEWARE_PROPS:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            renderingMiddlewareProps: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_MIDDLEWARE_LOCALIZED_TEXTS:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            middlewareLocalizedTexts: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_GLOBAL_DIR:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            globalDir: action.payload === "ltr" || action.payload === "rtl" ? action.payload : "ltr"
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_MINIMIZED:
+        return { ...state,
+          appStates: { ...state.appStates,
+            isMinimized: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_CONVERSATION_STATE:
+        return { ...state,
+          appStates: { ...state.appStates,
+            conversationState: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_OUTSIDE_OPERATING_HOURS:
+        return { ...state,
+          appStates: { ...state.appStates,
+            outsideOperatingHours: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_PRE_CHAT_SURVEY_RESPONSE:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            preChatSurveyResponse: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_PREVIOUS_FOCUSED_ELEMENT:
+        return { ...state,
+          appStates: { ...state.appStates,
+            previousElementOnFocusBeforeModalOpen: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_SHOW_CONFIRMATION:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            showConfirmationPane: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_POST_CHAT_CONTEXT:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            postChatContext: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_SHOULD_SHOW_POST_CHAT:
+        return { ...state,
+          appStates: { ...state.appStates,
+            shouldShowPostChat: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SHOW_CALLING_CONTAINER:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            showCallingPopup: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_INCOMING_CALL:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            isIncomingCall: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_FOCUS_CHAT_BUTTON:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            focusChatButton: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.DISABLE_VIDEO_CALL:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            disableVideoCall: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.DISABLE_LOCAL_VIDEO:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            disableSelfVideo: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.DISABLE_REMOTE_VIDEO:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            disableRemoteVideo: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_CHAT_TOKEN:
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            chatToken: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_SHOW_EMAIL_TRANSCRIPT_PANE:
+        return { ...state,
+          uiStates: { ...state.uiStates,
+            showEmailTranscriptPane: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_PRECHAT_RESPONSE_EMAIL:
+        return { ...state,
+          appStates: { ...state.appStates,
+            preChatResponseEmail: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_AUDIO_NOTIFICATION:
+        return { ...state,
+          appStates: { ...state.appStates,
+            isAudioMuted: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_E2VV_ENABLED:
+        return { ...state,
+          appStates: { ...state.appStates,
+            e2vvEnabled: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_SKIP_CHAT_BUTTON_RENDERING:
+        return { ...state,
+          appStates: { ...state.appStates,
+            skipChatButtonRendering: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_PROACTIVE_CHAT_PARAMS:
+        return { ...state,
+          appStates: { ...state.appStates,
+            proactiveChatStates: { ...state.appStates.proactiveChatStates,
+              proactiveChatBodyTitle: (_action$payload = action.payload) === null || _action$payload === void 0 ? void 0 : _action$payload.proactiveChatBodyTitle,
+              proactiveChatEnablePrechat: (_action$payload2 = action.payload) === null || _action$payload2 === void 0 ? void 0 : _action$payload2.proactiveChatEnablePrechat,
+              proactiveChatInNewWindow: (_action$payload3 = action.payload) === null || _action$payload3 === void 0 ? void 0 : _action$payload3.proactiveChatInNewWindow
+            }
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_TELEMETRY_DATA:
+        TelemetryManager.InternalTelemetryData = action.payload;
+        return { ...state,
+          domainStates: { ...state.domainStates,
+            telemetryInternalData: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_RECONNECT_ID:
+        return { ...state,
+          appStates: { ...state.appStates,
+            reconnectId: action.payload
+          }
+        };
+
+      case LiveChatWidgetActionType.SET_UNREAD_MESSAGE_COUNT:
+        return { ...state,
+          appStates: { ...state.appStates,
+            unreadMessageCount: action.payload
+          }
+        };
+
+      default:
+        return state;
+    }
+  };
+
+  return reducer;
+};