@microsoft/omnichannel-chat-widget 0.1.0-main.01a30be

package/lib/esm/components/livechatwidget/LiveChatWidget.js

@@ -0,0 +1,21 @@
+import React, { useReducer, useState } from "react";
+import { ChatAdapterStore } from "../../contexts/ChatAdapterStore";
+import { ChatContextStore } from "../../contexts/ChatContextStore";
+import { ChatSDKStore } from "../../contexts/ChatSDKStore";
+import LiveChatWidgetStateful from "./livechatwidgetstateful/LiveChatWidgetStateful";
+import { createReducer } from "../../contexts/createReducer";
+import { getLiveChatWidgetContextInitialState } from "../../contexts/common/LiveChatWidgetContextInitialState";
+export const LiveChatWidget = props => {
+  const reducer = createReducer();
+  const [state, dispatch] = useReducer(reducer, getLiveChatWidgetContextInitialState(props));
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const [adapter, setAdapter] = useState(undefined);
+  return /*#__PURE__*/React.createElement(ChatSDKStore.Provider, {
+    value: props.chatSDK
+  }, /*#__PURE__*/React.createElement(ChatAdapterStore.Provider, {
+    value: [adapter, setAdapter]
+  }, /*#__PURE__*/React.createElement(ChatContextStore.Provider, {
+    value: [state, dispatch]
+  }, /*#__PURE__*/React.createElement(LiveChatWidgetStateful, props))));
+};
+export default LiveChatWidget;

package/lib/esm/components/livechatwidget/common/ActivityStreamHandler.js

@@ -0,0 +1,32 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { Deferred } from "./Deferred";
+export class ActivityStreamHandler {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  /**
+   * Use of a deferred pattern, to hold the execution of the activity.
+   * 
+   * */
+  static cork() {
+    ActivityStreamHandler.restoreDeferred = new Deferred();
+    ActivityStreamHandler.restorePromise = ActivityStreamHandler.restoreDeferred.promise;
+  }
+
+  /**
+   * Resolve the promise, releasing it to continue with the execution of the activity.
+   * 
+   * */
+  static uncork() {
+    ActivityStreamHandler.restoreDeferred.resolve();
+  }
+}
+_defineProperty(ActivityStreamHandler, "restoreDeferred", {
+  resolve: () => {
+    return "initialState";
+  }
+});
+_defineProperty(ActivityStreamHandler, "restorePromise", void 0);

package/lib/esm/components/livechatwidget/common/ActivitySubscriber/BotAuthActivitySubscriber.js

@@ -0,0 +1,134 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BroadcastService } from "@microsoft/omnichannel-chat-components";
+import { BroadcastEvent, LogLevel, TelemetryEvent } from "../../../../common/telemetry/TelemetryConstants";
+import { TelemetryHelper } from "../../../../common/telemetry/TelemetryHelper";
+const supportedSignInCardContentTypes = ["application/vnd.microsoft.card.signin", "application/vnd.microsoft.card.oauth"];
+const botOauthUrlRegex = /[\S]+.botframework.com\/api\/oauth\/signin\?signin=([\S]+)/;
+const delay = t => new Promise(resolve => setTimeout(resolve, t));
+const fetchBotAuthConfigRetries = 3;
+const fetchBotAuthConfigRetryInterval = 1000;
+let response;
+const extractSignInId = signInUrl => {
+  const result = botOauthUrlRegex.exec(signInUrl);
+  if (result && result[1]) {
+    return result[1];
+  }
+  return "";
+};
+const extractSasUrl = async attachment => {
+  let sasUrl = undefined;
+  if (attachment && attachment.content && attachment.content.tokenPostResource && attachment.content.tokenPostResource.sasUrl) {
+    sasUrl = attachment.content.tokenPostResource.sasUrl;
+  }
+  if (!sasUrl) {
+    const signInId = extractSignInId(attachment.content.buttons[0].value);
+    const getTestUrlEndpoint = `https://token.botframework.com/api/sas/gettesturl?signInId=${signInId}`;
+    try {
+      const response = await window.fetch(getTestUrlEndpoint);
+      if (response.status === 200) {
+        const responseJson = await response.json();
+        sasUrl = responseJson.sasUrl;
+      }
+    } catch {
+      sasUrl = undefined;
+    }
+  }
+  return sasUrl;
+};
+const fetchBotAuthConfig = async retries => {
+  TelemetryHelper.logLoadingEvent(LogLevel.INFO, {
+    Event: TelemetryEvent.SetBotAuthProviderFetchConfig
+  });
+  const botAuthConfigRequestEvent = {
+    eventName: BroadcastEvent.BotAuthConfigRequest
+  };
+  BroadcastService.postMessage(botAuthConfigRequestEvent);
+  const listener = BroadcastService.getMessageByEventName(BroadcastEvent.BotAuthConfigResponse).subscribe(data => {
+    var _data$payload, _data$payload2;
+    response = ((_data$payload = data.payload) === null || _data$payload === void 0 ? void 0 : _data$payload.response) !== undefined ? (_data$payload2 = data.payload) === null || _data$payload2 === void 0 ? void 0 : _data$payload2.response : response;
+    listener.unsubscribe();
+  });
+  if (response !== undefined) {
+    //return response;
+    return response;
+  }
+  if (retries === 1) {
+    // Base Case
+    throw new Error();
+  }
+  await delay(fetchBotAuthConfigRetryInterval);
+  return await fetchBotAuthConfig(--retries);
+};
+export class BotAuthActivitySubscriber {
+  constructor() {
+    _defineProperty(this, "observer", void 0);
+    _defineProperty(this, "signInCardSeen", void 0);
+    this.signInCardSeen = new Set();
+  }
+  applicable(activity) {
+    var _activity$attachments;
+    return (activity === null || activity === void 0 ? void 0 : (_activity$attachments = activity.attachments) === null || _activity$attachments === void 0 ? void 0 : _activity$attachments.length) > 0 && activity.attachments[0] && supportedSignInCardContentTypes.indexOf(activity.attachments[0].contentType) >= 0;
+  }
+  async apply(activity) {
+    this.observer.next(false); // Hides card
+    const attachment = activity.attachments[0];
+    const signInUrl = attachment.content.buttons[0].value;
+    const signInId = extractSignInId(signInUrl);
+    if (!signInId) {
+      return;
+    }
+    if (this.signInCardSeen.has(signInId)) {
+      // Prevents duplicate auth
+      return;
+    }
+    this.signInCardSeen.add(signInId);
+    const sasUrl = await extractSasUrl(attachment);
+    const event = {
+      eventName: BroadcastEvent.SigninCardReceived,
+      payload: {
+        sasUrl
+      }
+    };
+    if (!sasUrl) {
+      TelemetryHelper.logLoadingEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.BotAuthActivityEmptySasUrl,
+        Description: "SaS Url is empty"
+      });
+      return activity;
+    } else {
+      BroadcastService.postMessage(event);
+    }
+    try {
+      const response = await fetchBotAuthConfig(fetchBotAuthConfigRetries);
+      if (response === false) {
+        TelemetryHelper.logLoadingEvent(LogLevel.INFO, {
+          Event: TelemetryEvent.SetBotAuthProviderHideCard
+        });
+      } else {
+        TelemetryHelper.logLoadingEvent(LogLevel.INFO, {
+          Event: TelemetryEvent.SetBotAuthProviderDisplayCard
+        });
+        return activity;
+      }
+    } catch {
+      TelemetryHelper.logLoadingEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.SetBotAuthProviderNotFound
+      });
+      //this is to ensure listener continues waiting for response
+      if (this.signInCardSeen.has(signInId)) {
+        this.signInCardSeen.delete(signInId);
+      }
+      return activity;
+    }
+  }
+  async next(activity) {
+    if (this.applicable(activity)) {
+      return await this.apply(activity);
+    }
+    return activity;
+  }
+}

package/lib/esm/components/livechatwidget/common/ActivitySubscriber/DefaultActivitySubscriber.js

@@ -0,0 +1,13 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+export class DefaultActivitySubscriber {
+  constructor() {
+    _defineProperty(this, "observer", void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async next(activity) {
+    this.observer.next(activity);
+    return false;
+  }
+}

package/lib/esm/components/livechatwidget/common/ActivitySubscriber/IActivitySubscriber.js

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

package/lib/esm/components/livechatwidget/common/ActivitySubscriber/PauseActivitySubscriber.js

@@ -0,0 +1,27 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { ActivityStreamHandler } from "../ActivityStreamHandler";
+export class PauseActivitySubscriber {
+  constructor() {
+    _defineProperty(this, "observer", void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async apply(activity) {
+    await ActivityStreamHandler.restorePromise;
+    return activity;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  applicable(activity) {
+    return true;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async next(activity) {
+    if (this.applicable(activity)) {
+      return await this.apply(activity);
+    }
+    return activity;
+  }
+}

package/lib/esm/components/livechatwidget/common/ChatAdapterShim.js

@@ -0,0 +1,57 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { DefaultActivitySubscriber } from "./ActivitySubscriber/DefaultActivitySubscriber";
+import { shareObservable } from "./shareObservable";
+export class ChatAdapterShim {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(chatAdapter) {
+    _defineProperty(this, "chatAdapter", void 0);
+    _defineProperty(this, "activityObserver", void 0);
+    _defineProperty(this, "subscribers", void 0);
+    this.subscribers = [];
+    this.chatAdapter = {
+      ...chatAdapter,
+      activity$: shareObservable(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      new window.Observable(observer => {
+        this.activityObserver = observer;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const abortController = new window.AbortController();
+        (async () => {
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for await (let activity of chatAdapter.activities({
+              signal: abortController.signal
+            })) {
+              for (const subscriber of [...this.subscribers, new DefaultActivitySubscriber()]) {
+                subscriber.observer = this.activityObserver;
+                activity = await subscriber.next(activity);
+                if (!activity) {
+                  break;
+                }
+              }
+            }
+            observer.complete();
+          } catch (error) {
+            observer.error(error);
+          }
+        })();
+        return () => {
+          abortController.abort();
+        };
+      }))
+    };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  addSubscriber(subscriber) {
+    this.subscribers.push(subscriber);
+  }
+}

package/lib/esm/components/livechatwidget/common/Deferred.js

@@ -0,0 +1,30 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+export class Deferred {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  constructor() {
+    _defineProperty(this, "_promise", void 0);
+    _defineProperty(this, "_resolve", void 0);
+    _defineProperty(this, "_reject", () => {
+      return;
+    });
+    _defineProperty(this, "resolve", value => {
+      this._resolve(value);
+    });
+    _defineProperty(this, "reject", value => {
+      this._reject(value);
+    });
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  get promise() {
+    return this._promise;
+  }
+}

package/lib/esm/components/livechatwidget/common/agentEndConversationHelper.js

@@ -0,0 +1,30 @@
+import { LogLevel, TelemetryEvent } from "../../../common/telemetry/TelemetryConstants";
+import { TelemetryHelper } from "../../../common/telemetry/TelemetryHelper";
+import { ConversationEndEntity } from "../../../contexts/common/ConversationEndEntity";
+import { LiveChatWidgetActionType } from "../../../contexts/common/LiveChatWidgetActionType";
+import { checkPostChatEnabled } from "./setPostChatContextAndLoadSurvey";
+const handleAgentEndConversation = (props, state, dispatch) => {
+  const isPostChatEnabled = checkPostChatEnabled(props, state);
+  if (isPostChatEnabled) {
+    if (!state.appStates.postChatWorkflowInProgress) {
+      dispatch({
+        type: LiveChatWidgetActionType.SET_CONVERSATION_ENDED_BY,
+        payload: ConversationEndEntity.Agent
+      });
+      TelemetryHelper.logActionEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.ConversationEndedByAgent,
+        Description: "Conversation is ended from agent side"
+      });
+    }
+  } else {
+    dispatch({
+      type: LiveChatWidgetActionType.SET_CONVERSATION_ENDED_BY,
+      payload: ConversationEndEntity.Agent
+    });
+    TelemetryHelper.logActionEvent(LogLevel.INFO, {
+      Event: TelemetryEvent.ConversationEndedByAgent,
+      Description: "Conversation is ended from agent side"
+    });
+  }
+};
+export { handleAgentEndConversation };

package/lib/esm/components/livechatwidget/common/authHelper.js

@@ -0,0 +1,42 @@
+import { LogLevel, TelemetryEvent } from "../../../common/telemetry/TelemetryConstants";
+import { TelemetryHelper } from "../../../common/telemetry/TelemetryHelper";
+import { isNullOrEmptyString } from "../../../common/utils";
+const getAuthClientFunction = chatConfig => {
+  let authClientFunction = undefined;
+  if (chatConfig !== null && chatConfig !== void 0 && chatConfig.LiveChatConfigAuthSettings) {
+    var _chatConfig$LiveChatC;
+    authClientFunction = (chatConfig === null || chatConfig === void 0 ? void 0 : (_chatConfig$LiveChatC = chatConfig.LiveChatConfigAuthSettings) === null || _chatConfig$LiveChatC === void 0 ? void 0 : _chatConfig$LiveChatC.msdyn_javascriptclientfunction) ?? undefined;
+  }
+  return authClientFunction;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const handleAuthentication = async (chatSDK, chatConfig, getAuthToken) => {
+  const authClientFunction = getAuthClientFunction(chatConfig);
+  if (getAuthToken && authClientFunction) {
+    TelemetryHelper.logActionEvent(LogLevel.INFO, {
+      Event: TelemetryEvent.GetAuthTokenCalled
+    });
+    const token = await getAuthToken(authClientFunction);
+    if (!isNullOrEmptyString(token)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      chatSDK.setAuthTokenProvider(async () => {
+        return token;
+      });
+      return true;
+    } else {
+      TelemetryHelper.logActionEvent(LogLevel.ERROR, {
+        Event: TelemetryEvent.ReceivedNullOrEmptyToken
+      });
+      return false;
+    }
+  }
+  return false;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const removeAuthTokenProvider = chatSDK => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  chatSDK.authenticatedUserToken = null;
+};
+export { getAuthClientFunction, handleAuthentication, removeAuthTokenProvider };

package/lib/esm/components/livechatwidget/common/createAdapter.js

@@ -0,0 +1,37 @@
+import { NotificationHandler } from "../../webchatcontainerstateful/webchatcontroller/notification/NotificationHandler";
+import { NotificationLevel } from "../../webchatcontainerstateful/webchatcontroller/enums/NotificationLevel";
+import { NotificationScenarios } from "../../webchatcontainerstateful/webchatcontroller/enums/NotificationScenarios";
+import { defaultMiddlewareLocalizedTexts } from "../../webchatcontainerstateful/common/defaultProps/defaultMiddlewareLocalizedTexts";
+import { ChatAdapterShim } from "./ChatAdapterShim";
+import { PauseActivitySubscriber } from "./ActivitySubscriber/PauseActivitySubscriber";
+import { BotAuthActivitySubscriber } from "./ActivitySubscriber/BotAuthActivitySubscriber";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const createAdapter = async chatSDK => {
+  const chatAdapterOptionalParams = {
+    IC3Adapter: {
+      options: {
+        callbackOnNotification: notification => {
+          if (notification.id === NotificationScenarios.InternetConnection && notification.level == NotificationLevel.Error) {
+            notification.message = defaultMiddlewareLocalizedTexts.MIDDLEWARE_BANNER_NO_INTERNET_CONNECTION;
+          }
+          if (notification.id === NotificationScenarios.InternetConnection && notification.level == NotificationLevel.Success) {
+            notification.message = defaultMiddlewareLocalizedTexts.MIDDLEWARE_BANNER_INTERNET_BACK_ONLINE;
+          }
+          if (notification.id && notification.message) {
+            NotificationHandler.notifyWithLevel(notification.id, notification.message, notification.level);
+          }
+        }
+      }
+    }
+  };
+  let adapter = await chatSDK.createChatAdapter(chatAdapterOptionalParams);
+  //so far, there is no need to convert to the shim adapter when using visual tests
+  if (chatSDK.isMockModeOn !== true) {
+    adapter = new ChatAdapterShim(adapter);
+    adapter.addSubscriber(new PauseActivitySubscriber());
+    adapter.addSubscriber(new BotAuthActivitySubscriber());
+    return adapter.chatAdapter;
+  }
+  return adapter;
+};

package/lib/esm/components/livechatwidget/common/createFooter.js

@@ -0,0 +1,15 @@
+import FooterStateful from "../../footerstateful/FooterStateful";
+import React from "react";
+import { decodeComponentString } from "@microsoft/omnichannel-chat-components";
+import { shouldShowFooter } from "../../../controller/componentController";
+export const createFooter = (props, state) => {
+  var _props$controlProps, _props$componentOverr;
+  const hideFooterDisplay = !((_props$controlProps = props.controlProps) !== null && _props$controlProps !== void 0 && _props$controlProps.hideFooter) && shouldShowFooter(state) ? false : true;
+  const footer = decodeComponentString((_props$componentOverr = props.componentOverrides) === null || _props$componentOverr === void 0 ? void 0 : _props$componentOverr.footer) || /*#__PURE__*/React.createElement(FooterStateful, {
+    footerProps: props.footerProps,
+    downloadTranscriptProps: props.downloadTranscriptProps,
+    audioNotificationProps: props.audioNotificationProps,
+    hideFooterDisplay: hideFooterDisplay
+  });
+  return footer;
+};

package/lib/esm/components/livechatwidget/common/createInternetConnectionChangeHandler.js

@@ -0,0 +1,35 @@
+import { Constants } from "../../../common/Constants";
+import { NotificationHandler } from "../../webchatcontainerstateful/webchatcontroller/notification/NotificationHandler";
+import { NotificationScenarios } from "../../webchatcontainerstateful/webchatcontroller/enums/NotificationScenarios";
+import { defaultMiddlewareLocalizedTexts } from "../../webchatcontainerstateful/common/defaultProps/defaultMiddlewareLocalizedTexts";
+import { TelemetryHelper } from "../../../common/telemetry/TelemetryHelper";
+import { LogLevel, TelemetryEvent } from "../../../common/telemetry/TelemetryConstants";
+const isInternetConnected = async () => {
+  try {
+    const response = await fetch(Constants.internetConnectionTestUrl);
+    const text = await response.text();
+    return text === Constants.internetConnectionTestUrlText;
+  } catch {
+    return false;
+  }
+};
+export const createInternetConnectionChangeHandler = async () => {
+  const handler = async () => {
+    const connected = await isInternetConnected();
+    if (!connected) {
+      TelemetryHelper.logActionEvent(LogLevel.WARN, {
+        Event: TelemetryEvent.NetworkDisconnected
+      });
+      NotificationHandler.notifyError(NotificationScenarios.InternetConnection, defaultMiddlewareLocalizedTexts.MIDDLEWARE_BANNER_NO_INTERNET_CONNECTION);
+    } else {
+      TelemetryHelper.logActionEvent(LogLevel.WARN, {
+        Event: TelemetryEvent.NetworkReconnected
+      });
+      NotificationHandler.notifySuccess(NotificationScenarios.InternetConnection, defaultMiddlewareLocalizedTexts.MIDDLEWARE_BANNER_INTERNET_BACK_ONLINE);
+    }
+  };
+
+  // Checking connection status on online & offline events due to possible false positives
+  window.addEventListener("online", () => handler(), false);
+  window.addEventListener("offline", () => handler(), false);
+};

package/lib/esm/components/livechatwidget/common/createMarkdown.js

@@ -0,0 +1,62 @@
+import MarkdownIt from "markdown-it";
+import MarkdownItForInline from "markdown-it-for-inline";
+import { defaultMarkdownLocalizedTexts } from "../../webchatcontainerstateful/common/defaultProps/defaultMarkdownLocalizedTexts";
+import { Constants } from "../../../common/Constants";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const createMarkdown = (disableMarkdownMessageFormatting, disableNewLineMarkdownSupport) => {
+  let markdown;
+  if (!disableMarkdownMessageFormatting) {
+    markdown = new MarkdownIt(Constants.Default, {
+      html: true,
+      linkify: true,
+      breaks: !disableNewLineMarkdownSupport
+    });
+    // ToDo: Commenting below usage of plugin until deferred bug is resolved: https://github.com/mayashavin/markdown-it-slack/issues/1
+    // markdown.use(MarkdownSlack);
+  } else {
+    markdown = new MarkdownIt(Constants.Zero, {
+      html: true,
+      linkify: true,
+      breaks: !disableNewLineMarkdownSupport
+    });
+    markdown.enable(["entity",
+    // Rule to process html entity - {, ¯, "
+    "linkify",
+    // Rule to replace link-like texts with link nodes
+    "html_block",
+    // Rule to process html blocks and paragraphs
+    "html_inline",
+    // Rule to process html tags
+    "newline" // Rule to proceess '\n'
+    ]);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  markdown.use(MarkdownItForInline, "url_new_win", "link_open", function (tokens, idx, env) {
+    const targetAttrIndex = tokens[idx].attrIndex(Constants.Target);
+    // Put a transparent pixel instead of the "open in new window" icon, so developers can easily modify the icon in CSS.
+    const TRANSPARENT_GIF = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+    if (~targetAttrIndex) {
+      tokens[idx].attrs[targetAttrIndex][1] = Constants.Blank;
+    } else {
+      tokens[idx].attrPush([Constants.Target, Constants.Blank]);
+    }
+    const relAttrIndex = tokens[idx].attrIndex(Constants.TargetRelationship);
+    if (~relAttrIndex) {
+      tokens[idx].attrs[relAttrIndex][1] = Constants.TargetRelationshipAttributes;
+    } else {
+      tokens[idx].attrPush([Constants.TargetRelationship, Constants.TargetRelationshipAttributes]);
+      if (!disableMarkdownMessageFormatting) {
+        tokens[idx].attrPush([Constants.Title, defaultMarkdownLocalizedTexts.MARKDOWN_EXTERNAL_LINK_ALT]);
+        // eslint-disable-next-line quotes
+        const iconTokens = markdown.parseInline(`![${defaultMarkdownLocalizedTexts.MARKDOWN_EXTERNAL_LINK_ALT}](${TRANSPARENT_GIF})`, env)[0].children;
+        if (iconTokens && iconTokens.length > 0) {
+          iconTokens[0].attrJoin("class", Constants.OpenLinkIconCssClass);
+          tokens.splice(idx + 2, 0, ...iconTokens);
+        }
+      }
+    }
+  });
+  return markdown;
+};

package/lib/esm/components/livechatwidget/common/defaultProps/defaultScrollBarProps.js

@@ -0,0 +1,7 @@
+export const defaultScrollBarProps = {
+  width: "7px",
+  trackBackgroundColor: "#f1f1f1",
+  thumbBackgroundColor: "#888",
+  thumbBorderRadius: "10px",
+  thumbHoverColor: "#555"
+};