@opencx/widget 2.4.3 → 2.4.4-rn.0

package/dist/core/client/api.d.ts

@@ -1,9 +1,8 @@
-import { HandleContactMessageOutputSchema, WidgetHistorySchema, WidgetPreludeSchema, WidgetSessionSchema } from '../types/schemas-v2';
-import { CoreOptions, SendMessageInput, ConsumerType } from '../types';
+import { HttpChatInputSchema, WidgetHistorySchema, WidgetPreludeSchema, WidgetSessionSchema } from '../types/schemas-v2';
+import { ConsumerType } from '../types';
+import { NormalizedConfig } from './config';
 export interface ApiCallerOptions {
-    apiUrl: string;
-    token: string;
-    coreOptions: CoreOptions;
+    config: NormalizedConfig;
 }
 export declare class ApiCaller {
     #private;
@@ -14,7 +13,38 @@ export declare class ApiCaller {
         contactName: string;
     }>;
     widgetPrelude(): Promise<WidgetPreludeSchema>;
-    handleMessage(message: SendMessageInput): Promise<HandleContactMessageOutputSchema>;
+    handleMessage(message: HttpChatInputSchema): Promise<{
+        success: true;
+        code?: string | undefined;
+        options?: {
+            value: string[];
+            type: "options";
+        } | undefined;
+        autopilotResponse?: {
+            value: {
+                content: string;
+                error: boolean;
+            };
+            type: "text";
+            id?: string | undefined;
+        } | undefined;
+        uiResponse?: {
+            value: {
+                type: "ui_component";
+                name: string;
+                request_response?: unknown;
+                content?: string | undefined;
+            };
+            type: "ui";
+        } | undefined;
+        sessionIsHandedOff?: boolean | undefined;
+    } | {
+        error: {
+            message?: string | undefined;
+            code?: string | undefined;
+        };
+        success: false;
+    }>;
     getSessionHistory(sessionId: string, lastMessageTimestamp?: string): Promise<WidgetHistorySchema[]>;
     createSession(): Promise<WidgetSessionSchema>;
     getSession(sessionId: string): Promise<WidgetSessionSchema>;

package/dist/core/client/chat.d.ts

@@ -1,18 +1,23 @@
 import { PubSub } from '../types/pub-sub';
 import { MessageType } from '../types';
 import { ApiCaller } from './api';
+import { HttpChatInputSchema } from '../types/schemas-v2';
+import { LoadingState, ErrorState, SomeOptional } from '../types/helpers';
+import { ConfigInstance } from './config';
+import { Platform } from '../platform';
 type ChatState = {
-    lastUpdated: number | null;
     messages: MessageType[];
     keyboard: {
         options: string[];
     } | null;
+    loading: LoadingState;
+    error: ErrorState;
 };
 type ChatOptions = {
     api: ApiCaller;
-    persistSession?: boolean;
-    useSoundEffects?: boolean;
+    config: ConfigInstance;
     onSessionDestroy?: () => void;
+    platform: Platform;
 };
 export declare function createChat(options: ChatOptions): {
     chatState: PubSub<ChatState>;
@@ -28,22 +33,7 @@ export declare function createChat(options: ChatOptions): {
         isHandedOff: boolean;
         isOpened: boolean;
     } | null>;
-    sendMessage: (input: {
-        content: {
-            text: string;
-        };
-        attachments?: any[];
-        id?: string;
-        language?: string;
-        user?: {
-            external_id?: string;
-            name?: string;
-            email?: string;
-            phone?: string;
-            customData?: Record<string, string>;
-            avatarUrl?: string;
-        };
-    }) => Promise<void>;
+    sendMessage: (input: SomeOptional<Omit<HttpChatInputSchema, "bot_token">, "session_id" | "user">) => Promise<boolean>;
     createSession: () => Promise<{
         id: string;
         channel: string;
@@ -55,7 +45,7 @@ export declare function createChat(options: ChatOptions): {
         updatedAt: Date;
         isHandedOff: boolean;
         isOpened: boolean;
-    }>;
+    } | null>;
     clearSession: () => Promise<void>;
     cleanup: () => void;
 };

package/dist/core/client/config.d.ts

@@ -1,5 +1,5 @@
 import { CoreOptions } from '../types';
-type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
+export type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
     contactToken: string | undefined | null;
     soundEffectFiles: {
         messageArrived: string;
@@ -13,7 +13,7 @@ type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
         useSoundEffects: boolean;
     };
 };
-type ConfigInstance = {
+export type ConfigInstance = {
     getConfig: () => NormalizedConfig;
     getApiConfig: () => {
         apiUrl: string;
@@ -31,4 +31,3 @@ type ConfigInstance = {
     getDebugMode: () => boolean;
 };
 export declare function createConfig(options: CoreOptions): ConfigInstance;
-export {};

package/dist/core/client/contact.d.ts

@@ -1,32 +1,33 @@
 import { PubSub } from '../types/pub-sub';
+import { ConsumerType } from '../types';
 import { ApiCaller } from './api';
 import { Platform } from '../platform';
+import { LoadingState, ErrorState } from '../types/helpers';
+import { ConfigInstance } from './config';
+type ContactState = {
+    contact: ConsumerType | null;
+    loading: LoadingState;
+    error: ErrorState;
+};
 type ContactOptions = {
     api: ApiCaller;
-    botToken: string;
     platform: Platform;
-    collectUserData?: boolean;
-    user?: {
-        external_id?: string;
-        name?: string;
-        email?: string;
-        phone?: string;
-        customData?: Record<string, string>;
-        avatarUrl?: string;
-    };
+    config: ConfigInstance;
 };
 export declare function createContact(options: ContactOptions): {
+    contactState: PubSub<ContactState>;
     shouldCollectData: () => {
         should: boolean;
         reason?: string;
     };
-    cleanup: () => void;
-    contactState: PubSub<{
+    loadContact: () => Promise<any>;
+    saveContact: (contactData: Partial<ConsumerType>) => Promise<{
         email: string | null;
         id: string;
         name: string | null;
         avatar_url: string | null;
         created_at: string;
     } | null>;
+    cleanup: () => Promise<void>;
 };
 export {};

package/dist/core/client/index.d.ts

@@ -1,3 +1,4 @@
 export { createChat } from './chat';
 export { createContact } from './contact';
 export { ApiCaller, type ApiCallerOptions } from './api';
+export { createConfig } from './config';

package/dist/core/index.d.ts

@@ -1,4 +1,3 @@
-export * from './client';
 export * from './errors';
 export * from './types';
 export * from './platform';

package/dist/core/platform/index.d.ts

@@ -1,11 +1,11 @@
+import { Logger } from './logger';
+import { Storage } from './storage';
+export * from './storage';
+export type { Storage };
 export interface Platform {
     storage?: Storage;
+    logger?: Logger;
     env: {
         platform: string;
     };
-    date: {
-        now(): number;
-        toISOString(date: number): string;
-    };
 }
-export declare function createDefaultPlatform(): Platform;

package/dist/core/platform/logger.d.ts

@@ -0,0 +1,14 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    setLevel(level: LogLevel): void;
+}
+export type LoggerOptions = {
+    level?: LogLevel;
+    prefix?: string;
+    enabled?: boolean;
+};
+export declare function createLogger(options?: LoggerOptions): Logger;

package/dist/core/platform/storage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Platform-agnostic storage interface that can be implemented
+ * for different environments (web, mobile, desktop, etc.)
+ */
+export interface Storage {
+    /**
+     * Retrieves the value associated with the given key
+     * @param key The key to look up
+     * @returns The stored value or null if not found
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Stores a value with the given key
+     * @param key The key to store under
+     * @param value The value to store
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Removes the value associated with the given key
+     * @param key The key to remove
+     */
+    removeItem(key: string): Promise<void>;
+    /**
+     * Checks if the storage is available and working
+     * @returns true if storage is available and working
+     */
+    isAvailable?(): boolean;
+}
+/**
+ * Helper function to check if storage is available and working
+ */
+export declare function isStorageAvailable(storage: Storage | undefined): storage is Storage;
+/**
+ * Type for the result of a safe storage operation
+ */
+export type StorageOperationResult<T> = {
+    success: true;
+    result: T;
+} | {
+    success: false;
+    error: Error;
+};
+/**
+ * Helper function to safely perform storage operations
+ */
+export declare function safeStorageOperation<T>(operation: () => Promise<T>, errorMessage: string): Promise<StorageOperationResult<T>>;

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

@@ -3,3 +3,15 @@ export type FunctionReturningPromise = (...args: any[]) => Promise<any>;
 export type MakeKeysNotNullable<T, K extends keyof T> = Omit<T, K> & {
     [P in K]-?: NonNullable<T[P]>;
 };
+export type LoadingReason = 'sending_message' | 'creating_session' | 'polling' | 'loading_contact' | 'saving_contact' | 'cleaning_up' | null;
+export type LoadingState = {
+    isLoading: boolean;
+    reason?: LoadingReason;
+};
+export type ErrorCode = 'SESSION_CREATION_FAILED' | 'SESSION_CLEAR_FAILED' | 'SESSION_PERSISTENCE_FAILED' | 'MESSAGE_SEND_FAILED' | 'NO_ACTIVE_SESSION' | 'CONTACT_PERSISTENCE_FAILED' | 'CONTACT_LOAD_FAILED' | 'CONTACT_SAVE_FAILED' | 'CONTACT_CLEANUP_FAILED';
+export type ErrorState = {
+    hasError: boolean;
+    message?: string;
+    code?: ErrorCode;
+};
+export type SomeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/core/types/index.d.ts

@@ -23,11 +23,11 @@ export interface SendMessageInput extends Record<string, unknown> {
 export interface CoreOptions {
     token: string;
     apiUrl?: string;
-    transport?: 'socket' | 'http';
     socketUrl?: string;
     headers?: Record<string, string>;
     queryParams?: Record<string, string>;
     pathParams?: Record<string, string>;
+    collectUserData?: boolean;
     debug?: boolean;
     language?: string;
     user?: User;

package/dist/core/types/messages.d.ts

@@ -5,7 +5,7 @@ export type UserMessageType = {
     content: string;
     deliveredAt: string | null;
     attachments?: ChatAttachmentType[];
-    timestamp?: string;
+    timestamp: string;
     user?: {
         name?: string;
         email?: string;
@@ -19,7 +19,7 @@ export type BotMessageType<TData = unknown> = {
     type: "FROM_BOT";
     component: string;
     data: TData;
-    timestamp?: string;
+    timestamp: string;
     original?: ChatHistoryMessageType;
     agent?: AgentType;
     attachments?: ChatAttachmentType[];

package/dist/core/types/pub-sub.d.ts

@@ -1,31 +1,47 @@
 export type Subscriber<T> = (data: T) => void;
+export declare enum LifecycleEvent {
+    INIT = "init",
+    STATE_CHANGE = "stateChange",
+    BEFORE_UPDATE = "beforeUpdate",
+    AFTER_UPDATE = "afterUpdate",
+    DESTROY = "destroy",
+    ERROR = "error"
+}
+type LifecycleListener = (event: {
+    type: LifecycleEvent;
+    timestamp: number;
+    data?: any;
+}) => void;
 export declare class PubSub<S> {
     #private;
     private subscribers;
     private initialState;
+    private lifecycleListeners;
     constructor(state: S);
+    private emitLifecycle;
     /**
      * Subscribe to state changes
      * @param callback Function to call when state changes
      * @returns Unsubscribe function
      */
-    subscribe(callback: Subscriber<S>): () => void;
+    subscribe: (callback: Subscriber<S>) => () => void;
+    onLifecycle: (event: LifecycleEvent, listener: LifecycleListener) => () => void;
     /**
      * Get the current state
      */
-    getState(): S;
+    getState: () => 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;
+    setState: (newState: S) => void;
+    setStatePartial: (_s: Partial<S>) => void;
     /**
      * Clear all subscriptions
      */
-    clear(): void;
-    reset(): void;
-    getSnapshot(): S;
-    get state(): S;
+    clear: () => void;
+    reset: () => void;
+    lastUpdated: () => number | null;
 }
 export declare function createPubSub<S>(state: S): PubSub<S>;
+export {};

package/dist/core/types/schemas-v2.d.ts

@@ -314,7 +314,7 @@ declare const widgetHistorySchema: z.ZodObject<{
     }, {
         text?: string | null | undefined;
     }>;
-    sentAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+    sentAt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     actionCalls: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
         actionName: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -365,7 +365,7 @@ declare const widgetHistorySchema: z.ZodObject<{
         size: number;
         url: string;
     }[] | null | undefined;
-    sentAt?: Date | null | undefined;
+    sentAt?: string | null | undefined;
     actionCalls?: {
         actionName: string;
         args: Record<string, unknown>;
@@ -389,7 +389,7 @@ declare const widgetHistorySchema: z.ZodObject<{
         size: number;
         url: string;
     }[] | null | undefined;
-    sentAt?: Date | null | undefined;
+    sentAt?: string | null | undefined;
     actionCalls?: {
         actionName: string;
         args: Record<string, unknown>;
@@ -437,13 +437,12 @@ declare const widgetSessionSchema: z.ZodObject<{
     isOpened: boolean;
 }>;
 declare const httpChatInputDto: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
     content: z.ZodString;
     session_id: z.ZodString;
-    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
     bot_token: z.ZodString;
     query_params: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    user: z.ZodObject<{
+    user: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         phone: z.ZodOptional<z.ZodString>;
@@ -461,7 +460,7 @@ declare const httpChatInputDto: z.ZodObject<{
         avatar?: string | undefined;
         phone?: string | undefined;
         customData?: Record<string, string> | undefined;
-    }>;
+    }>>>;
     language: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     attachments: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -485,16 +484,7 @@ declare const httpChatInputDto: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     session_id: string;
     content: string;
-    user: {
-        email?: string | undefined;
-        name?: string | undefined;
-        avatar?: string | undefined;
-        phone?: string | undefined;
-        customData?: Record<string, string> | undefined;
-    };
-    headers: Record<string, string>;
     bot_token: string;
-    id?: string | undefined;
     language?: string | null | undefined;
     attachments?: {
         id: string;
@@ -503,20 +493,19 @@ declare const httpChatInputDto: z.ZodObject<{
         size: number;
         url: string;
     }[] | null | undefined;
-    query_params?: Record<string, string> | null | undefined;
-}, {
-    session_id: string;
-    content: string;
-    user: {
+    user?: {
         email?: string | undefined;
         name?: string | undefined;
         avatar?: string | undefined;
         phone?: string | undefined;
         customData?: Record<string, string> | undefined;
-    };
-    headers: Record<string, string>;
+    } | null | undefined;
+    headers?: Record<string, string> | null | undefined;
+    query_params?: Record<string, string> | null | undefined;
+}, {
+    session_id: string;
+    content: string;
     bot_token: string;
-    id?: string | undefined;
     language?: string | null | undefined;
     attachments?: {
         id: string;
@@ -525,11 +514,19 @@ declare const httpChatInputDto: z.ZodObject<{
         size: number;
         url: string;
     }[] | null | undefined;
+    user?: {
+        email?: string | undefined;
+        name?: string | undefined;
+        avatar?: string | undefined;
+        phone?: string | undefined;
+        customData?: Record<string, string> | undefined;
+    } | null | undefined;
+    headers?: Record<string, string> | null | undefined;
     query_params?: Record<string, string> | null | undefined;
 }>;
 declare const handleContactMessageOutputSchema: z.ZodDiscriminatedUnion<"success", [z.ZodObject<{
     success: z.ZodLiteral<true>;
-    code: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<"session_assigned_to_human_agent">]>>;
     options: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"options">;
         value: z.ZodArray<z.ZodString, "many">;