@om_patel_26/chat-widget 1.0.1

package/dist/services/chatService.d.ts

@@ -0,0 +1,144 @@
+export interface SupportChatSession {
+    chat_id: string;
+    session_id: string;
+}
+export interface SupportMessage {
+    id?: string;
+    sender_type: "customer" | "agent";
+    content: string;
+    timestamp: string;
+}
+export interface ChatInfo {
+    status: "waiting" | "active";
+    agent_id?: string;
+}
+export interface WebSocketMessage {
+    type: "message" | "chat_info" | "error" | "typing_start" | "typing_stop" | "agent_changed" | "agent_accepted" | "chat_resolved" | "chat_ended" | "ping" | "pong";
+    id?: string;
+    chat_id?: string;
+    sender_type?: "customer" | "agent";
+    sender_id?: string;
+    content?: string;
+    timestamp?: string;
+    status?: "waiting" | "active" | "resolved" | "ended";
+    agent_id?: string;
+    error?: string;
+    from_agent?: string;
+    to_agent?: string;
+    to_agent_id?: string;
+    reason?: string;
+    message?: string;
+}
+export declare class ChatResolvedError extends Error {
+    reason: "chat_resolved";
+    constructor(message?: string);
+}
+export interface ChatServiceConfig {
+    baseUrl?: string;
+    wsUrl?: string;
+    debug?: boolean;
+}
+export interface StartSupportChatOptions {
+    dialogflowSessionId?: string | null;
+    customerName?: string | null;
+    customerEmail?: string | null;
+    customerMobile?: string | null;
+}
+declare class ChatService {
+    private baseUrl;
+    private wsUrl;
+    private debug;
+    private ws;
+    private wsReconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private currentChatId;
+    private currentSessionId;
+    private messageHandlers;
+    private connectionHandlers;
+    private sessionManager;
+    constructor(config?: ChatServiceConfig);
+    /**
+     * Start a new support chat session
+     * @param dialogflowSessionId - Optional: Dialogflow session ID
+     * @param customerName - Optional: Customer name
+     * @param customerEmail - Optional: Customer email
+     * @param customerMobile - Optional: Customer mobile number
+     */
+    startSupportChat(dialogflowSessionId?: string | null, customerName?: string | null, customerEmail?: string | null, customerMobile?: string | null): Promise<SupportChatSession>;
+    /**
+     * Request handoff to human agent
+     * @param chatId - Chat ID (must be valid, not undefined)
+     * @param sessionId - Session ID
+     * @param reason - Optional: Reason for handoff
+     * @param dialogflowSessionId - Optional: Dialogflow session ID
+     * @param customerName - Optional: Customer name
+     * @param customerEmail - Optional: Customer email
+     * @param customerMobile - Optional: Customer mobile number
+     */
+    requestHandoff(chatId: string, sessionId: string, reason?: string, dialogflowSessionId?: string | null, customerName?: string | null, customerEmail?: string | null, customerMobile?: string | null): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Send message to agent via REST API
+     */
+    sendMessageToAgent(chatId: string, sessionId: string, message: string): Promise<SupportMessage>;
+    /**
+     * Ensure chat is initialized - helper method
+     * Returns existing chat_id if valid, otherwise initializes new chat
+     * @param existingChatId - Existing chat ID to validate
+     * @param existingSessionId - Existing session ID
+     * @param dialogflowSessionId - Optional: Dialogflow session ID
+     * @param customerName - Optional: Customer name
+     * @param customerEmail - Optional: Customer email
+     * @param customerMobile - Optional: Customer mobile number
+     * @returns Promise with chat_id and session_id
+     */
+    ensureChatInitialized(existingChatId?: string | null, existingSessionId?: string | null, dialogflowSessionId?: string | null, customerName?: string | null, customerEmail?: string | null, customerMobile?: string | null): Promise<SupportChatSession>;
+    /**
+     * Load message history
+     */
+    loadMessageHistory(chatId: string, sessionId: string): Promise<SupportMessage[]>;
+    /**
+     * Connect to WebSocket
+     */
+    connectWebSocket(chatId: string, sessionId: string, onMessage?: (message: WebSocketMessage) => void, onConnectionChange?: (connected: boolean) => void, onClose?: (event: CloseEvent) => void): void;
+    /**
+     * Send message via WebSocket
+     */
+    sendMessageViaWebSocket(message: string): boolean;
+    /**
+     * Send typing indicator via WebSocket
+     */
+    sendTypingIndicator(type: "typing_start" | "typing_stop"): boolean;
+    /**
+     * Start ping interval to keep connection alive
+     */
+    private startPingInterval;
+    /**
+     * Stop ping interval
+     */
+    private stopPingInterval;
+    /**
+     * Disconnect WebSocket
+     */
+    disconnectWebSocket(): void;
+    /**
+     * Check if WebSocket is connected
+     */
+    isWebSocketConnected(): boolean;
+    /**
+     * Remove message handler
+     */
+    removeMessageHandler(handler: (message: WebSocketMessage) => void): void;
+    /**
+     * Remove connection handler
+     */
+    removeConnectionHandler(handler: (connected: boolean) => void): void;
+}
+export declare function getChatService(config?: ChatServiceConfig): ChatService;
+export declare function createChatService(config: ChatServiceConfig): ChatService;
+export {};
+//# sourceMappingURL=chatService.d.ts.map

package/dist/services/chatService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatService.d.ts","sourceRoot":"","sources":["../../src/services/chatService.ts"],"names":[],"mappings":"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"}

package/dist/services/chatService.esm.js

@@ -0,0 +1,482 @@
+import { getSessionManager } from "./sessionManager.esm.js";
+class ChatResolvedError extends Error {
+  constructor(message = "chat_resolved") {
+    super(message);
+    this.reason = "chat_resolved";
+    this.name = "ChatResolvedError";
+  }
+}
+const DEFAULT_BASE_URL = typeof process !== "undefined" && process.env?.REACT_APP_BACKEND_BASE_URL;
+const DEFAULT_WS_URL = typeof process !== "undefined" && process.env?.REACT_APP_BACKEND_WS_URL;
+class ChatService {
+  constructor(config = {}) {
+    this.ws = null;
+    this.wsReconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectTimeout = null;
+    this.pingInterval = null;
+    this.currentChatId = null;
+    this.currentSessionId = null;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.connectionHandlers = /* @__PURE__ */ new Set();
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.wsUrl = config.wsUrl || DEFAULT_WS_URL;
+    this.debug = config.debug || false;
+    this.sessionManager = getSessionManager();
+  }
+  /**
+   * Start a new support chat session
+   * @param dialogflowSessionId - Optional: Dialogflow session ID
+   * @param customerName - Optional: Customer name
+   * @param customerEmail - Optional: Customer email
+   * @param customerMobile - Optional: Customer mobile number
+   */
+  async startSupportChat(dialogflowSessionId, customerName, customerEmail, customerMobile) {
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.sessionManager.getSessionHeader()
+      };
+      if (dialogflowSessionId) {
+        headers["X-Session-ID"] = dialogflowSessionId;
+      }
+      const body = {};
+      if (customerName) body.name = customerName;
+      if (customerEmail) body.email = customerEmail;
+      if (customerMobile) body.mobile = customerMobile;
+      const response = await fetch(`${this.baseUrl}/api/support/chat/start`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      this.sessionManager.updateSessionFromResponse(data);
+      if (data.status && data.data) {
+        return {
+          chat_id: data.data.chat_id,
+          session_id: data.data.session_id
+        };
+      }
+      if (data.chat_id && data.session_id) {
+        return {
+          chat_id: data.chat_id,
+          session_id: data.session_id
+        };
+      }
+      throw new Error("Invalid response format from chat start endpoint");
+    } catch (error) {
+      console.error("Error starting support chat:", error);
+      throw new Error(
+        error.message || "Failed to start support chat session"
+      );
+    }
+  }
+  /**
+   * Request handoff to human agent
+   * @param chatId - Chat ID (must be valid, not undefined)
+   * @param sessionId - Session ID
+   * @param reason - Optional: Reason for handoff
+   * @param dialogflowSessionId - Optional: Dialogflow session ID
+   * @param customerName - Optional: Customer name
+   * @param customerEmail - Optional: Customer email
+   * @param customerMobile - Optional: Customer mobile number
+   */
+  async requestHandoff(chatId, sessionId, reason, dialogflowSessionId, customerName, customerEmail, customerMobile) {
+    if (!chatId || chatId === "undefined" || chatId === "null") {
+      throw new Error("Invalid chat_id. Chat must be initialized first.");
+    }
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.sessionManager.getSessionHeader()
+      };
+      if (sessionId) {
+        headers["X-Session-ID"] = sessionId;
+      } else if (dialogflowSessionId) {
+        headers["X-Session-ID"] = dialogflowSessionId;
+      }
+      const body = {};
+      if (reason) body.reason = reason;
+      if (customerName) body.name = customerName;
+      if (customerEmail) body.email = customerEmail;
+      if (customerMobile) body.mobile = customerMobile;
+      const response = await fetch(
+        `${this.baseUrl}/api/support/chat/${chatId}/handoff`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        }
+      );
+      if (response.status === 400 || response.status === 404) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || "Invalid chat_id. Chat may have expired."
+        );
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      this.sessionManager.updateSessionFromResponse(data);
+      if (data.status) {
+        return {
+          success: true,
+          message: data.message || data.data?.message
+        };
+      }
+      return {
+        success: true,
+        message: data.message
+      };
+    } catch (error) {
+      console.error("Error requesting handoff:", error);
+      throw error;
+    }
+  }
+  /**
+   * Send message to agent via REST API
+   */
+  async sendMessageToAgent(chatId, sessionId, message) {
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.sessionManager.getSessionHeader()
+      };
+      if (sessionId) {
+        headers["X-Session-ID"] = sessionId;
+      }
+      const response = await fetch(
+        `${this.baseUrl}/api/support/chat/${chatId}/message`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            content: message
+          })
+        }
+      );
+      if (response.status === 401 || response.status === 404) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || "Chat not found or unauthorized"
+        );
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      this.sessionManager.updateSessionFromResponse(data);
+      if (data?.ignored === true && data?.reason === "chat_resolved") {
+        throw new ChatResolvedError();
+      }
+      return {
+        id: data.id,
+        sender_type: "customer",
+        content: message,
+        timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      if (error instanceof ChatResolvedError || error?.name === "ChatResolvedError") {
+        throw error;
+      }
+      console.error("Error sending message to agent:", error);
+      throw new Error(error.message || "Failed to send message to agent");
+    }
+  }
+  /**
+   * Ensure chat is initialized - helper method
+   * Returns existing chat_id if valid, otherwise initializes new chat
+   * @param existingChatId - Existing chat ID to validate
+   * @param existingSessionId - Existing session ID
+   * @param dialogflowSessionId - Optional: Dialogflow session ID
+   * @param customerName - Optional: Customer name
+   * @param customerEmail - Optional: Customer email
+   * @param customerMobile - Optional: Customer mobile number
+   * @returns Promise with chat_id and session_id
+   */
+  async ensureChatInitialized(existingChatId, existingSessionId, dialogflowSessionId, customerName, customerEmail, customerMobile) {
+    if (existingChatId && existingChatId !== "undefined" && existingChatId !== "null" && existingSessionId) {
+      return {
+        chat_id: existingChatId,
+        session_id: existingSessionId
+      };
+    }
+    return await this.startSupportChat(
+      dialogflowSessionId || null,
+      customerName || null,
+      customerEmail || null,
+      customerMobile || null
+    );
+  }
+  /**
+   * Load message history
+   */
+  async loadMessageHistory(chatId, sessionId) {
+    try {
+      const headers = {
+        ...this.sessionManager.getSessionHeader()
+      };
+      if (sessionId) {
+        headers["X-Session-ID"] = sessionId;
+      }
+      const response = await fetch(
+        `${this.baseUrl}/api/support/chat/${chatId}/messages`,
+        {
+          method: "GET",
+          headers
+        }
+      );
+      if (response.status === 401 || response.status === 404) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || "Chat not found or unauthorized"
+        );
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(
+          error.message || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      this.sessionManager.updateSessionFromResponse(data);
+      return data.messages || [];
+    } catch (error) {
+      console.error("Error loading message history:", error);
+      throw new Error(error.message || "Failed to load message history");
+    }
+  }
+  /**
+   * Connect to WebSocket
+   */
+  connectWebSocket(chatId, sessionId, onMessage, onConnectionChange, onClose) {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      if (this.debug) {
+        console.log("WebSocket already connected");
+      }
+      return;
+    }
+    this.currentChatId = chatId;
+    this.currentSessionId = sessionId;
+    if (onMessage) {
+      this.messageHandlers.add(onMessage);
+    }
+    if (onConnectionChange) {
+      this.connectionHandlers.add(onConnectionChange);
+    }
+    const sessionIdToUse = sessionId || this.sessionManager.getSessionId() || "";
+    const wsUrl = `${this.wsUrl}/ws/support/${chatId}?X-Session-ID=${encodeURIComponent(sessionIdToUse)}`;
+    try {
+      this.ws = new WebSocket(wsUrl);
+      this.ws.onopen = () => {
+        if (this.debug) {
+          console.log("WebSocket connected to:", wsUrl);
+        }
+        console.log("✅ Customer WebSocket connected:", { chatId, sessionId, wsUrl });
+        this.wsReconnectAttempts = 0;
+        this.connectionHandlers.forEach((handler) => handler(true));
+        this.startPingInterval();
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (this.debug) {
+            console.log("WebSocket raw message received:", event.data);
+            console.log("WebSocket parsed message:", message);
+          }
+          if (message.session_id) {
+            this.sessionManager.updateSessionFromResponse({ session_id: message.session_id });
+          }
+          if (message.type === "agent_accepted" || message.type === "chat_resolved" || message.type === "chat_ended") {
+            console.log("🔔 Received notification message:", {
+              type: message.type,
+              chat_id: message.chat_id,
+              timestamp: message.timestamp,
+              to_agent: message.to_agent,
+              to_agent_id: message.to_agent_id
+            });
+          }
+          if (message.type === "pong") {
+            return;
+          }
+          if (this.debug && message.type === "message") {
+            console.log("Processing message type:", {
+              type: message.type,
+              sender_type: message.sender_type,
+              content: message.content?.substring(0, 50) + "...",
+              id: message.id
+            });
+          }
+          this.messageHandlers.forEach((handler) => handler(message));
+        } catch (error) {
+          console.error("Error parsing WebSocket message:", error);
+          if (this.debug) {
+            console.error("Raw message data:", event.data);
+          }
+        }
+      };
+      this.ws.onerror = (error) => {
+        console.error("❌ WebSocket error:", error);
+        this.connectionHandlers.forEach((handler) => handler(false));
+      };
+      this.ws.onclose = (event) => {
+        if (this.debug) {
+          console.log("WebSocket closed:", event.code, event.reason);
+        }
+        console.log("🔌 Customer WebSocket closed:", { code: event.code, reason: event.reason, chatId });
+        this.stopPingInterval();
+        this.connectionHandlers.forEach((handler) => handler(false));
+        this.ws = null;
+        onClose?.(event);
+        if (event.code === 4e3) {
+          this.wsReconnectAttempts = this.maxReconnectAttempts;
+          this.currentChatId = null;
+          this.currentSessionId = null;
+          return;
+        }
+        if (this.wsReconnectAttempts < this.maxReconnectAttempts && this.currentChatId && this.currentSessionId) {
+          this.wsReconnectAttempts++;
+          const delay = Math.min(1e3 * Math.pow(2, this.wsReconnectAttempts), 3e4);
+          if (this.debug) {
+            console.log(`Reconnecting in ${delay}ms (attempt ${this.wsReconnectAttempts}/${this.maxReconnectAttempts})`);
+          }
+          this.reconnectTimeout = setTimeout(() => {
+            if (this.currentChatId && this.currentSessionId) {
+              this.connectWebSocket(this.currentChatId, this.currentSessionId, onMessage, onConnectionChange, onClose);
+            }
+          }, delay);
+        } else if (this.debug) {
+          console.error("Max reconnection attempts reached");
+        }
+      };
+    } catch (error) {
+      console.error("Error creating WebSocket connection:", error);
+      this.connectionHandlers.forEach((handler) => handler(false));
+    }
+  }
+  /**
+   * Send message via WebSocket
+   */
+  sendMessageViaWebSocket(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(
+        JSON.stringify({
+          type: "message",
+          content: message
+        })
+      );
+      return true;
+    } catch (error) {
+      console.error("Error sending message via WebSocket:", error);
+      return false;
+    }
+  }
+  /**
+   * Send typing indicator via WebSocket
+   */
+  sendTypingIndicator(type) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(
+        JSON.stringify({
+          type
+        })
+      );
+      return true;
+    } catch (error) {
+      console.error(`Error sending ${type} via WebSocket:`, error);
+      return false;
+    }
+  }
+  /**
+   * Start ping interval to keep connection alive
+   */
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send(JSON.stringify({ type: "ping" }));
+        } catch (error) {
+          console.error("Error sending ping:", error);
+        }
+      }
+    }, 3e4);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Disconnect WebSocket
+   */
+  disconnectWebSocket() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.stopPingInterval();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.messageHandlers.clear();
+    this.connectionHandlers.clear();
+    this.wsReconnectAttempts = 0;
+    this.currentChatId = null;
+    this.currentSessionId = null;
+  }
+  /**
+   * Check if WebSocket is connected
+   */
+  isWebSocketConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Remove message handler
+   */
+  removeMessageHandler(handler) {
+    this.messageHandlers.delete(handler);
+  }
+  /**
+   * Remove connection handler
+   */
+  removeConnectionHandler(handler) {
+    this.connectionHandlers.delete(handler);
+  }
+}
+function createChatService(config) {
+  return new ChatService(config);
+}
+export {
+  ChatResolvedError,
+  createChatService
+};
+//# sourceMappingURL=chatService.esm.js.map