@opencx/widget 2.0.0

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

@@ -0,0 +1,15 @@
+import { ChatSessionType } from '../types/schemas';
+import { MessageData } from '../types/transport';
+export interface ApiCallerOptions {
+    apiUrl: string;
+    token: string;
+}
+export declare class ApiCaller {
+    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>;
+}

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

@@ -0,0 +1,39 @@
+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;
+    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;
+}

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

@@ -0,0 +1 @@
+export * from './client';

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

@@ -0,0 +1,21 @@
+export declare class OpenCopilotError extends Error {
+    constructor(message: string);
+}
+export declare class ConnectionError extends OpenCopilotError {
+    constructor(message?: string);
+}
+export declare class AuthenticationError extends OpenCopilotError {
+    constructor(message?: string);
+}
+export declare class SessionError extends OpenCopilotError {
+    constructor(message?: string);
+}
+export declare class SessionNotDefinedError extends SessionError {
+    constructor(message?: string);
+}
+export declare class TransportError extends OpenCopilotError {
+    constructor(message?: string);
+}
+export declare class FileUploadError extends OpenCopilotError {
+    constructor(message?: string);
+}

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './errors';
+export type { CoreOptions } from './types';

package/dist/core/managers/chathistory-manager.d.ts

@@ -0,0 +1,61 @@
+import { ChatHistoryMessageType, MessageType, UserMessageType } from '../types';
+import { EventMap, PubSub } from '../types/pub-sub';
+/**
+ * Events emitted by the ChatHistoryManager
+ */
+export interface ChatHistoryEvents extends EventMap {
+    "history:message:added": MessageType;
+    "history:message:updated": MessageType;
+    "history:updated": MessageType[];
+    "history:cleared": void;
+}
+/**
+ * Manages chat history and message operations.
+ * Uses a strongly typed event system for history-related events.
+ *
+ * @example
+ * ```typescript
+ * const history = new ChatHistoryManager();
+ *
+ * // Subscribe to events
+ * history.on('history:message:added', (message) => {
+ *   console.log('New message:', message);
+ * });
+ *
+ * // Add messages
+ * history.appendUserMessage({
+ *   id: '123',
+ *   type: 'FROM_USER',
+ *   content: 'Hello'
+ * });
+ * ```
+ */
+export declare class ChatHistoryManager extends PubSub<ChatHistoryEvents> {
+    private messages;
+    private lastUpdated;
+    constructor();
+    /**
+     * Subscribe to history events
+     * @param event Event name to subscribe to
+     * @param callback Callback function to handle the event
+     * @returns Unsubscribe function
+     */
+    on<K extends keyof ChatHistoryEvents>(event: K, callback: (data: ChatHistoryEvents[K]) => void): () => void;
+    private handleNewMessage;
+    private handleHistoryUpdate;
+    private notifyHistoryUpdate;
+    addResponseMessage(message: MessageType): void;
+    appendUserMessage(message: UserMessageType): void;
+    prependHistory(historyMessages: MessageType[]): void;
+    setDeliveredAt(clientMessageId: string, deliveredAt: string): void;
+    setMessages(messages: MessageType[]): void;
+    appendMessages(newMessages: MessageType[]): void;
+    reset(): void;
+    getMessages(): readonly MessageType[];
+    getLastUpdated(): number | null;
+    getLastMessageTimestamp(): string | undefined;
+    isEmpty(): boolean;
+    mapHistoryMessages(historyMessages: ChatHistoryMessageType[]): MessageType[];
+    private updateTimestamp;
+    protected cleanup(): void;
+}

package/dist/core/managers/session-manager.d.ts

@@ -0,0 +1,35 @@
+import { EventMap, PubSub } from '../types/pub-sub';
+import { ChatSessionType } from '../types/schemas';
+import { ApiCaller } from '../client/api';
+export type ChatSessionWithStatus = ChatSessionType & {
+    isSessionClosed: boolean;
+    isAssignedToAi: boolean;
+    isAssignedToHuman: boolean;
+    isPendingHuman: boolean;
+};
+/**
+ * Events emitted by the SessionManager
+ */
+interface SessionEvents extends EventMap {
+    "session:updated": ChatSessionType;
+    "session:created": ChatSessionType;
+    "session:closed": {
+        sessionId: string;
+    };
+    "session:error": {
+        error: Error;
+    };
+}
+export declare class SessionManager extends PubSub<SessionEvents> {
+    #private;
+    private readonly httpClient;
+    constructor(httpClient: ApiCaller, initialSession?: ChatSessionType);
+    get currentSession(): ChatSessionWithStatus | null;
+    setSession(session: ChatSessionType): void;
+    clearSession: () => void;
+    createSession(): Promise<ChatSessionType>;
+    getOrCreateSession(): Promise<ChatSessionType>;
+    refreshSession(sessionId: string): Promise<ChatSessionType | null>;
+    protected cleanup(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+export interface Platform {
+    storage?: Storage;
+    env: {
+        platform: string;
+    };
+    date: {
+        now(): number;
+        toISOString(date: number): string;
+    };
+}
+export declare class DefaultPlatform implements Platform {
+    env: {
+        platform: string;
+    };
+    date: {
+        now: () => number;
+        toISOString: (date: number) => string;
+    };
+    private detectPlatform;
+}

package/dist/core/transport/http.transport.d.ts

@@ -0,0 +1,17 @@
+import { Platform } from '../platform';
+import { MessageData, TransportOptions } from '../types/transport';
+import { MessagingTransport } from './transport';
+interface HttpTransportOptions extends TransportOptions {
+    pollingInterval: number;
+}
+export declare class HttpTransport extends MessagingTransport {
+    private readonly httpOptions;
+    private readonly platform;
+    private pollingInterval?;
+    constructor(httpOptions: HttpTransportOptions, platform?: Platform);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendMessage(message: MessageData): Promise<void>;
+    private startPolling;
+}
+export {};

package/dist/core/transport/transport.d.ts

@@ -0,0 +1,25 @@
+import { MessageData, TransportOptions } from '../types/transport';
+import { PubSub } from '../types/pub-sub';
+export interface TransportEvents extends Record<string, any> {
+    "transport:message:received": MessageData;
+    "transport:error": {
+        error: Error;
+    };
+    "transport:status": {
+        status: "connected" | "disconnected";
+    };
+}
+export interface TransportState {
+    connected: boolean;
+}
+export declare abstract class MessagingTransport extends PubSub<TransportEvents> {
+    #private;
+    protected readonly options: TransportOptions;
+    constructor(options: TransportOptions);
+    abstract connect(): Promise<void>;
+    abstract disconnect(): void;
+    abstract sendMessage(message: MessageData): Promise<void>;
+    protected setState(newState: Partial<TransportState>): void;
+    isConnected(): boolean;
+    getState(): TransportState;
+}

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

@@ -0,0 +1,5 @@
+export type PromiseType<P extends Promise<unknown>> = P extends Promise<infer T> ? T : never;
+export type FunctionReturningPromise = (...args: any[]) => Promise<any>;
+export type MakeKeysNotNullable<T, K extends keyof T> = Omit<T, K> & {
+    [P in K]-?: NonNullable<T[P]>;
+};

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

@@ -0,0 +1,32 @@
+export * from './messages';
+export * from './schemas';
+export * from './pub-sub';
+export * from './transport';
+export * from './helpers';
+export interface User {
+    external_id?: string;
+    name?: string;
+    email?: string;
+    phone?: string;
+    customData?: Record<string, string>;
+    avatarUrl?: string;
+}
+export interface CoreOptions {
+    token: string;
+    apiUrl?: string;
+    transport?: "socket" | "http";
+    socketUrl?: string;
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    debug?: boolean;
+    language?: string;
+    user?: User;
+    bot?: {
+        name?: string;
+        avatarUrl?: string;
+        id?: number | null;
+        is_ai?: boolean;
+    };
+    pollingInterval?: number;
+}

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

@@ -0,0 +1,43 @@
+import { AgentType, ChatAttachmentType, ChatHistoryMessageType } from './schemas';
+export type UserMessageType = {
+    id: string;
+    type: "FROM_USER";
+    content: string;
+    deliveredAt: string | null;
+    attachments?: ChatAttachmentType[];
+    timestamp?: string;
+    user?: {
+        name?: string;
+        email?: string;
+        phone?: string;
+        customData?: Record<string, string>;
+        avatarUrl?: string;
+    };
+};
+export type BotMessageType<TData = unknown> = {
+    id: string;
+    type: "FROM_BOT";
+    component: string;
+    data: TData;
+    timestamp?: string;
+    original?: ChatHistoryMessageType;
+    agent?: AgentType;
+    attachments?: ChatAttachmentType[];
+};
+export type MessageType = UserMessageType | BotMessageType;
+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/core/types/prelude.d.ts

@@ -0,0 +1,14 @@
+export interface PreludeData {
+    initial_questions?: string[];
+    organization_name?: string;
+}
+export interface WorkingHours {
+    timezone: string;
+    weekdays: {
+        [key: string]: {
+            enabled: boolean;
+            start: string;
+            end: string;
+        };
+    };
+}

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

@@ -0,0 +1,94 @@
+/**
+ * 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> {
+    private subscribers;
+    /**
+     * Subscribe to an event
+     * @param event Event name to subscribe to
+     * @param callback Function to call when event is published
+     * @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)[];
+    /**
+     * Add an unsubscribe function to be called during cleanup
+     */
+    protected addUnsubscriber(unsubscribe: () => void): void;
+    /**
+     * Dispose of all subscriptions and perform cleanup
+     */
+    dispose(): void;
+    /**
+     * Component-specific cleanup logic
+     */
+    protected abstract cleanup(): void;
+}
+/**
+ * Helper function to create a strongly typed PubSub instance
+ */
+export declare function createPubSub<T extends EventMap>(): PubSub<T>;