@microsoft/omnichannel-chat-widget 1.8.3 → 1.8.4-main.21aec08

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

@@ -0,0 +1,159 @@
+/**
+ * SecureEventBus class implementing the singleton pattern for secure event communication.
+ * Provides authentication-based event dispatching to prevent unauthorized external access.
+ */
+declare class SecureEventBus {
+    private static instance;
+    private listeners;
+    private readonly authToken;
+    private eventCounter;
+    /**
+     * Private constructor to enforce singleton pattern.
+     * Generates a unique authentication token for this session.
+     */
+    private constructor();
+    /**
+     * Get the singleton instance of SecureEventBus.
+     * Creates a new instance if one doesn't exist.
+     *
+     * @returns The singleton instance of SecureEventBus
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     * ```
+     */
+    static getInstance(): SecureEventBus;
+    /**
+     * Generate a cryptographically secure authentication token.
+     * Uses crypto.getRandomValues when available, falls back to Math.random.
+     *
+     * @private
+     * @returns A 64-character hexadecimal string representing the authentication token
+     */
+    private generateAuthToken;
+    /**
+     * Get the authentication token for this SecureEventBus instance.
+     * This token is required for dispatching events and should only be used internally.
+     *
+     * @returns The authentication token string
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     * const token = eventBus.getAuthToken();
+     * eventBus.dispatch('myEvent', { data: 'value' }, token);
+     * ```
+     */
+    getAuthToken(): string;
+    /**
+     * Dispatch an event with authentication to all registered listeners.
+     * Verifies the authentication token before dispatching to prevent unauthorized access.
+     *
+     * @param eventName - The name of the event to dispatch
+     * @param payload - The data to send with the event (optional)
+     * @param token - Authentication token (must match the internal token)
+     * @returns true if event was successfully dispatched, false if unauthorized or error occurred
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     * const token = eventBus.getAuthToken();
+     *
+     * // Dispatch with payload
+     * const success = eventBus.dispatch('userAction', { action: 'click', target: 'button' }, token);
+     *
+     * // Dispatch without payload
+     * eventBus.dispatch('windowClosed', undefined, token);
+     * ```
+     */
+    dispatch(eventName: string, payload?: any, token?: string): boolean;
+    /**
+     * Subscribe to an event with a callback function.
+     * The callback will be executed whenever the specified event is dispatched.
+     *
+     * @param eventName - The name of the event to listen for
+     * @param callback - The function to execute when the event is fired
+     * @returns A function that can be called to unsubscribe from the event
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     *
+     * // Subscribe to an event
+     * const unsubscribe = eventBus.subscribe('chatMessage', (message) => {
+     *   console.log('New message:', message.text);
+     *   console.log('From user:', message.userId);
+     * });
+     *
+     * // Later, unsubscribe
+     * unsubscribe();
+     * ```
+     */
+    subscribe(eventName: string, callback: (payload: any) => void): () => void;
+    /**
+     * Remove all listeners for a specific event.
+     * This completely removes the event from the internal listeners map.
+     *
+     * @param eventName - The name of the event to remove all listeners for
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     *
+     * // Remove all listeners for 'chatClosed' event
+     * eventBus.removeAllListeners('chatClosed');
+     * ```
+     */
+    removeAllListeners(eventName: string): void;
+    /**
+     * Clear all listeners for all events.
+     * This resets the entire event bus to its initial state.
+     * Useful for cleanup during application shutdown or testing.
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     *
+     * // Clear all event listeners
+     * eventBus.clear();
+     * ```
+     */
+    clear(): void;
+    /**
+     * Get the number of listeners for a specific event.
+     * Useful for debugging and monitoring purposes.
+     *
+     * @param eventName - The name of the event to count listeners for
+     * @returns The number of listeners registered for the event
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     *
+     * // Check how many listeners are registered for 'userAction'
+     * const count = eventBus.getListenerCount('userAction');
+     * console.log(`${count} listeners registered for userAction`);
+     * ```
+     */
+    getListenerCount(eventName: string): number;
+    /**
+     * Get all registered event names.
+     * Returns an array of event names that currently have listeners.
+     * Useful for debugging and monitoring purposes.
+     *
+     * @returns An array of event names that have registered listeners
+     *
+     * @example
+     * ```typescript
+     * const eventBus = SecureEventBus.getInstance();
+     *
+     * // Get all registered events
+     * const events = eventBus.getRegisteredEvents();
+     * console.log('Active events:', events);
+     * // Output: ['userAction', 'chatMessage', 'windowResize']
+     * ```
+     */
+    getRegisteredEvents(): string[];
+}
+export default SecureEventBus;

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

@@ -0,0 +1,2 @@
+declare const dispatchCustomEvent: (name: string, payload?: any) => void;
+export default dispatchCustomEvent;

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

@@ -1,6 +1,6 @@
+import * as CustomEventType from "../contexts/common/CustomEventType";
 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;
@@ -55,3 +55,11 @@ export declare function isEndConversationDueToOverflowActivity(activity: {
         tags?: string[];
     };
 }): boolean | undefined;
+/**
+ * Parses a value that can be boolean or string ("true"/"false") into a boolean.
+ * Handles null/undefined by returning false.
+ *
+ * @param value - The value to parse (can be boolean, string, null, or undefined)
+ * @returns true if value is true or "true" (case-insensitive), false otherwise
+ */
+export declare function parseBooleanFromConfig(value: boolean | string | null | undefined): boolean;

package/lib/types/components/livechatwidget/common/ActivitySubscriber/AddActivitySubscriber.d.ts

@@ -0,0 +1,45 @@
+import { IActivitySubscriber } from "./IActivitySubscriber";
+/**
+ * The `AddActivitySubscriber` class is responsible for subscribing to the `ADD_ACTIVITY` event
+ * from the `ChatWidgetEvents` and notifying an observer when a new activity is added.
+ *
+ * This class implements the `IActivitySubscriber` interface and acts as a bridge between
+ * the event system and the observer pattern.
+ */
+export declare class AddActivitySubscriber implements IActivitySubscriber {
+    /**
+     * The observer that will be notified when a new activity is added.
+     * This is expected to be an object with a `next` method, such as an RxJS `Observer`.
+     */
+    observer: any;
+    /**
+     * Set to track processed activity IDs to prevent duplicate processing.
+     */
+    private processedActivityIds;
+    /**
+     * Unsubscribe function for the secure event listener
+     */
+    private unsubscribeFromSecureEvent;
+    /**
+     * Subscription for PersistentConversationReset event
+     */
+    private resetEventListener;
+    /**
+     * Constructor initializes the `AddActivitySubscriber` and sets up a secure event listener
+     * for the `ChatWidgetEvents.ADD_ACTIVITY` event. When the event is triggered, it checks
+     * if the event payload contains an `activity` and notifies the observer.
+     */
+    constructor();
+    /**
+     * The `next` method is a placeholder for processing the activity.
+     * This method can be overridden or extended as needed.
+     *
+     * @param activity - The activity object to process.
+     * @returns The activity object (asynchronously).
+     */
+    next(activity: any): Promise<any>;
+    /**
+     * Reset the processed activity IDs when a conversation resets
+     */
+    reset(): void;
+}

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

@@ -0,0 +1,7 @@
+declare enum ChatWidgetEvents {
+    ADD_ACTIVITY = "CHAT_WIDGET/ADD_ACTIVITY",
+    FETCH_PERSISTENT_CHAT_HISTORY = "CHAT_WIDGET/FETCH_PERSISTENT_CHAT_HISTORY",
+    NO_MORE_HISTORY_AVAILABLE = "CHAT_WIDGET/NO_MORE_HISTORY_AVAILABLE",
+    HISTORY_LOAD_ERROR = "CHAT_WIDGET/HISTORY_LOAD_ERROR"
+}
+export default ChatWidgetEvents;

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

@@ -0,0 +1,28 @@
+import { FacadeChatSDK } from "../../../common/facades/FacadeChatSDK";
+import { IPersistentChatHistoryProps } from "../interfaces/IPersistentChatHistoryProps";
+/**
+ * Class responsible for handling persistent conversation history
+ */
+declare class PersistentConversationHandler {
+    private appliedProps;
+    private isLastPull;
+    private pageToken;
+    private facadeChatSDK;
+    private lastMessage;
+    private count;
+    private pageSize;
+    private isCurrentlyPulling;
+    private pageTokenInTransitSet;
+    constructor(facadeChatSDK: FacadeChatSDK, props: IPersistentChatHistoryProps);
+    private appliedPropsHandler;
+    private resetEventListener;
+    reset(): void;
+    destroy(): void;
+    pullHistory(): Promise<void>;
+    private processHistoryMessages;
+    private fetchHistoryMessages;
+    private shouldPull;
+    private processMessageToActivity;
+    private createDividerActivity;
+}
+export default PersistentConversationHandler;

package/lib/types/components/livechatwidget/common/defaultProps/defaultPersistentChatHistoryProps.d.ts

@@ -0,0 +1,2 @@
+import { IPersistentChatHistoryProps } from "../../interfaces/IPersistentChatHistoryProps";
+export declare const defaultPersistentChatHistoryProps: IPersistentChatHistoryProps;

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

@@ -1,4 +1,15 @@
+import { ExtendedChatConfig } from "../../webchatcontainerstateful/interfaces/IExtendedChatConffig";
 import { FacadeChatSDK } from "../../../common/facades/FacadeChatSDK";
 export declare const isPostChatSurveyEnabled: (facadeChatSDK: FacadeChatSDK) => Promise<boolean>;
 export declare const getPostChatSurveyConfig: (facadeChatSDK: FacadeChatSDK) => Promise<any>;
 export declare const isPersistentChatEnabled: (conversationMode: string | undefined) => boolean;
+/**
+ * Determines if persistent chat history should be loaded based on all required conditions.
+ *
+ * @param extendedChatConfig - The extended chat configuration object
+ * @returns true if ALL conditions are met:
+ *   1. Conversation mode must be Persistent ("192350001")
+ *   2. History is enabled in admin config (msdyn_enablepersistentchatpreviousconversations)
+ *   3. History is enabled via feature flag (lcwPersistentChatHistoryEnabled)
+ */
+export declare const shouldLoadPersistentChatHistory: (extendedChatConfig: ExtendedChatConfig | undefined) => boolean;

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

@@ -4,4 +4,5 @@ import { ILiveChatWidgetAction } from "../../../contexts/common/ILiveChatWidgetA
 import { ILiveChatWidgetProps } from "../interfaces/ILiveChatWidgetProps";
 export declare const handleStartChatError: (dispatch: Dispatch<ILiveChatWidgetAction>, facadeChatSDK: FacadeChatSDK, props: ILiveChatWidgetProps | undefined, ex: any, isStartChatSuccessful: boolean) => void;
 export declare const logWidgetLoadComplete: (additionalMessage?: string) => void;
+export declare const logStartChatComplete: (additionalMessage?: string) => void;
 export declare const logWidgetLoadWithUnexpectedError: (ex: any) => void;

package/lib/types/components/livechatwidget/interfaces/ILiveChatWidgetProps.d.ts

@@ -20,6 +20,7 @@ import { ILoadingPaneProps } from "@microsoft/omnichannel-chat-components/lib/ty
 import { IMockProps } from "./IMockProps";
 import { INotificationPaneProps } from "@microsoft/omnichannel-chat-components/lib/types/components/notificationpane/interfaces/INotificationPaneProps";
 import { IOOOHPaneProps } from "@microsoft/omnichannel-chat-components/lib/types/components/outofofficehourspane/interfaces/IOOOHPaneProps";
+import { IPersistentChatHistoryProps } from "./IPersistentChatHistoryProps";
 import { IPostChatSurveyPaneStatefulProps } from "../../postchatsurveypanestateful/interfaces/IPostChatSurveyPaneStatefulProps";
 import { IPreChatSurveyPaneProps } from "@microsoft/omnichannel-chat-components/lib/types/components/prechatsurveypane/interfaces/IPreChatSurveyPaneProps";
 import { IProactiveChatPaneStatefulProps } from "../../proactivechatpanestateful/interfaces/IProactiveChatPaneStatefulProps";
@@ -69,4 +70,5 @@ export interface ILiveChatWidgetProps {
     mock?: IMockProps;
     featureConfigProps?: IFeatureConfigProps;
     appInsightsConfig?: IAppInsightsConfig;
+    persistentChatHistoryProps?: IPersistentChatHistoryProps;
 }

package/lib/types/components/livechatwidget/interfaces/IPersistentChatHistoryProps.d.ts

@@ -0,0 +1,11 @@
+import { IStyle } from "@fluentui/react";
+export interface IPersistentChatHistoryProps {
+    pageSize?: number;
+    dividerActivityStyle?: IStyle;
+    /**
+     * Accessible label announced by screen readers for the conversation divider element.
+     * If not supplied, a default provided in defaultPersistentChatHistoryProps will be used.
+     */
+    dividerActivityAriaLabel?: string;
+    bannerStyle?: IStyle;
+}

package/lib/types/components/webchatcontainerstateful/common/activities/botActivity.d.ts

@@ -0,0 +1,7 @@
+declare const botActivity: {
+    from: {
+        role: string;
+    };
+    type: string;
+};
+export default botActivity;

package/lib/types/components/webchatcontainerstateful/common/activities/conversationDividerActivity.d.ts

@@ -0,0 +1,10 @@
+declare const conversationDividerActivity: {
+    channelData: {
+        tags: string[];
+    };
+    from: {
+        role: string;
+    };
+    type: string;
+};
+export default conversationDividerActivity;

package/lib/types/components/webchatcontainerstateful/common/activityConverters/convertPersistentChatHistoryMessageToActivity.d.ts

@@ -0,0 +1,2 @@
+declare const convertPersistentChatHistoryMessageToActivity: (message: any) => any;
+export default convertPersistentChatHistoryMessageToActivity;

package/lib/types/components/webchatcontainerstateful/hooks/usePersistentChatHistory.d.ts

@@ -0,0 +1,4 @@
+import { FacadeChatSDK } from "../../../common/facades/FacadeChatSDK";
+import { IPersistentChatHistoryProps } from "../../livechatwidget/interfaces/IPersistentChatHistoryProps";
+declare const usePersistentChatHistory: (facadeChatSDK: FacadeChatSDK | undefined, props: IPersistentChatHistoryProps) => void;
+export default usePersistentChatHistory;

package/lib/types/components/webchatcontainerstateful/interfaces/IExtendedChatConffig.d.ts

@@ -0,0 +1,15 @@
+export interface ExtendedChatConfig {
+    LcwFcbConfiguration?: LcwFcbConfiguration;
+    LiveChatConfigAuthSettings?: LiveChatConfigAuthSettings;
+    LiveWSAndLiveChatEngJoin?: {
+        msdyn_conversationmode?: string;
+        msdyn_enablepersistentchatpreviousconversations?: string;
+    };
+}
+interface LcwFcbConfiguration {
+    lcwPersistentChatHistoryEnabled?: boolean;
+}
+interface LiveChatConfigAuthSettings {
+    msdyn_javascriptclientfunction?: string;
+}
+export {};

package/lib/types/components/webchatcontainerstateful/webchatcontroller/WebChatEventSubscribers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Component to handle persistent chat history events.
+ * Uses WebChatStoreLoader instead of hooks to avoid context issues.
+ */
+declare const WebChatEventSubscribers: () => null;
+export default WebChatEventSubscribers;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/Constants.d.ts

@@ -0,0 +1,3 @@
+export declare const LazyLoadActivityConstants: {
+    SCROLL_ID: string;
+};

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/ConversationDividerActivity.d.ts

@@ -0,0 +1,4 @@
+import { IPersistentChatHistoryProps } from "../../../../../livechatwidget/interfaces/IPersistentChatHistoryProps";
+import React from "react";
+declare const ConversationDividerActivity: (props: IPersistentChatHistoryProps) => React.JSX.Element;
+export default ConversationDividerActivity;