@opencx/widget 2.6.2 → 3.0.0

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

@@ -1,69 +1,18 @@
-import { User } from '../types';
-import { SendChatDto, WidgetVoteDto } from '../types/schemas-v2';
-import { NormalizedConfig } from './config';
-import { Dto } from '../sdk';
-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);
-    createClient: (user: User) => import('openapi-fetch').Client<import('../sdk/schema').paths, `${string}/${string}`>;
-    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;
@@ -80,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: {
@@ -88,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"];
                 };
             };
         };
@@ -99,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;
@@ -108,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: {
@@ -117,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: {
@@ -125,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"];
                 };
             };
         };
@@ -161,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;
@@ -179,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: {
@@ -187,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"];
                 };
             };
         };
@@ -200,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: {
@@ -212,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: {
@@ -221,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: {
@@ -229,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"];
                 };
             };
         };
@@ -240,8 +194,8 @@ export declare class ApiCaller {
             };
         };
         body: {
-            email: string;
-            name: string;
+            email?: string;
+            name?: string;
         };
     }, `${string}/${string}`>>;
     createSession: () => Promise<import('openapi-fetch').FetchResponse<{
@@ -258,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: {
@@ -266,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"];
                 };
             };
         };
@@ -284,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: {
@@ -292,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;
@@ -313,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: {
@@ -321,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"];
                 };
             };
         };
@@ -331,60 +288,16 @@ export declare class ApiCaller {
                 sessionId: string;
             };
         };
+        signal: AbortSignal;
     }, `${string}/${string}`>>;
-    uploadFile: ({ file, abortSignal, }: {
-        file: {
-            id: string;
-            file: File;
-        };
-        abortSignal?: AbortSignal;
-    }) => Promise<import('openapi-fetch').FetchResponse<{
-        parameters: {
-            query: {
-                fileId: string;
-                sessionId: string;
-            };
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "multipart/form-data": import('../sdk/schema').components["schemas"]["FileUploadDto"];
-            };
-        };
-        responses: {
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["UploadWidgetFileDto"];
-                };
-            };
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
-                };
-            };
-        };
-    }, {
-        params: {
-            query: {
-                fileId: string;
-                sessionId: string;
-            };
-        };
-        body: Dto["FileUploadDto"];
-        signal: AbortSignal | undefined;
-        headers: {
-            "Content-Type": string;
-        };
-    }, `${string}/${string}`>>;
-    vote: (body: WidgetVoteDto) => Promise<import('openapi-fetch').FetchResponse<{
+    uploadFile: (file: {
+        id: string;
+        file: File;
+    }, config?: Partial<AxiosRequestConfig>) => Promise<{
+        fileName: string;
+        fileUrl: string;
+    }>;
+    vote: (body: VoteInputDto) => Promise<import('openapi-fetch').FetchResponse<{
         parameters: {
             query?: never;
             header?: never;
@@ -393,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: {
@@ -402,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: {
@@ -410,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,25 @@
+import { PubSub } from '../utils/PubSub';
+import { ApiCaller } from '../api';
+import { Dto } from 'src/headless/core/sdk';
+import { WidgetConfig } from 'src/headless/core/types/WidgetConfig';
+type ContactState = {
+    contact: {
+        token: string;
+    } | null;
+    isCreatingUnverifiedContact: boolean;
+    isErrorCreatingUnverifiedContact: boolean;
+};
+export type CreateContactHandlerOptions = {
+    api: ApiCaller;
+    config: WidgetConfig;
+};
+export declare class ContactCtx {
+    private config;
+    private api;
+    state: PubSub<ContactState>;
+    constructor({ config, api }: CreateContactHandlerOptions);
+    shouldCollectData: () => boolean;
+    autoCreateUnverifiedUser: () => Promise<void>;
+    createUnverifiedContact: (payload: Dto["CreateUnverifiedContactDto"]) => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { MessageAttachmentType, SendMessageOutputDto, MessageDto, SomeOptional, SafeOmit, SendMessageDto, WidgetConfig } from 'src/headless/core';
+import { BotMessageType, MessageType, UserMessageType } from 'src/headless/core/types/messages';
+import { ApiCaller } from '../api';
+import { SessionCtx } from './session';
+import { PubSub } from 'src/headless/core/utils/PubSub';
+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 'src/headless/core/api';
+import { SessionDto } from 'src/headless/core';
+import { PubSub } from 'src/headless/core/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 { WidgetConfig } from 'src/headless/core/types/WidgetConfig';
+import { ApiCaller } from '../api';
+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,7 @@
+export * from './types/agent-or-bot';
+export * from './types/helpers';
+export * from './types/messages';
+export * from './types/schemas';
+export * from './types/WidgetConfig';
+export { WidgetCtx } from './context/widget';
+export { PubSub } from './utils/PubSub';

package/dist/{core → src/headless/core}/sdk/index.d.ts

@@ -2,10 +2,11 @@ import { Middleware } from 'openapi-fetch';
 import { paths, components } from './schema';
 type Options = {
     baseUrl: string;
-    onRequest?: Middleware['onRequest'];
-    onResponse?: Middleware['onResponse'];
-    onError?: Middleware['onError'];
+    onRequest?: Middleware["onRequest"];
+    onResponse?: Middleware["onResponse"];
+    onError?: Middleware["onError"];
 };
 export declare const basicClient: (options: Options) => import('openapi-fetch').Client<paths, `${string}/${string}`>;
-export type Dto = components['schemas'];
+export type Endpoint = keyof paths;
+export type Dto = components["schemas"];
 export {};

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 'src/headless/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;
-    };
-}