@opencx/widget 2.2.0 → 2.3.1

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

@@ -1,15 +1,29 @@
-import { ChatSessionType } from '../types/schemas';
-import { MessageData } from '../types/transport';
+import { HandleContactMessageOutputSchema, WidgetHistorySchema, WidgetPreludeSchema, WidgetSessionSchema } from '../types/schemas-v2';
+import { CoreOptions, SendMessageInput, ConsumerType } from '../types';
 export interface ApiCallerOptions {
     apiUrl: string;
     token: string;
+    coreOptions: CoreOptions;
 }
 export declare class ApiCaller {
+    #private;
     private readonly options;
     constructor(options: ApiCallerOptions);
-    createSession(): Promise<ChatSessionType>;
-    fetchSession(sessionId: string): Promise<ChatSessionType>;
-    ping(): Promise<void>;
-    getMessages(sessionId?: string): Promise<MessageData[]>;
-    sendMessage(message: MessageData): Promise<void>;
+    me(): Promise<{
+        contactId: string;
+        contactName: string;
+    }>;
+    widgetPrelude(): Promise<WidgetPreludeSchema>;
+    handleMessage(message: SendMessageInput): Promise<HandleContactMessageOutputSchema>;
+    getSessionHistory(sessionId: string, lastMessageTimestamp?: string): Promise<WidgetHistorySchema[]>;
+    createSession(): Promise<WidgetSessionSchema>;
+    getSession(sessionId: string): Promise<WidgetSessionSchema>;
+    createContact(user: {
+        external_id?: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        customData?: Record<string, string>;
+        avatarUrl?: string;
+    }): Promise<ConsumerType>;
 }

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

@@ -0,0 +1,62 @@
+import { PubSub } from '../types/pub-sub';
+import { MessageType } from '../types';
+import { ApiCaller } from './api';
+type ChatState = {
+    lastUpdated: number | null;
+    messages: MessageType[];
+    keyboard: {
+        options: string[];
+    } | null;
+};
+type ChatOptions = {
+    api: ApiCaller;
+    persistSession?: boolean;
+    useSoundEffects?: boolean;
+    onSessionDestroy?: () => void;
+};
+export declare function createChat(options: ChatOptions): {
+    chatState: PubSub<ChatState>;
+    sessionState: PubSub<{
+        id: string;
+        channel: string;
+        assignee: {
+            name: string | null;
+            kind: "unknown" | "ai" | "none" | "human";
+        };
+        createdAt: Date;
+        updatedAt: Date;
+        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>;
+    createSession: () => Promise<{
+        id: string;
+        channel: string;
+        assignee: {
+            name: string | null;
+            kind: "unknown" | "ai" | "none" | "human";
+        };
+        createdAt: Date;
+        updatedAt: Date;
+        isHandedOff: boolean;
+        isOpened: boolean;
+    }>;
+    clearSession: () => Promise<void>;
+    cleanup: () => void;
+};
+export {};

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

@@ -1,39 +1,9 @@
 import { CoreOptions } from '../types';
-import { Subscribable } from '../types/pub-sub';
-import { Platform } from '../platform';
-import { MessagingTransport } from '../transport/transport';
-import { MessageType, SendMessageInput } from '../types/messages';
-export declare class ApiClient extends Subscribable {
-    private readonly platform;
-    private messagingTransport;
-    private readonly options;
+export type RequiredOptions = Required<Omit<CoreOptions, 'contactToken'>> & {
+    contactToken: string | undefined | null;
+};
+export declare class ApiClient {
+    private readonly _options;
     private readonly api;
-    private readonly session;
-    private readonly events;
-    private messages;
-    private keyboard;
-    private pollingInterval?;
-    private heartbeatInterval?;
-    constructor(options: CoreOptions, platform?: Platform);
-    private startMessagePolling;
-    private startHeartbeat;
-    private appendMessages;
-    private handleIncomingMessage;
-    private refreshSession;
-    private initializeTransport;
-    sendMessage({ content, user, ...data }: SendMessageInput): Promise<void>;
-    setKeyboard(options: string[] | null): void;
-    handleKeyboardOption(option: string): void;
-    getMessages(): readonly MessageType[];
-    clearChat(): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    setTransport(transport: MessagingTransport): void;
-    get state(): {
-        connected: boolean;
-        session: import('../managers/session-manager').ChatSessionWithStatus | null;
-        messages: MessageType[];
-        keyboard: string[] | null;
-    };
-    protected cleanup(): void;
+    constructor(options: CoreOptions);
 }

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

@@ -0,0 +1,35 @@
+import { CoreOptions } from '../types';
+type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
+    contactToken: string | undefined | null;
+    soundEffectFiles: {
+        messageArrived: string;
+    };
+    theme: {
+        headerStyle: "compact" | "basic";
+        primaryColor: string;
+        triggerOffset: string;
+    };
+    settings: {
+        persistSession: boolean;
+        useSoundEffects: boolean;
+    };
+};
+type ConfigInstance = {
+    getConfig: () => NormalizedConfig;
+    getApiConfig: () => {
+        apiUrl: string;
+        token: string;
+        headers: Record<string, string>;
+        queryParams: Record<string, string>;
+        pathParams: Record<string, string>;
+    };
+    getBotConfig: () => NormalizedConfig['bot'];
+    getThemeConfig: () => NormalizedConfig['theme'];
+    getSettings: () => NormalizedConfig['settings'];
+    getSoundEffects: () => NormalizedConfig['soundEffectFiles'];
+    getUser: () => NormalizedConfig['user'];
+    getLanguage: () => string;
+    getDebugMode: () => boolean;
+};
+export declare function createConfig(options: CoreOptions): ConfigInstance;
+export {};

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

@@ -0,0 +1,32 @@
+import { PubSub } from '../types/pub-sub';
+import { ApiCaller } from './api';
+import { Platform } from '../platform';
+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;
+    };
+};
+export declare function createContact(options: ContactOptions): {
+    shouldCollectData: () => {
+        should: boolean;
+        reason?: string;
+    };
+    cleanup: () => void;
+    contactState: PubSub<{
+        email: string | null;
+        id: string;
+        name: string | null;
+        avatar_url: string | null;
+        created_at: string;
+    } | null>;
+};
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

package/dist/core/index.d.ts

@@ -1,3 +1,8 @@
 export * from './client';
 export * from './errors';
-export type { CoreOptions } from './types';
+export * from './types';
+export * from './platform';
+export { createChat } from './client/chat';
+export { createContact } from './client/contact';
+export { createConfig } from './client/config';
+export { ApiCaller } from './client/api';

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

@@ -8,13 +8,4 @@ export interface Platform {
         toISOString(date: number): string;
     };
 }
-export declare class DefaultPlatform implements Platform {
-    env: {
-        platform: string;
-    };
-    date: {
-        now: () => number;
-        toISOString: (date: number) => string;
-    };
-    private detectPlatform;
-}
+export declare function createDefaultPlatform(): Platform;

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

@@ -1,7 +1,7 @@
+import { ChatAttachmentType } from './schemas';
 export * from './messages';
 export * from './schemas';
 export * from './pub-sub';
-export * from './transport';
 export * from './helpers';
 export interface User {
     external_id?: string;
@@ -11,10 +11,19 @@ export interface User {
     customData?: Record<string, string>;
     avatarUrl?: string;
 }
+export interface SendMessageInput extends Record<string, unknown> {
+    content: {
+        text: string;
+    };
+    attachments?: Array<ChatAttachmentType>;
+    id?: string;
+    language?: string;
+    user?: User;
+}
 export interface CoreOptions {
     token: string;
     apiUrl?: string;
-    transport?: "socket" | "http";
+    transport?: 'socket' | 'http';
     socketUrl?: string;
     headers?: Record<string, string>;
     queryParams?: Record<string, string>;
@@ -22,6 +31,7 @@ export interface CoreOptions {
     debug?: boolean;
     language?: string;
     user?: User;
+    contactToken?: string;
     bot?: {
         name?: string;
         avatarUrl?: string;
@@ -29,4 +39,16 @@ export interface CoreOptions {
         is_ai?: boolean;
     };
     pollingInterval?: number;
+    soundEffectFiles?: {
+        messageArrived?: string;
+    };
+    theme?: {
+        headerStyle?: "compact" | "basic";
+        primaryColor?: string;
+        triggerOffset?: string;
+    };
+    settings?: {
+        persistSession?: boolean;
+        useSoundEffects?: boolean;
+    };
 }

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

@@ -1,94 +1,31 @@
-/**
- * Base interface for event maps. All event maps must extend this.
- * @example
- * ```typescript
- * interface MyEvents extends EventMap {
- *   "my:event": string
- *   "my:other:event": { data: number }
- * }
- * ```
- */
-export interface EventMap {
-    [key: string]: any;
-}
-/**
- * Event subscriber function type
- */
 export type Subscriber<T> = (data: T) => void;
-/**
- * Generic PubSub class that can be typed with specific event maps.
- * Each component should create its own instance with its specific events.
- *
- * @example
- * ```typescript
- * interface MyEvents extends EventMap {
- *   "my:event": string
- * }
- *
- * const pubSub = new PubSub<MyEvents>();
- *
- * pubSub.subscribe("my:event", (data) => {
- *   console.log(data.toUpperCase()); // Type-safe: data is string
- * });
- * ```
- */
-export declare class PubSub<T extends EventMap> {
+export declare class PubSub<S> {
+    #private;
     private subscribers;
+    private initialState;
+    constructor(state: S);
     /**
-     * Subscribe to an event
-     * @param event Event name to subscribe to
-     * @param callback Function to call when event is published
+     * Subscribe to state changes
+     * @param callback Function to call when state changes
      * @returns Unsubscribe function
      */
-    subscribe<K extends keyof T>(event: K, callback: Subscriber<T[K]>): () => void;
-    /**
-     * Publish an event with data
-     * @param event Event name to publish
-     * @param data Data to send with the event
-     */
-    publish<K extends keyof T>(event: K, data: T[K]): void;
-    /**
-     * Clear all subscriptions
-     */
-    clear(): void;
-}
-/**
- * Abstract base class for components that need subscription management.
- * Provides common functionality for managing subscriptions and cleanup.
- *
- * @example
- * ```typescript
- * class MyComponent extends Subscribable {
- *   constructor() {
- *     super();
- *     // Add unsubscribers
- *     this.addUnsubscriber(() => {
- *       console.log('Cleanup');
- *     });
- *   }
- *
- *   protected cleanup(): void {
- *     // Component-specific cleanup
- *   }
- * }
- * ```
- */
-export declare abstract class Subscribable {
-    protected unsubscribers: (() => void)[];
+    subscribe(callback: Subscriber<S>): () => void;
     /**
-     * Add an unsubscribe function to be called during cleanup
+     * Get the current state
      */
-    protected addUnsubscriber(unsubscribe: () => void): void;
+    getState(): S;
     /**
-     * Dispose of all subscriptions and perform cleanup
+     * Set the state and notify subscribers if the state changes
+     * @param newState The new state to set
      */
-    dispose(): void;
+    setState(newState: S): void;
+    setStatePartial(_s: Partial<S>): void;
     /**
-     * Component-specific cleanup logic
+     * Clear all subscriptions
      */
-    protected abstract cleanup(): void;
+    clear(): void;
+    reset(): void;
+    getSnapshot(): S;
+    get state(): S;
 }
-/**
- * Helper function to create a strongly typed PubSub instance
- */
-export declare function createPubSub<T extends EventMap>(): PubSub<T>;
+export declare function createPubSub<S>(state: S): PubSub<S>;