@brandfine/client 0.11.0 → 0.14.0

package/dist/index.js

@@ -2,6 +2,356 @@ export { createCache, createKeyedCache } from './chunk-DHQHUIFO.js';
 export { isLocale, localizePath, pickLocale, resolveNavigation, stripLocalePrefix } from './chunk-U6VJX7PP.js';
 export { createBrandfineWebhookHandler, parseWebhookPayload, verifyWebhookSecret } from './chunk-QQLAYITF.js';
 
+// src/live-chat-session.ts
+var SESSION_STORAGE_KEY = "bf-live-chat-session";
+function tokenStorageKey(publishableKey) {
+  return `bf-live-chat-token:${publishableKey.slice(-12)}`;
+}
+function getVisitorSessionId() {
+  try {
+    const existing = localStorage.getItem(SESSION_STORAGE_KEY);
+    if (existing) return existing;
+    const generated = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID().replace(/-/g, "") : `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+    localStorage.setItem(SESSION_STORAGE_KEY, generated);
+    return generated;
+  } catch {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+  }
+}
+function readStoredToken(publishableKey) {
+  try {
+    return localStorage.getItem(tokenStorageKey(publishableKey)) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeStoredToken(publishableKey, token) {
+  try {
+    if (token === null) localStorage.removeItem(tokenStorageKey(publishableKey));
+    else localStorage.setItem(tokenStorageKey(publishableKey), token);
+  } catch {
+  }
+}
+function resolvePageLocale(explicit) {
+  if (explicit) return explicit;
+  if (typeof document === "undefined") return void 0;
+  const htmlLang = document.documentElement.lang?.trim();
+  if (htmlLang) return htmlLang;
+  return typeof navigator !== "undefined" ? navigator.language || void 0 : void 0;
+}
+async function createLiveChatSession(wire, opts) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "liveChat.createSession() is browser-only \u2014 build the transcript UI client-side; fetch the bootstrap with getConfig() on the server."
+    );
+  }
+  const publishableKey = opts.config.enabled ? opts.config.publishableKey : void 0;
+  const locale = resolvePageLocale(opts.locale);
+  const pollMs = Math.max(1e3, opts.pollIntervalMs ?? 5e3);
+  let snapshot = {
+    messages: [],
+    status: "CONNECTING",
+    online: false,
+    greeting: null,
+    offlineMessage: null,
+    sending: false,
+    error: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  let cursor;
+  let lastEventId = 0;
+  let token;
+  let timer;
+  let closed = false;
+  let ticking = false;
+  const aborter = new AbortController();
+  let realtimeUrl = opts.config.realtimeUrl;
+  let ws;
+  let wsLive = false;
+  let wsFailures = 0;
+  let wsGivenUp = false;
+  let reconnectTimer;
+  let pingTimer;
+  function emit(patch) {
+    snapshot = { ...snapshot, ...patch };
+    for (const listener of listeners) listener(snapshot);
+  }
+  function appendMessages(incoming) {
+    const fresh = incoming.filter((m) => !seen.has(m.id));
+    if (fresh.length === 0) {
+      for (const m of incoming) {
+        if (typeof m.eventId === "number" && m.eventId > lastEventId) {
+          lastEventId = m.eventId;
+        }
+      }
+      return;
+    }
+    for (const m of fresh) {
+      seen.add(m.id);
+      if (typeof m.eventId === "number" && m.eventId > lastEventId) {
+        lastEventId = m.eventId;
+      }
+    }
+    const messages = [...snapshot.messages, ...fresh];
+    cursor = messages[messages.length - 1].createdAt;
+    emit({ messages });
+  }
+  function markClosed() {
+    if (snapshot.status !== "CLOSED") emit({ status: "CLOSED" });
+    stopPolling();
+    teardownRealtime();
+    wsGivenUp = true;
+  }
+  async function tick() {
+    if (ticking || closed || !token) return;
+    ticking = true;
+    try {
+      const result = await wire.history(
+        token,
+        // The eventId cursor is exact (no equal-millisecond drop
+        // window); the timestamp cursor remains for old APIs that
+        // never sent eventIds.
+        lastEventId > 0 ? { afterEvent: lastEventId } : { after: cursor }
+      );
+      if (closed) return;
+      appendMessages(result.messages);
+      if (result.status === "CLOSED") markClosed();
+    } catch {
+    } finally {
+      ticking = false;
+    }
+  }
+  function startPolling() {
+    stopPolling();
+    timer = setInterval(() => void tick(), pollMs);
+  }
+  function stopPolling() {
+    if (timer !== void 0) clearInterval(timer);
+    timer = void 0;
+  }
+  function teardownRealtime() {
+    if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+    reconnectTimer = void 0;
+    if (pingTimer !== void 0) clearInterval(pingTimer);
+    pingTimer = void 0;
+    wsLive = false;
+    if (ws) {
+      const socket = ws;
+      ws = void 0;
+      try {
+        socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+        socket.close();
+      } catch {
+      }
+    }
+  }
+  function scheduleReconnect() {
+    if (closed || wsGivenUp || reconnectTimer !== void 0) return;
+    if (wsFailures >= 5) {
+      wsGivenUp = true;
+      return;
+    }
+    const base = Math.min(3e4, 1e3 * 2 ** wsFailures);
+    const delay = base / 2 + Math.random() * (base / 2);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = void 0;
+      startRealtime();
+    }, delay);
+  }
+  function handleSocketDown() {
+    teardownRealtime();
+    if (closed || wsGivenUp || snapshot.status === "CLOSED") return;
+    startPolling();
+    wsFailures += 1;
+    scheduleReconnect();
+  }
+  function startRealtime() {
+    if (closed || wsGivenUp || wsLive || ws !== void 0 || !realtimeUrl || !token || !publishableKey || typeof WebSocket === "undefined" || snapshot.status === "CLOSED") {
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(realtimeUrl);
+    } catch {
+      wsFailures += 1;
+      scheduleReconnect();
+      return;
+    }
+    ws = socket;
+    socket.onopen = () => {
+      try {
+        socket.send(
+          JSON.stringify({
+            type: "auth",
+            publishableKey,
+            conversationToken: token,
+            lastEventId
+          })
+        );
+      } catch {
+        handleSocketDown();
+      }
+    };
+    socket.onmessage = (event) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      switch (frame.type) {
+        case "ready": {
+          wsLive = true;
+          wsFailures = 0;
+          stopPolling();
+          if (pingTimer === void 0) {
+            pingTimer = setInterval(() => {
+              try {
+                socket.send(JSON.stringify({ type: "ping" }));
+              } catch {
+              }
+            }, 3e4);
+          }
+          break;
+        }
+        case "message": {
+          const m = frame.message;
+          if (m && typeof m.id === "string") {
+            appendMessages([
+              {
+                ...m,
+                eventId: typeof frame.eventId === "number" ? frame.eventId : m.eventId
+              }
+            ]);
+          }
+          break;
+        }
+        case "status": {
+          if (frame.status === "CLOSED") markClosed();
+          break;
+        }
+        case "error": {
+          wsGivenUp = true;
+          teardownRealtime();
+          if (!closed && snapshot.status !== "CLOSED") startPolling();
+          break;
+        }
+      }
+    };
+    socket.onclose = () => handleSocketDown();
+    socket.onerror = () => {
+    };
+  }
+  async function connect(resumeToken) {
+    if (!publishableKey) {
+      emit({ status: "CLOSED" });
+      return;
+    }
+    try {
+      const cfg = await wire.runtimeConfig(locale);
+      if (closed) return;
+      if (!cfg.enabled) {
+        emit({ status: "CLOSED" });
+        return;
+      }
+      emit({
+        greeting: cfg.greeting,
+        offlineMessage: cfg.offlineMessage,
+        online: cfg.online !== false
+      });
+      if (cfg.realtimeUrl !== void 0) realtimeUrl = cfg.realtimeUrl;
+    } catch (error) {
+      if (closed) return;
+      emit({ status: "ERROR", error });
+      return;
+    }
+    try {
+      const started = await wire.startConversation({
+        visitorSessionId: getVisitorSessionId(),
+        conversationToken: resumeToken,
+        pageUrl: opts.pageUrl ?? (typeof location !== "undefined" ? location.href.slice(0, 2048) : void 0),
+        referrer: opts.referrer,
+        locale,
+        visitor: opts.visitor
+      });
+      if (closed) return;
+      if (!started.enabled) {
+        emit({ status: "CLOSED" });
+        return;
+      }
+      token = started.conversationToken;
+      writeStoredToken(publishableKey, token);
+      if (started.online !== void 0) emit({ online: started.online });
+      emit({ status: "OPEN" });
+      await tick();
+      if (!closed) {
+        startPolling();
+        startRealtime();
+      }
+    } catch (error) {
+      if (closed) return;
+      emit({ status: "ERROR", error });
+    }
+  }
+  const session = {
+    get messages() {
+      return snapshot.messages;
+    },
+    get state() {
+      return snapshot.status;
+    },
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async send(body) {
+      const trimmed = body.trim();
+      if (!trimmed) throw new Error("send(): message body is empty");
+      if (!token) throw new Error("send(): session is not connected");
+      if (snapshot.status === "CLOSED") {
+        throw new Error("send(): conversation is closed \u2014 call reset()");
+      }
+      emit({ sending: true });
+      try {
+        const clientId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+        const message = await wire.sendMessage(token, {
+          body: trimmed,
+          clientId
+        });
+        appendMessages([message]);
+        return message;
+      } finally {
+        emit({ sending: false });
+      }
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      stopPolling();
+      teardownRealtime();
+      aborter.abort();
+      listeners.clear();
+    },
+    async reset() {
+      teardownRealtime();
+      wsFailures = 0;
+      wsGivenUp = false;
+      if (publishableKey) writeStoredToken(publishableKey, null);
+      token = void 0;
+      cursor = void 0;
+      lastEventId = 0;
+      seen.clear();
+      stopPolling();
+      emit({ messages: [], status: "CONNECTING", error: null });
+      await connect(void 0);
+    }
+  };
+  await connect(publishableKey ? readStoredToken(publishableKey) : void 0);
+  return session;
+}
+
 // src/client.ts
 var BrandfineApiError = class extends Error {
   name = "BrandfineApiError";
@@ -21,6 +371,23 @@ var BrandfineApiError = class extends Error {
 };
 var INSTALLED_MARKER = "data-brandfine-analytics";
 var LIVE_CHAT_MARKER = "data-brandfine-live-chat";
+var LIVE_CHAT_IDENTITY_CONTEXT = "brandfine:live-chat:identity:v1";
+async function hmacHex(key, message) {
+  const enc = new TextEncoder();
+  const cryptoKey = await globalThis.crypto.subtle.importKey(
+    "raw",
+    enc.encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await globalThis.crypto.subtle.sign(
+    "HMAC",
+    cryptoKey,
+    enc.encode(message)
+  );
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var GTAG_MARKER = "data-brandfine-gtag";
 function injectGoogleTag(measurementId) {
   if (typeof document === "undefined") return;
@@ -168,6 +535,28 @@ function createBrandfineClient(config) {
       return { installed: true, websiteId: cfg.websiteId };
     }
   };
+  async function liveChatWireRequest(key, method, path, body) {
+    const url = `${baseUrl}${path}`;
+    const res = await fetchImpl(url, {
+      method,
+      headers: {
+        Accept: "application/json",
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+        ...key ? { "X-Api-Key": key } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new BrandfineApiError({
+        status: res.status,
+        statusText: res.statusText,
+        body: text,
+        url
+      });
+    }
+    return await res.json();
+  }
   const liveChat = {
     getConfig() {
       return get("/external/live-chat/bootstrap");
@@ -192,6 +581,9 @@ function createBrandfineClient(config) {
       if (opts.visitor?.externalId && opts.visitor.identityToken) {
         host.setAttribute("data-visitor", JSON.stringify(opts.visitor));
       }
+      if (opts.locale) {
+        host.setAttribute("data-locale", opts.locale);
+      }
       if (cfg.theme) {
         for (const [key, value] of Object.entries(cfg.theme)) {
           if (key.startsWith("--bf-chat-")) {
@@ -207,35 +599,67 @@ function createBrandfineClient(config) {
       document.head.appendChild(script);
       return { installed: true };
     },
+    createSession(opts) {
+      const pk = opts.config.enabled ? opts.config.publishableKey : void 0;
+      const wire = {
+        runtimeConfig: (locale) => liveChatWireRequest(
+          pk,
+          "GET",
+          `/external/live-chat/config${locale ? `?locale=${encodeURIComponent(locale)}` : ""}`
+        ),
+        startConversation: (input) => liveChatWireRequest(pk, "POST", "/external/live-chat/conversations", input),
+        sendMessage: (conversationToken, input) => liveChatWireRequest(
+          void 0,
+          "POST",
+          `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages`,
+          input
+        ),
+        history: (conversationToken, o = {}) => liveChatWireRequest(
+          void 0,
+          "GET",
+          `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages${o.afterEvent !== void 0 ? `?afterEvent=${encodeURIComponent(String(o.afterEvent))}` : o.after ? `?after=${encodeURIComponent(o.after)}` : ""}`
+        )
+      };
+      return createLiveChatSession(wire, opts);
+    },
+    runtimeConfig(locale) {
+      return liveChatWireRequest(
+        apiKey,
+        "GET",
+        `/external/live-chat/config${locale ? `?locale=${encodeURIComponent(locale)}` : ""}`
+      );
+    },
+    startConversation(input) {
+      return liveChatWireRequest(apiKey, "POST", "/external/live-chat/conversations", input);
+    },
+    sendMessage(conversationToken, input) {
+      return liveChatWireRequest(
+        void 0,
+        "POST",
+        `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages`,
+        input
+      );
+    },
+    history(conversationToken, o = {}) {
+      const qs = o.afterEvent !== void 0 ? `?afterEvent=${encodeURIComponent(String(o.afterEvent))}` : o.after ? `?after=${encodeURIComponent(o.after)}` : "";
+      return liveChatWireRequest(
+        void 0,
+        "GET",
+        `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages${qs}`
+      );
+    },
     async identityToken(externalId, opts = {}) {
       if (typeof document !== "undefined" || typeof window !== "undefined") {
         throw new Error(
           "liveChat.identityToken() is server-only \u2014 never compute identity tokens in a browser. Sign the visitor on your server and pass the result to install({ visitor })."
         );
       }
-      const secret = opts.secret ?? (typeof process !== "undefined" ? process.env.BRANDFINE_LIVE_CHAT_IDENTITY_SECRET : void 0);
-      if (!secret) {
-        throw new Error(
-          "liveChat.identityToken(): identity secret missing. Pass { secret } or set BRANDFINE_LIVE_CHAT_IDENTITY_SECRET. Generate one in the CMS: Plugins \u2192 Live Chat \u2192 Integrate."
-        );
-      }
       if (!externalId) {
         throw new Error("liveChat.identityToken(): externalId is required.");
       }
-      const enc = new TextEncoder();
-      const key = await globalThis.crypto.subtle.importKey(
-        "raw",
-        enc.encode(secret),
-        { name: "HMAC", hash: "SHA-256" },
-        false,
-        ["sign"]
-      );
-      const sig = await globalThis.crypto.subtle.sign(
-        "HMAC",
-        key,
-        enc.encode(externalId)
-      );
-      return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const explicit = opts.secret ?? (typeof process !== "undefined" ? process.env.BRANDFINE_LIVE_CHAT_IDENTITY_SECRET : void 0);
+      const secret = explicit ?? await hmacHex(apiKey, LIVE_CHAT_IDENTITY_CONTEXT);
+      return hmacHex(secret, externalId);
     }
   };
   const submissions = {
@@ -303,6 +727,35 @@ function createBrandfineClient(config) {
         "/external/appointments/requests",
         input
       );
+    },
+    async list(identity) {
+      const res = await post(
+        "/external/appointments/requests/lookup",
+        identity
+      );
+      return res.appointments;
+    },
+    async get(id, identity) {
+      const res = await post(
+        "/external/appointments/requests/lookup",
+        { ...identity, id }
+      );
+      const row = res.appointments[0];
+      if (!row) {
+        throw new BrandfineApiError({
+          status: 404,
+          statusText: "Not Found",
+          body: "Appointment not found.",
+          url: "/external/appointments/requests/lookup"
+        });
+      }
+      return row;
+    },
+    cancel(cancellationToken) {
+      return post(
+        `/external/appointments/requests/${encodeURIComponent(cancellationToken)}/cancel`,
+        {}
+      );
     }
   };
   return {