@diffsome/sdk 3.2.7 → 3.2.9

package/dist/index.mjs

@@ -1639,6 +1639,366 @@ var ReservationResource = class {
   }
 };
 
+// src/resources/site.ts
+var SiteResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get site information
+   * Returns site settings including currency, SEO, contact info
+   */
+  async getInfo() {
+    return this.http.get("/site");
+  }
+  /**
+   * Get currency info only (lightweight)
+   */
+  async getCurrency() {
+    const response = await this.http.get("/site/currency");
+    return response.currency;
+  }
+  /**
+   * Format price with site's currency settings
+   * @param amount - The amount to format
+   * @param currency - Optional currency info (uses fetched currency if not provided)
+   */
+  formatPrice(amount, currency) {
+    const formatted = amount.toLocaleString(void 0, {
+      minimumFractionDigits: currency.decimals,
+      maximumFractionDigits: currency.decimals
+    });
+    if (currency.position === "after") {
+      return `${formatted}${currency.symbol}`;
+    }
+    return `${currency.symbol}${formatted}`;
+  }
+};
+
+// src/resources/chat.ts
+var ChatResource = class {
+  constructor(http) {
+    this.http = http;
+    this.lastMessageIds = /* @__PURE__ */ new Map();
+    this.visitorId = null;
+    this.reverbConfig = null;
+    this.websocket = null;
+    this.subscribedChannels = /* @__PURE__ */ new Set();
+    if (typeof localStorage !== "undefined") {
+      this.visitorId = localStorage.getItem("diffsome_visitor_id");
+    }
+  }
+  /**
+   * Configure WebSocket connection (Laravel Reverb)
+   */
+  configureWebSocket(config) {
+    this.reverbConfig = config;
+  }
+  /**
+   * Start a new chat conversation
+   */
+  async start(data = {}) {
+    const response = await this.http.post("/chat/conversations", data);
+    this.visitorId = response.visitor_id;
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem("diffsome_visitor_id", this.visitorId);
+    }
+    return response;
+  }
+  /**
+   * Get list of conversations
+   */
+  async list(params) {
+    return this.http.request("/chat/conversations", {
+      method: "GET",
+      params,
+      headers: this.getVisitorHeader()
+    });
+  }
+  /**
+   * Get conversation details
+   */
+  async get(conversationId) {
+    return this.http.request(
+      `/chat/conversations/${conversationId}`,
+      {
+        method: "GET",
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Send a message
+   */
+  async send(conversationId, data) {
+    return this.http.request(
+      `/chat/conversations/${conversationId}/messages`,
+      {
+        method: "POST",
+        body: data,
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Get messages for a conversation
+   */
+  async getMessages(conversationId, params) {
+    return this.http.request(
+      `/chat/conversations/${conversationId}/messages`,
+      {
+        method: "GET",
+        params,
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Poll for new messages (fallback when WebSocket not available)
+   */
+  async poll(conversationId, lastMessageId) {
+    return this.http.request(
+      `/chat/conversations/${conversationId}/poll`,
+      {
+        method: "GET",
+        params: { last_id: lastMessageId },
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Close conversation
+   */
+  async close(conversationId) {
+    await this.http.request(
+      `/chat/conversations/${conversationId}/close`,
+      {
+        method: "POST",
+        body: {},
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Send typing indicator
+   */
+  async sendTyping(conversationId) {
+    await this.http.request(
+      `/chat/conversations/${conversationId}/typing`,
+      {
+        method: "POST",
+        body: {},
+        headers: this.getVisitorHeader()
+      }
+    );
+  }
+  /**
+   * Check agent availability
+   */
+  async checkAvailability() {
+    return this.http.get("/chat/availability");
+  }
+  /**
+   * Connect to a conversation with real-time updates
+   * Uses WebSocket if configured, falls back to polling
+   */
+  connect(conversationId) {
+    const messageListeners = [];
+    const statusListeners = [];
+    const typingListeners = [];
+    let pollingActive = false;
+    let pollingTimeout = null;
+    let wsChannel = null;
+    const connectWebSocket = async () => {
+      if (!this.reverbConfig) {
+        startPolling();
+        return;
+      }
+      try {
+        const channelName = `private-chat.conversation.${conversationId}`;
+        const authResponse = await this.http.request(
+          "/broadcasting/auth",
+          {
+            method: "POST",
+            body: {
+              socket_id: this.generateSocketId(),
+              channel_name: channelName
+            },
+            headers: this.getVisitorHeader()
+          }
+        );
+        const { host, port = 443, key, scheme = "wss" } = this.reverbConfig;
+        const wsUrl = `${scheme}://${host}:${port}/app/${key}`;
+        if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
+          this.websocket = new WebSocket(wsUrl);
+          this.websocket.onopen = () => {
+            console.log("WebSocket connected");
+            subscribeToChannel(channelName, authResponse.auth);
+          };
+          this.websocket.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            handleWebSocketMessage(data);
+          };
+          this.websocket.onerror = (error) => {
+            console.error("WebSocket error:", error);
+            startPolling();
+          };
+          this.websocket.onclose = () => {
+            console.log("WebSocket closed");
+            this.subscribedChannels.delete(channelName);
+          };
+        } else {
+          subscribeToChannel(channelName, authResponse.auth);
+        }
+        wsChannel = channelName;
+      } catch (error) {
+        console.error("WebSocket connection failed:", error);
+        startPolling();
+      }
+    };
+    const subscribeToChannel = (channelName, auth) => {
+      if (!this.websocket || this.subscribedChannels.has(channelName)) return;
+      this.websocket.send(JSON.stringify({
+        event: "pusher:subscribe",
+        data: {
+          auth,
+          channel: channelName
+        }
+      }));
+      this.subscribedChannels.add(channelName);
+    };
+    const handleWebSocketMessage = (data) => {
+      if (data.event === "message.sent") {
+        const message = data.data;
+        messageListeners.forEach((cb) => cb(message));
+        this.lastMessageIds.set(conversationId, message.id);
+      } else if (data.event === "conversation.updated") {
+        statusListeners.forEach((cb) => cb(data.data.status));
+      } else if (data.event === "typing") {
+        typingListeners.forEach((cb) => cb(data.data.sender_type));
+      }
+    };
+    const startPolling = () => {
+      if (pollingActive) return;
+      pollingActive = true;
+      pollLoop();
+    };
+    const pollLoop = async () => {
+      if (!pollingActive) return;
+      try {
+        const lastId = this.lastMessageIds.get(conversationId) || 0;
+        const result = await this.poll(conversationId, lastId);
+        for (const msg of result.messages) {
+          if (msg.id > lastId) {
+            this.lastMessageIds.set(conversationId, msg.id);
+            messageListeners.forEach((cb) => cb(msg));
+          }
+        }
+        statusListeners.forEach((cb) => cb(result.conversation_status));
+      } catch (error) {
+        console.error("Chat polling error:", error);
+      }
+      if (pollingActive) {
+        pollingTimeout = setTimeout(pollLoop, 3e3);
+      }
+    };
+    const stopPolling = () => {
+      pollingActive = false;
+      if (pollingTimeout) {
+        clearTimeout(pollingTimeout);
+        pollingTimeout = null;
+      }
+    };
+    const disconnect = () => {
+      stopPolling();
+      if (wsChannel && this.websocket) {
+        this.websocket.send(JSON.stringify({
+          event: "pusher:unsubscribe",
+          data: { channel: wsChannel }
+        }));
+        this.subscribedChannels.delete(wsChannel);
+      }
+    };
+    if (this.reverbConfig) {
+      connectWebSocket();
+    }
+    return {
+      send: (content, type) => this.send(conversationId, { content, type }),
+      getMessages: (params) => this.getMessages(conversationId, params),
+      onMessage: (callback) => {
+        messageListeners.push(callback);
+        if (!this.reverbConfig) startPolling();
+        return () => {
+          const idx = messageListeners.indexOf(callback);
+          if (idx > -1) messageListeners.splice(idx, 1);
+          if (messageListeners.length === 0 && statusListeners.length === 0) {
+            disconnect();
+          }
+        };
+      },
+      onStatusChange: (callback) => {
+        statusListeners.push(callback);
+        if (!this.reverbConfig) startPolling();
+        return () => {
+          const idx = statusListeners.indexOf(callback);
+          if (idx > -1) statusListeners.splice(idx, 1);
+        };
+      },
+      onTyping: (callback) => {
+        typingListeners.push(callback);
+        return () => {
+          const idx = typingListeners.indexOf(callback);
+          if (idx > -1) typingListeners.splice(idx, 1);
+        };
+      },
+      sendTyping: () => this.sendTyping(conversationId),
+      close: () => this.close(conversationId),
+      disconnect,
+      // Use WebSocket if available
+      useWebSocket: () => connectWebSocket(),
+      // Force polling mode
+      usePolling: () => {
+        disconnect();
+        startPolling();
+      }
+    };
+  }
+  /**
+   * Generate a random socket ID
+   */
+  generateSocketId() {
+    return `${Math.random().toString(36).substring(2)}.${Math.random().toString(36).substring(2)}`;
+  }
+  /**
+   * Get visitor ID header
+   */
+  getVisitorHeader() {
+    return this.visitorId ? { "X-Visitor-Id": this.visitorId } : {};
+  }
+  /**
+   * Set visitor ID manually (useful for server-side rendering)
+   */
+  setVisitorId(visitorId) {
+    this.visitorId = visitorId;
+  }
+  /**
+   * Get current visitor ID
+   */
+  getVisitorId() {
+    return this.visitorId;
+  }
+  /**
+   * Disconnect WebSocket
+   */
+  disconnectWebSocket() {
+    if (this.websocket) {
+      this.websocket.close();
+      this.websocket = null;
+      this.subscribedChannels.clear();
+    }
+  }
+};
+
 // src/index.ts
 var Diffsome = class {
   constructor(config) {
@@ -1655,6 +2015,8 @@ var Diffsome = class {
     this.media = new MediaResource(this.http);
     this.entities = new EntitiesResource(this.http);
     this.reservation = new ReservationResource(this.http);
+    this.site = new SiteResource(this.http);
+    this.chat = new ChatResource(this.http);
   }
   /**
    * Check if user is authenticated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diffsome/sdk",
-  "version": "3.2.7",
+  "version": "3.2.9",
   "description": "Diffsome SDK for JavaScript/TypeScript - Different + Awesome",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -33,7 +33,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/diffsome/sdk.git"
+    "url": "https://github.com/diffsome/diffsome-sdk.git"
   },
   "devDependencies": {
     "openapi-typescript": "^7.10.1",