@unblu/floating-js-api 8.19.1 → 8.21.0

package/dist/lib/shared/model/customaction/custom-action-invocation.d.ts

@@ -0,0 +1,27 @@
+import { PersonInfo } from "../person-info";
+import { ConversationInfo } from "../conversation-info";
+/**
+ * CustomActionInvocation represents an event containing information about the invoked custom action
+ */
+export interface CustomActionInvocation {
+    /**
+     * The invocation ID
+     */
+    invocationId: string;
+    /**
+     * The unique key of the invoked custom action
+     */
+    key: string;
+    /**
+     * UTC timestamp, in milliseconds, of the custom action invocation
+     */
+    invocationTimestamp: number;
+    /**
+     * The person who invoked the custom action
+     */
+    invokingPerson: PersonInfo;
+    /**
+     * The conversation the custom action was invoked in
+     */
+    conversation: ConversationInfo;
+}

package/dist/lib/shared/model/customaction/custom-conversation-action-invocation.d.ts

@@ -0,0 +1,6 @@
+import { CustomActionInvocation } from "./custom-action-invocation";
+/**
+ * Custom conversation action invocation
+ */
+export interface CustomConversationActionInvocation extends CustomActionInvocation {
+}

package/dist/lib/shared/model/customaction/custom-message-action-invocation.d.ts

@@ -0,0 +1,16 @@
+import { CustomActionInvocation } from "./custom-action-invocation";
+import { PersonInfo } from "../person-info";
+import { ConversationMessageInfo } from "../conversation-message-info";
+/**
+ * Custom message action invocation
+ */
+export interface CustomMessageActionInvocation extends CustomActionInvocation {
+    /**
+     * The conversation containing the message that the custom action was invoked on is part of
+     */
+    targetMessage: ConversationMessageInfo;
+    /**
+     * The sender of the message the custom action was invoked on
+     */
+    targetMessageSender: PersonInfo;
+}

package/dist/lib/shared/model/customaction/custom-person-action-invocation.d.ts

@@ -0,0 +1,11 @@
+import { CustomActionInvocation } from "./custom-action-invocation";
+import { PersonInfo } from "../person-info";
+/**
+ * Custom person action invocation
+ */
+export interface CustomPersonActionInvocation extends CustomActionInvocation {
+    /**
+     * The person the custom action was invoked on
+     */
+    targetPerson: PersonInfo;
+}

package/dist/lib/shared/model/new-conversation-interceptor-result.d.ts

@@ -0,0 +1,14 @@
+import { NewConversationRecipient } from "./new-conversation-recipient";
+/**
+ * The result of calling a {@link NewConversationInterceptor}.
+ */
+export interface NewConversationInterceptorResult {
+    /**
+     * Custom visitor data that will be stored on the conversation and can be accessed through the Web API later on. This data won't be displayed anywhere and is for API usage only.
+     */
+    visitorData?: string;
+    /**
+     * The team or agent recipient of the conversation. This overwrites any named area that may be set on the web page.
+     */
+    recipient?: NewConversationRecipient;
+}

package/dist/lib/shared/model/new-conversation-recipient-type.d.ts

@@ -0,0 +1,10 @@
+export declare enum NewConversationRecipientType {
+    /**
+     * The recipient type for a conversation is an agent
+     */
+    AGENT = "AGENT",
+    /**
+     * The recipient type for a conversation is a team
+     */
+    TEAM = "TEAM"
+}

package/dist/lib/shared/model/new-conversation-recipient.d.ts

@@ -0,0 +1,14 @@
+import { NewConversationRecipientType } from "./new-conversation-recipient-type";
+/**
+ * The recipient of a conversation
+ */
+export interface NewConversationRecipient {
+    /**
+     * The ID of the recipient. Depending on the recipient type, this refers either to an agent person ID or a team ID.
+     */
+    id: string;
+    /**
+     * The recipient type
+     */
+    recipientType: NewConversationRecipientType;
+}

package/dist/lib/shared/model/person-info.d.ts

@@ -0,0 +1,5 @@
+export interface PersonInfo {
+    id: string;
+    displayName: string;
+    labels: string[];
+}

package/dist/lib/shared/new-conversation-interceptor.d.ts

@@ -0,0 +1,24 @@
+import { ConversationType } from "./model/conversation-type";
+import { NewConversationRecipient } from "./model/new-conversation-recipient";
+import { NewConversationInterceptorResult } from "./model/new-conversation-interceptor-result";
+/**
+ * Interceptor function which is called every time a new conversation is started from the UI or JS API.
+ *
+ * Starting the conversation is deferred until the Promise returned by this interceptor resolves:
+ * - If the interceptor rejects the Promise, starting the conversation will be cancelled.
+ * - If the interceptor resolves the Promise with a String, the value of the String will be used and set as "visitorData" for the conversation created.
+ * - If the interceptor resolves the Promise with a {@link NewConversationInterceptorResult}, the values from it will be used for the "visitorData" and the "recipient" for the conversation created.
+ * - If the resolved value is undefined, the value passed into the {@link UnbluApi.startConversation} method will be used.
+ * - If the resolved value is set to null, any value passed into {@link UnbluApi.startConversation} will be discarded.
+ * - If the resolved value is neither a {@link NewConversationInterceptorResult}, nor a String, nor undefined, the conversation is started without any visitorData.
+ * - If the interceptor resolves the Promise with something other than a {@link NewConversationInterceptorResult} or a String, the conversation is started without any visitorData.
+ *
+ * Any values of {@link NewConversationInterceptorResult} that are undefined are replaced by the corresponding values passed to {@link UnbluApi.startConversation}.
+ * Any values of {@link NewConversationInterceptorResult} that are null discard the corresponding values passed to {@link UnbluApi.startConversation}.
+ *
+ * @param conversationType The type of the conversation being started.
+ * @param visitorData Optional visitorData, only present if passed to the {@link UnbluApi.startConversation} method
+ * @param recipient Optional recipient, only present if passed to the {@link UnbluApi.startConversation} method
+ * @return A Promise deferring the start of the conversation until it resolves.
+ */
+export type NewConversationInterceptor = (conversationType: ConversationType, visitorData?: String, recipient?: NewConversationRecipient) => Promise<String | NewConversationInterceptorResult>;

package/dist/lib/shared/unblu-api-error.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Type of an unblu error. This can be used to check what kind of error occurred.
+ */
+export declare enum UnbluErrorType {
+    /**
+     * Thrown if the browser is not supported by unblu.
+     */
+    UNSUPPORTED_BROWSER = "UNSUPPORTED_BROWSER",
+    /**
+     * Thrown if the initialization of the unblu API failed due to a timeout.
+     */
+    INITIALIZATION_TIMEOUT = "INITIALIZATION_TIMEOUT",
+    /**
+     * Thrown if the initialization is called with no existing snippet and no configuration.
+     */
+    CONFIGURATION_MISSING = "CONFIGURATION_MISSING",
+    /**
+     * Thrown if the login against the Unblu collaboration server failed.
+     */
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    /**
+     * Thrown during initialization if the snippet can't be loaded or unblu can't be initialized from the snippet.
+     */
+    ERROR_LOADING_UNBLU = "ERROR_LOADING_UNBLU",
+    /**
+     * Thrown if the unblu JS API is not compatible with the unblu collaboration server.
+     */
+    INCOMPATIBLE_UNBLU_VERSION = "INCOMPATIBLE_UNBLU_VERSION",
+    /**
+     * Thrown if a function call was invalid.
+     * This is usually do to an incompatibility between the unblu JS API and the unblu collaboration server.
+     */
+    INVALID_FUNCTION_CALL = "INVALID_FUNCTION_CALL",
+    /**
+     * Thrown if the arguments passed to a function where invalid.
+     */
+    INVALID_FUNCTION_ARGUMENTS = "INVALID_FUNCTION_ARGUMENTS",
+    /**
+     * Thrown if a called action is not permitted for the local person.
+     * The details message usually has more information about the required permissions.
+     */
+    ACTION_NOT_GRANTED = "ACTION_NOT_GRANTED",
+    /**
+     * Thrown if an unexpected exception occurrs during a function execution.
+     */
+    EXECUTION_EXCEPTION = "EXECUTION_EXCEPTION",
+    /**
+     * Thrown if a method is called in an invalid context. E.g. if the Object called upon was already destroyed.
+     */
+    ILLEGAL_STATE = "ILLEGAL_STATE",
+    /**
+    * Thrown if a timeout ocurrs.
+    */
+    TIMEOUT = "TIMEOUT"
+}
+/**
+ * General unblu JS API error class that will be thrown whenever something goes wrong.
+ *
+ * - Use the {@link UnbluApiError.type} to check what kind of error occurred.
+ * - Use the {@link UnbluApiError.detail} for human readable details.
+ *
+ * Check the documentation of {@link UnbluErrorType} for more details on the different error types.
+ *
+ * Example for the Floating API:
+ * ```ts
+ * unblu.floating.api.initialize().then(api => {
+ *      // use the api
+ * }).catch(e => {
+ *     if(e.type === 'INITIALIZATION_TIMEOUT') {
+ *          //retry
+ *     } else if(e.type === 'UNSUPPORTED_BROWSER') {
+ *          // display unsupported browser dialog
+ *     } else {
+ *          // show generic error message
+ *     }
+ * })
+ * ```
+ *
+ * or using async / await:
+ *
+ * ```ts
+ * try {
+ *     const api = await unblu.floating.api.initialize()
+ *     // use the api
+ * } catch(e) {
+ *     if(e.type === 'INITIALIZATION_TIMEOUT') {
+ *          //retry
+ *     } else if(e.type === 'UNSUPPORTED_BROWSER') {
+ *          // display unsupported browser dialog
+ *     } else {
+ *          // show generic error message
+ *     }
+ * }
+ * ```
+ *
+ *
+ * The error types may either be checked via their constant string values or via the UnbluErrorType enum:
+ *
+ * ```ts
+ * // using string constant
+ * function isTimeout(e: UnbluApiError) {
+ *  return e.type === 'INITIALIZATION_TIMEOUT'
+ * }
+ * ```
+ * ```ts
+ * // using the enum
+ * function isTimeout(e: UnbluApiError) {
+ *  return e.type === window.unblu.UnbluErrorType.INITIALIZATION_TIMEOUT
+ * }
+ * ```
+ *
+ */
+export declare class UnbluApiError extends Error {
+    type: UnbluErrorType;
+    detail: string;
+    constructor(type: UnbluErrorType, detail: string);
+}

package/dist/lib/unblu-api-ui.d.ts

@@ -0,0 +1,137 @@
+import { InternalApi } from './internal/internal-api';
+import { Listener } from './shared/internal/util/event-emitter';
+import { IndividualUiState } from './model/individualui_state';
+import { GeneralEventType } from "./internal/module/general-module";
+import { ActiveIndividualUiView } from "./model/individualui_component";
+/**
+ * Listener called whenever the UI state changes.
+ * @param uistate The new UI state.
+ */
+export type UiStateChangeListener = (uistate: IndividualUiState) => void;
+/**
+ * Listener called whenever the active individual UI view changes.
+ *
+ * NOTE: This listener is also triggered when the view in individual UI changes, but the UI isn't
+ * visible, for example, because it's collapsed.
+ *
+ * @param uicomponent The new individual UI component.
+ */
+export type UiActiveIndividualUiViewChangeListener = (uicomponent: ActiveIndividualUiView) => void;
+/**
+ * This class allows you to control the UI state and the Unblu individual UI.
+ */
+export declare class UnbluUiApi {
+    private internalApi;
+    private internalListeners;
+    private eventEmitter;
+    /**
+     * Event emitted every time the state of the individual UI is changed.
+     *
+     * @event uiStateChange
+     * @see {@link on} for listener registration
+     * @see {@link UiStateChangeListener}
+     */
+    static readonly UI_STATE_CHANGE: 'uiStateChange';
+    /**
+     * Event emitted every time individual UI view changes.
+     *
+     * NOTE: This event is also triggered when an individual UI view change happens, but the UI isn't
+     * visible, for example, because it's collapsed.
+     *
+     * @event uiActiveIndividualUiViewChange
+     * @see {@link on} for listener registration
+     * @see {@link UiActiveIndividualUiViewChangeListener}
+     */
+    static readonly UI_ACTIVE_INDIVIDUAL_UI_VIEW_CHANGE: 'uiActiveIndividualUiViewChange';
+    /**
+     * @hidden
+     */
+    constructor(internalApi: InternalApi);
+    /**
+     * Registers an event listener for the given event.
+     * @param event The uistateChange event.
+     * @param listener The listener to be called.
+     * @see {@link UI_STATE_CHANGE}
+     */
+    on(event: typeof UnbluUiApi.UI_STATE_CHANGE, listener: UiStateChangeListener): void;
+    /**
+     * Registers an event listener for the given event.
+     * @param event The uiOverviewOpen event.
+     * @param listener The listener to be called.
+     * @see {@link UI_ACTIVE_INDIVIDUAL_UI_VIEW_CHANGE}
+     */
+    on(event: typeof UnbluUiApi.UI_ACTIVE_INDIVIDUAL_UI_VIEW_CHANGE, listener: UiActiveIndividualUiViewChangeListener): void;
+    /**
+     * Removes a previously registered listener
+     * @param event The event to unregister from.
+     * @param listener The listener to remove.
+     */
+    off(event: GeneralEventType, listener: Listener): boolean;
+    private onInternal;
+    private offInternal;
+    /**
+     * Opens the individual UI if it is collapsed and collapses it if it is open.
+     */
+    toggleIndividualUi(): Promise<void>;
+    /**
+     * Navigates the individual UI to the PIN entry UI.
+     *
+     * **NOTE:** calling this method will NOT automatically open the Unblu UI if it is collapsed. Use {@link openIndividualUi} if this is needed.
+     */
+    openPinEntryUi(): Promise<void>;
+    /**
+     * Navigates the individual UI to the overview UI.
+     *
+     * <p>
+     *     Be aware that this method will force to close any currently open conversation. Depending on the conversation's configuration and the activity in it a prompt may be displayed that has to be accepted by the visitor before the navigation to the overview can happen.
+     * </p>
+     *
+     * **NOTE:** calling this method will NOT automatically open the Unblu UI if it is collapsed. Use {@link openIndividualUi} if this is needed.
+     */
+    openOverviewUi(): Promise<void>;
+    /**
+     * Pop-out the individual UI into a separate window.
+     *
+     * **NOTE:** this has to be called in a click-event in order to be able to open the pop-up window without being blocked by the browser!
+     */
+    popoutIndividualUi(): Promise<void>;
+    /**
+     * Pop-in the individual UI when it is in [POPPED_OUT]{@link IndividualUiState.POPPED_OUT} state.
+     *
+     * The pop-out window will automatically close and the individual UI will be displayed in the original window again.
+     */
+    popinIndividualUi(): Promise<void>;
+    /**
+     * Maximize the individual UI - Does nothing if it is already maximized or popped out.
+     */
+    maximizeIndividualUi(): Promise<void>;
+    /**
+     * Minimize the individual UI - Does nothing if it is already minimized.
+     */
+    minimizeIndividualUi(): Promise<void>;
+    /**
+     * Opens the individual UI if it was collapsed. - Does nothing if it was already open.
+     */
+    openIndividualUi(): Promise<void>;
+    /**
+     * Collapses the individual UI if it was open. - Does nothing if it was already collapsed.
+     */
+    collapseIndividualUi(): Promise<void>;
+    /**
+     * Get the state of the individual UI.
+     * @return A promise that resolves to the {@link IndividualUiState} of the individual UI.
+     */
+    getIndividualUiState(): Promise<IndividualUiState>;
+    /**
+     * Get the active individual UI view.
+     *
+     * NOTE: The view being active doesn't necessarily mean it's visible to the user. The UI as a whole may be
+     * collapsed, for instance.
+     *
+     * @return A promise that resolves to the {@link ActiveIndividualUiView} of the individual UI.
+     * @see {@link getIndividualUiState}
+     */
+    getActiveIndividualUiView(): Promise<ActiveIndividualUiView>;
+    private requireUpgrade;
+    private onUpgraded;
+}