@opencx/widget 2.6.3 → 3.0.1

package/dist/{core/client → src/headless/core}/api.d.ts

@@ -1,81 +1,18 @@
-import { User } from '../types';
-import { SendChatDto, WidgetVoteDto } from '../types/schemas-v2';
-import { NormalizedConfig } from './config';
-import { Dto } from '../sdk';
-import { AxiosInstance, AxiosRequestConfig } from 'axios';
-export interface ApiCallerOptions {
-    config: NormalizedConfig;
-}
+import { AxiosRequestConfig } from 'axios';
+import { Dto } from './sdk';
+import { WidgetConfig } from './types/WidgetConfig';
+import { SendMessageDto, VoteInputDto } from './types/schemas';
 export declare class ApiCaller {
-    #private;
-    private readonly options;
-    constructor(options: ApiCallerOptions);
-    constructClientOptions: (user: User) => {
-        baseUrl: string;
-        headers: {
-            "X-Bot-Token": string;
-            "X-Consumer-Id": string;
-            "Content-Type": string;
-            Accept: string;
-            Authorization: string | undefined;
-        };
-    };
-    createOpenAPIClient: ({ baseUrl, headers, }: ReturnType<typeof this.constructClientOptions>) => import('openapi-fetch').Client<import('../sdk/schema').paths, `${string}/${string}`>;
-    createAxiosUploadClient: ({ baseUrl, headers, }: ReturnType<typeof this.constructClientOptions>) => AxiosInstance;
-    setUser: (user: User) => void;
-    me: () => Promise<import('openapi-fetch').FetchResponse<{
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
-                };
-            };
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
-                };
-            };
-        };
-    }, import('openapi-fetch').FetchOptions<{
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
-                };
-            };
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
-                };
-            };
-        };
-    }> | undefined, `${string}/${string}`>>;
+    private client;
+    private uploadFileClient;
+    private config;
+    constructor({ config, }: {
+        config: WidgetConfig;
+    });
+    private constructClientOptions;
+    private createOpenAPIClient;
+    private createAxiosUploadClient;
+    setAuthToken: (token: string) => void;
     widgetPrelude: () => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
@@ -92,7 +29,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetPreludeDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetPreludeDto"];
                 };
             };
             500: {
@@ -100,7 +37,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -111,7 +48,7 @@ export declare class ApiCaller {
             };
         };
     }, `${string}/${string}`>>;
-    handleMessage: (body: SendChatDto, abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
+    sendMessage: (body: SendMessageDto, abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
@@ -120,7 +57,7 @@ export declare class ApiCaller {
         };
         requestBody: {
             content: {
-                "application/json": import('../sdk/schema').components["schemas"]["HttpChatInputDto"];
+                "application/json": import('./sdk/schema').components["schemas"]["HttpChatInputDto"];
             };
         };
         responses: {
@@ -129,7 +66,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["HandleContactMessageOutputDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["HandleContactMessageOutputDto"];
                 };
             };
             500: {
@@ -137,7 +74,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -173,7 +110,11 @@ export declare class ApiCaller {
         };
         signal: AbortSignal | undefined;
     }, `${string}/${string}`>>;
-    getSessionHistory: (sessionId: string, lastMessageTimestamp?: string) => Promise<import('openapi-fetch').FetchResponse<{
+    getSessionHistory: ({ sessionId, lastMessageTimestamp, abortSignal, }: {
+        sessionId: string;
+        lastMessageTimestamp?: string;
+        abortSignal: AbortSignal;
+    }) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: {
                 lastMessageTimestamp?: string;
@@ -191,7 +132,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetHistoryDto"][];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetHistoryDto"][];
                 };
             };
             500: {
@@ -199,7 +140,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -212,8 +153,9 @@ export declare class ApiCaller {
                 lastMessageTimestamp: string;
             } | undefined;
         };
+        signal: AbortSignal;
     }, `${string}/${string}`>>;
-    createContact: (body: Dto["CreateContactDto"]) => Promise<import('openapi-fetch').FetchResponse<{
+    createUnverifiedContact: (body: Dto["CreateUnverifiedContactDto"]) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
             header: {
@@ -224,7 +166,7 @@ export declare class ApiCaller {
         };
         requestBody: {
             content: {
-                "application/json": import('../sdk/schema').components["schemas"]["CreateContactDto"];
+                "application/json": import('./sdk/schema').components["schemas"]["CreateUnverifiedContactDto"];
             };
         };
         responses: {
@@ -233,7 +175,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetContactTokenResponseDto"];
                 };
             };
             500: {
@@ -241,7 +183,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -252,8 +194,8 @@ export declare class ApiCaller {
             };
         };
         body: {
-            email: string;
-            name: string;
+            email?: string;
+            name?: string;
         };
     }, `${string}/${string}`>>;
     createSession: () => Promise<import('openapi-fetch').FetchResponse<{
@@ -270,7 +212,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetSessionDto"];
                 };
             };
             500: {
@@ -278,7 +220,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -296,7 +238,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetSessionDto"];
                 };
             };
             500: {
@@ -304,12 +246,15 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
     }> | undefined, `${string}/${string}`>>;
-    getSession: (sessionId: string) => Promise<import('openapi-fetch').FetchResponse<{
+    getSession: ({ sessionId, abortSignal, }: {
+        sessionId: string;
+        abortSignal: AbortSignal;
+    }) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
@@ -325,7 +270,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetSessionDto"];
                 };
             };
             500: {
@@ -333,7 +278,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };
@@ -343,6 +288,7 @@ export declare class ApiCaller {
                 sessionId: string;
             };
         };
+        signal: AbortSignal;
     }, `${string}/${string}`>>;
     uploadFile: (file: {
         id: string;
@@ -351,7 +297,7 @@ export declare class ApiCaller {
         fileName: string;
         fileUrl: string;
     }>;
-    vote: (body: WidgetVoteDto) => Promise<import('openapi-fetch').FetchResponse<{
+    vote: (body: VoteInputDto) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
@@ -360,7 +306,7 @@ export declare class ApiCaller {
         };
         requestBody: {
             content: {
-                "application/json": import('../sdk/schema').components["schemas"]["WidgetVoteDto"];
+                "application/json": import('./sdk/schema').components["schemas"]["WidgetVoteDto"];
             };
         };
         responses: {
@@ -369,7 +315,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["WidgetVoteResponseDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["WidgetVoteResponseDto"];
                 };
             };
             500: {
@@ -377,7 +323,7 @@ export declare class ApiCaller {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                    "application/json": import('./sdk/schema').components["schemas"]["ErrorDto"];
                 };
             };
         };

package/dist/src/headless/core/context/contact.d.ts

@@ -0,0 +1,24 @@
+import { PubSub } from '../utils/PubSub';
+import { ApiCaller } from '../api';
+import { WidgetConfig } from '../types/WidgetConfig';
+import { Dto } from '../sdk';
+type ContactState = {
+    contact: {
+        token: string;
+    } | null;
+    isCreatingUnverifiedContact: boolean;
+    isErrorCreatingUnverifiedContact: boolean;
+};
+export declare class ContactCtx {
+    private config;
+    private api;
+    state: PubSub<ContactState>;
+    constructor({ config, api, }: {
+        api: ApiCaller;
+        config: WidgetConfig;
+    });
+    shouldCollectData: () => boolean;
+    autoCreateUnverifiedUser: () => Promise<void>;
+    createUnverifiedContact: (payload: Dto["CreateUnverifiedContactDto"]) => Promise<void>;
+}
+export {};

package/dist/src/headless/core/context/message.d.ts

@@ -0,0 +1,42 @@
+import { ApiCaller } from '../api';
+import { WidgetConfig } from '../types/WidgetConfig';
+import { SafeOmit, SomeOptional } from '../types/helpers';
+import { BotMessageType, MessageType, UserMessageType } from '../types/messages';
+import { MessageAttachmentType, MessageDto, SendMessageDto, SendMessageOutputDto } from '../types/schemas';
+import { PubSub } from '../utils/PubSub';
+import { SessionCtx } from './session';
+export declare class MessageCtx {
+    private config;
+    private api;
+    private sessionCtx;
+    private poller;
+    state: PubSub<{
+        messages: MessageType[];
+        isSendingMessage: boolean;
+        suggestedReplies: string[] | null;
+    }>;
+    private sendMessageAbortController;
+    constructor({ config, api, sessionCtx, }: {
+        config: WidgetConfig;
+        api: ApiCaller;
+        sessionCtx: SessionCtx;
+    });
+    reset: () => void;
+    registerPolling: () => void;
+    sendMessage: (input: SomeOptional<SafeOmit<SendMessageDto, "bot_token" | "uuid">, "session_id" | "user">) => Promise<void>;
+    fetchAndSetHistory: (sessionId: string, abortSignal: AbortSignal) => Promise<void>;
+    /** Not the best name but whatever */
+    static mapHistoryToMessage(history: MessageDto): MessageType;
+    static toUserMessage(content: string, attachments?: MessageAttachmentType[]): UserMessageType;
+    static toBotMessage(response: SendMessageOutputDto): BotMessageType | null;
+    static toErrorMessage(message: string): {
+        type: "FROM_BOT";
+        id: string;
+        timestamp: string;
+        component: string;
+        data: {
+            message: string;
+            variant: string;
+        };
+    };
+}

package/dist/src/headless/core/context/session.d.ts

@@ -0,0 +1,74 @@
+import { ApiCaller } from '../api';
+import { SessionDto } from '../types/schemas';
+import { PubSub } from '../utils/PubSub';
+export declare class SessionCtx {
+    private api;
+    private poller;
+    state: PubSub<{
+        session: SessionDto | null;
+        isCreatingSession: boolean;
+    }>;
+    constructor(api: ApiCaller);
+    /** Clears the session and stops polling */
+    reset: () => Promise<void>;
+    registerPolling: () => void;
+    /**
+     * Creates a new session
+     * @returns The session
+     */
+    createSession: () => Promise<{
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        isHandedOff: boolean;
+        isOpened: boolean;
+        assignee: {
+            kind: "human" | "ai" | "none" | "unknown";
+            name: string | null;
+            avatarUrl: string | null;
+        };
+        channel: string;
+        isVerified: boolean;
+    } | null>;
+    /**
+     * Fetches the session from the API
+     * @param id - The ID of the session to fetch
+     * @returns The session
+     */
+    fetch: (sessionId: string, abortSignal: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                sessionId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                sessionId: string;
+            };
+        };
+        signal: AbortSignal;
+    }, `${string}/${string}`>>;
+}

package/dist/src/headless/core/context/widget.d.ts

@@ -0,0 +1,16 @@
+import { ApiCaller } from '../api';
+import { WidgetConfig } from '../types/WidgetConfig';
+import { ContactCtx } from './contact';
+import { MessageCtx } from './message';
+import { SessionCtx } from './session';
+export declare class WidgetCtx {
+    config: WidgetConfig;
+    api: ApiCaller;
+    contactCtx: ContactCtx;
+    sessionCtx: SessionCtx;
+    messageCtx: MessageCtx;
+    constructor({ config }: {
+        config: WidgetConfig;
+    });
+    resetChat: () => void;
+}

package/dist/src/headless/core/index.d.ts

@@ -0,0 +1,10 @@
+export type { AgentOrBotType } from './types/agent-or-bot';
+export type { SafeExtract, SafeOmit, SomeOptional, StringOrLiteral, } from './types/helpers';
+export type { AgentMessageType, BotMessageType, MessageType, UserMessageType, } from './types/messages';
+export type { MessageAttachmentType, MessageDto, PreludeDto, SendMessageDto, SendMessageOutputDto, SessionDto, VoteInputDto, VoteOutputDto, } from './types/schemas';
+export type { WidgetConfig } from './types/WidgetConfig';
+export { WidgetCtx } from './context/widget';
+export type { ContactCtx } from './context/contact';
+export type { SessionCtx } from './context/session';
+export type { MessageCtx } from './context/message';
+export { PubSub } from './utils/PubSub';

package/dist/src/headless/core/types/WidgetConfig.d.ts

@@ -0,0 +1,34 @@
+import { AgentOrBotType } from './agent-or-bot';
+export interface WidgetConfig {
+    token: string;
+    apiUrl?: string;
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    collectUserData?: boolean;
+    debug?: boolean;
+    initialMessages?: string[];
+    language?: string;
+    user?: {
+        external_id?: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        customData?: Record<string, string>;
+        avatarUrl?: string;
+    };
+    contactToken?: string;
+    bot?: AgentOrBotType;
+    soundEffectsUrls?: {
+        messageArrived?: string;
+    };
+    theme?: {
+        primaryColor?: string;
+    };
+    settings?: {
+        persistSession?: boolean;
+        playSoundEffects?: boolean;
+    };
+    assets?: {
+        organizationLogo?: string;
+    };
+}

package/dist/src/headless/core/types/agent-or-bot.d.ts

@@ -0,0 +1,6 @@
+export type AgentOrBotType = {
+    isAi: boolean;
+    id: string | null;
+    name: string;
+    avatar: string | null;
+};

package/dist/src/headless/core/types/helpers.d.ts

@@ -0,0 +1,4 @@
+export type SomeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+export type SafeExtract<T, K extends T> = Extract<T, K>;
+export type StringOrLiteral<T extends string> = T | (string & {});

package/dist/{core → src/headless/core}/types/messages.d.ts

@@ -1,18 +1,13 @@
-import { DefaultTextComponentBaseProps, WidgetLiteralComponentKey } from '../../react-web/types';
-import { ChatAttachmentType, WidgetHistoryDto } from './schemas-v2';
+import { MessageAttachmentType, MessageDto } from './schemas';
 import { SafeExtract, StringOrLiteral } from './helpers';
-export type AgentType = {
-    isAi: boolean;
-    id: string | null;
-    name: string;
-    avatar: string | null;
-};
+import { AgentOrBotType } from './agent-or-bot';
+import { DefaultTextComponentBaseProps, WidgetLiteralComponentKey } from '../../react/types/components';
 export type UserMessageType = {
     id: string;
     type: "FROM_USER";
     content: string;
     deliveredAt: string | null;
-    attachments?: ChatAttachmentType[] | null;
+    attachments?: MessageAttachmentType[] | null;
     timestamp: string;
     user?: {
         name?: string;
@@ -31,9 +26,9 @@ export type BotMessageType<TData = DefaultTextComponentBaseProps | unknown> = {
     component: StringOrLiteral<SafeExtract<WidgetLiteralComponentKey, "bot_message">>;
     data: TData;
     timestamp: string;
-    original?: WidgetHistoryDto;
-    agent?: AgentType;
-    attachments?: ChatAttachmentType[];
+    original?: MessageDto;
+    agent?: AgentOrBotType;
+    attachments?: MessageAttachmentType[];
 };
 export type AgentMessageType = {
     id: string;
@@ -41,24 +36,9 @@ export type AgentMessageType = {
     component: SafeExtract<WidgetLiteralComponentKey, "agent_message">;
     data: DefaultTextComponentBaseProps;
     timestamp?: string;
-    original?: WidgetHistoryDto;
-    agent?: AgentType;
-    attachments?: ChatAttachmentType[];
+    original?: MessageDto;
+    agent?: AgentOrBotType;
+    attachments?: MessageAttachmentType[];
 };
+/** Find a better name for this thing */
 export type MessageType = UserMessageType | BotMessageType | AgentMessageType;
-export interface SendMessageInput {
-    content: {
-        text: string;
-    };
-    attachments?: ChatAttachmentType[];
-    id?: string;
-    language?: string;
-    user?: {
-        external_id?: string;
-        name?: string;
-        email?: string;
-        phone?: string;
-        customData?: Record<string, string>;
-        avatarUrl?: string;
-    };
-}

package/dist/src/headless/core/types/schemas.d.ts

@@ -0,0 +1,9 @@
+import { Dto } from '../sdk';
+export type VoteInputDto = Dto["WidgetVoteDto"];
+export type VoteOutputDto = Dto["WidgetVoteResponseDto"];
+export type SendMessageDto = Dto["HttpChatInputDto"];
+export type SendMessageOutputDto = Dto["HandleContactMessageOutputDto"];
+export type SessionDto = Dto["WidgetSessionDto"];
+export type MessageDto = Dto["WidgetHistoryDto"];
+export type PreludeDto = Dto["WidgetPreludeDto"];
+export type MessageAttachmentType = NonNullable<Dto["WidgetHistoryDto"]["attachments"]>[number];

package/dist/src/headless/core/utils/Poller.d.ts

@@ -0,0 +1,12 @@
+import { PubSub } from './PubSub';
+export type PollingState = {
+    isPolling: boolean;
+    isError: boolean;
+};
+export declare class Poller {
+    state: PubSub<PollingState>;
+    private abortController;
+    reset: () => void;
+    stopPolling: (() => void) | null;
+    startPolling: (cb: (abortSignal: AbortSignal) => Promise<void>, interval: number) => void;
+}

package/dist/{core/types/pub-sub.d.ts → src/headless/core/utils/PubSub.d.ts}

@@ -25,18 +25,16 @@ export declare class PubSub<S> {
      * @param callback Function to call when state changes
      * @returns Unsubscribe function
      */
-    subscribe: (callback: Subscriber<S>) => () => void;
-    onLifecycle: (event: LifecycleEvent, listener: LifecycleListener) => () => void;
-    /**
-     * Get the current state
-     */
-    getState: () => S;
+    subscribe: (callback: Subscriber<S>) => (() => void);
+    onLifecycle: (event: LifecycleEvent, listener: LifecycleListener) => (() => void);
+    /** Get the current state */
+    get: () => S;
     /**
      * Set the state and notify subscribers if the state changes
      * @param newState The new state to set
      */
-    setState: (newState: S) => void;
-    setStatePartial: (_s: Partial<S>) => void;
+    set: (newState: S) => void;
+    setPartial: (_s: Partial<S>) => void;
     /**
      * Clear all subscriptions
      */
@@ -44,5 +42,4 @@ export declare class PubSub<S> {
     reset: () => void;
     lastUpdated: () => number | null;
 }
-export declare function createPubSub<S>(state: S): PubSub<S>;
 export {};