@opencx/widget 2.6.3 → 3.0.0

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/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;
-    };
-}

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

@@ -0,0 +1,9 @@
+import { Dto } from 'src/headless/core/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 'src/headless/core/utils/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 {};

package/dist/{react-web/core-integration/components.d.ts → src/headless/react/ComponentRegistry.d.ts}

@@ -1,4 +1,4 @@
-import { WidgetComponentType } from '../types';
+import { WidgetComponentType } from './types/components';
 export declare class ComponentRegistry {
     components: WidgetComponentType[];
     constructor(opts: {

package/dist/src/headless/react/WidgetProvider.d.ts

@@ -0,0 +1,17 @@
+import { WidgetConfig, WidgetCtx } from 'src/headless/core';
+import { default as React } from 'react';
+import { ComponentRegistry } from './ComponentRegistry';
+import { WidgetComponentType } from './types/components';
+interface WidgetProviderValue {
+    widgetCtx: WidgetCtx;
+    components?: WidgetComponentType[];
+    componentStore: ComponentRegistry;
+    version: string;
+}
+declare const useWidget: () => WidgetProviderValue;
+declare function WidgetProvider({ options, children, components, }: {
+    options: WidgetConfig;
+    children: React.ReactNode;
+    components?: WidgetComponentType[];
+}): React.JSX.Element;
+export { useWidget, WidgetProvider };

package/dist/src/headless/react/hooks/useConfig.d.ts

@@ -0,0 +1 @@
+export declare function useConfig(): import('..').WidgetConfig;

package/dist/src/headless/react/hooks/useContact.d.ts

@@ -0,0 +1,10 @@
+export declare function useContact(): {
+    state: {
+        contact: {
+            token: string;
+        } | null;
+        isCreatingUnverifiedContact: boolean;
+        isErrorCreatingUnverifiedContact: boolean;
+    };
+    contactCtx: import('../../core/context/contact').ContactCtx;
+};

package/dist/src/headless/react/hooks/useIsAwaitingBotReply.d.ts

@@ -0,0 +1,3 @@
+export declare function useIsAwaitingBotReply(): {
+    isAwaitingBotReply: boolean;
+};

package/dist/src/headless/react/hooks/useMessages.d.ts

@@ -0,0 +1,8 @@
+export declare function useMessages(): {
+    messages: {
+        messages: import('../../core').MessageType[];
+        isSendingMessage: boolean;
+        suggestedReplies: string[] | null;
+    };
+    messageCtx: import('../../core/context/message').MessageCtx;
+};

package/dist/{react-web/core-integration → src/headless/react}/hooks/usePreludeData.d.ts

@@ -14,7 +14,7 @@ declare function usePreludeData(): import('swr').SWRResponse<import('openapi-fet
                 [name: string]: unknown;
             };
             content: {
-                "application/json": import('../../../core/sdk/schema').components["schemas"]["WidgetPreludeDto"];
+                "application/json": import('../../core/sdk/schema').components["schemas"]["WidgetPreludeDto"];
             };
         };
         500: {
@@ -22,7 +22,7 @@ declare function usePreludeData(): import('swr').SWRResponse<import('openapi-fet
                 [name: string]: unknown;
             };
             content: {
-                "application/json": import('../../../core/sdk/schema').components["schemas"]["ErrorDto"];
+                "application/json": import('../../core/sdk/schema').components["schemas"]["ErrorDto"];
             };
         };
     };

package/dist/{react-web/core-integration → src/headless/react}/hooks/usePubsub.d.ts

@@ -1,2 +1,2 @@
-import { PubSub } from '../../../core/types';
+import { PubSub } from 'src/headless/core';
 export declare function usePubsub<T>(p: PubSub<T>): T;

package/dist/src/headless/react/hooks/useSession.d.ts

@@ -0,0 +1,6 @@
+export declare function useSession(): {
+    session: {
+        session: import('../../core').SessionDto | null;
+        isCreatingSession: boolean;
+    };
+};

package/dist/{react-web/core-integration → src/headless/react}/hooks/useVote.d.ts

@@ -8,11 +8,11 @@ export declare function useVote(id: string, sessionId: string, onSuccess?: () =>
  * @param id
  * @param onSuccess
  * @deprecated use useVote instead
-*/
+ */
 export declare function useUpvote(id: string, sessionId: string, onSuccess?: () => void): import('react-use/lib/useAsyncFn').AsyncFnReturn<() => Promise<void>>;
 /**
  * @param id
  * @param onSuccess
  * @deprecated use useVote instead
-*/
+ */
 export declare function useDownvote(id: string, sessionId: string, onSuccess?: () => void): import('react-use/lib/useAsyncFn').AsyncFnReturn<() => Promise<void>>;

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

@@ -0,0 +1,11 @@
+export { WidgetProvider, useWidget, } from './WidgetProvider';
+export { useConfig } from './hooks/useConfig';
+export { useContact } from './hooks/useContact';
+export { useIsAwaitingBotReply } from './hooks/useIsAwaitingBotReply';
+export { useMessages } from './hooks/useMessages';
+export { usePreludeData } from './hooks/usePreludeData';
+export { usePubsub } from './hooks/usePubsub';
+export { useSession } from './hooks/useSession';
+export { useVote } from './hooks/useVote';
+export { type FileWithProgress, useUploadFiles } from './hooks/useUploadFiles';
+export type { WidgetConfig } from 'src/headless/core';

package/dist/src/headless/react/types/components.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { BotMessageType } from 'src/headless/core/types/messages';
+import { StringOrLiteral } from 'src/headless/core';
+export type WidgetComponentProps<TData> = BotMessageType<TData>;
+export type WidgetLiteralComponentKey = "bot_message" | "agent_message" | "loading" | "fallback";
+export type WidgetComponentKey = StringOrLiteral<WidgetLiteralComponentKey>;
+export type WidgetComponentType = {
+    key: WidgetComponentKey;
+    component: React.ElementType;
+};
+export type DefaultTextComponentBaseProps = {
+    message: string;
+    variant?: "default" | "error";
+};
+export type DefaultTextComponentProps = WidgetComponentProps<DefaultTextComponentBaseProps>;