@mailoo/chat 0.0.0-stage → 1.32.2

package/dist/hooks/index.cjs

@@ -0,0 +1,751 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  DEFAULT_CHAT_GUEST_PROFILE_KEY: () => DEFAULT_CHAT_GUEST_PROFILE_KEY,
+  DEFAULT_CHAT_MESSAGES_ENDPOINT: () => DEFAULT_CHAT_MESSAGES_ENDPOINT,
+  DEFAULT_CHAT_POLL_INTERVAL_MS: () => DEFAULT_CHAT_POLL_INTERVAL_MS,
+  DEFAULT_CHAT_SESSION_STORAGE_KEY: () => DEFAULT_CHAT_SESSION_STORAGE_KEY,
+  DEFAULT_CHAT_STATUS_ENDPOINT: () => DEFAULT_CHAT_STATUS_ENDPOINT,
+  DEFAULT_CHAT_SUBMIT_ENDPOINT: () => DEFAULT_CHAT_SUBMIT_ENDPOINT,
+  classifyChatFault: () => classifyChatFault,
+  isChatSessionNotFound: () => isChatSessionNotFound,
+  messageFromPayload: () => messageFromPayload,
+  useMailooChatMessages: () => useMailooChatMessages,
+  useMailooChatSession: () => useMailooChatSession,
+  useMailooChatStatus: () => useMailooChatStatus,
+  useMailooChatSubmit: () => useMailooChatSubmit
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_react2 = require("react");
+
+// src/lib/chat-message.ts
+function parseChatMessages(rows) {
+  const parsed = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const r = row;
+    if (typeof r.id !== "string" || typeof r.content !== "string") continue;
+    parsed.push({
+      id: r.id,
+      messageType: typeof r.messageType === "string" ? r.messageType : "INBOUND",
+      content: r.content,
+      senderEmail: typeof r.senderEmail === "string" ? r.senderEmail : null,
+      senderName: typeof r.senderName === "string" ? r.senderName : null,
+      createdAt: typeof r.createdAt === "string" ? r.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return parsed;
+}
+function messagesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.id !== y.id || x.content !== y.content || x.messageType !== y.messageType || x.createdAt !== y.createdAt || x.senderEmail !== y.senderEmail || x.senderName !== y.senderName) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeChatMessages(prev, incoming) {
+  if (incoming.length === 0) return prev;
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of prev) byId.set(m.id, m);
+  for (const m of incoming) byId.set(m.id, m);
+  const next = Array.from(byId.values()).sort(
+    (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+  );
+  return messagesEqual(prev, next) ? prev : next;
+}
+function latestMessageCreatedAt(messages) {
+  if (messages.length === 0) return void 0;
+  let latest = messages[0].createdAt;
+  for (const m of messages) {
+    if (new Date(m.createdAt).getTime() > new Date(latest).getTime()) {
+      latest = m.createdAt;
+    }
+  }
+  return latest;
+}
+
+// src/hooks/shared.ts
+var DEFAULT_CHAT_SUBMIT_ENDPOINT = "/api/v1/webhooks/chat/submit";
+var DEFAULT_CHAT_MESSAGES_ENDPOINT = "/api/v1/webhooks/chat/messages";
+var DEFAULT_CHAT_STATUS_ENDPOINT = "/api/v1/webhooks/chat/status";
+var DEFAULT_CHAT_SESSION_STORAGE_KEY = "mailoo_site_chat_session_public_id";
+var DEFAULT_CHAT_GUEST_PROFILE_KEY = "mailoo_site_chat_guest_profile";
+var DEFAULT_CHAT_POLL_INTERVAL_MS = 5e3;
+function messageFromPayload(data, fallback) {
+  if (!data || typeof data !== "object") return fallback;
+  const d = data;
+  if (typeof d.message === "string") return d.message;
+  if (typeof d.error === "string") return d.error;
+  return fallback;
+}
+function classifyChatFault(status, payload, fallbackMessage = "Request failed") {
+  if (status === 429) {
+    return {
+      kind: "rate_limited",
+      status,
+      message: messageFromPayload(payload, fallbackMessage)
+    };
+  }
+  if (status === 0 || status === 502 || status === 503 || status >= 500) {
+    return {
+      kind: "unavailable",
+      status,
+      message: messageFromPayload(payload, fallbackMessage)
+    };
+  }
+  return null;
+}
+function isChatSessionNotFound(status, data) {
+  if (status !== 404) return false;
+  const text = messageFromPayload(data, "").toLowerCase();
+  return text.includes("chat session not found");
+}
+function persistSessionPublicId(id, storageKey, ctx) {
+  const created = !ctx.sessionPublicIdRef.current;
+  ctx.setSessionPublicId(id);
+  ctx.sessionPublicIdRef.current = id;
+  try {
+    sessionStorage.setItem(storageKey, id);
+  } catch {
+  }
+  if (created) ctx.onCreated?.(id);
+}
+
+// src/hooks/use-mailoo-chat-session.ts
+var import_react = require("react");
+
+// src/lib/guest-copy.ts
+function isValidEmail(s) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s.trim());
+}
+
+// src/lib/visitor-ws-url.ts
+function buildVisitorWsUrl(apiOrigin, projectUid, integrationId, sessionPublicId) {
+  const u = new URL(apiOrigin);
+  const wsProto = u.protocol === "https:" ? "wss:" : "ws:";
+  const qs = new URLSearchParams({
+    projectUid,
+    integrationId,
+    sessionPublicId
+  });
+  return `${wsProto}//${u.host}/api/v1/chat/visitor-ws?${qs.toString()}`;
+}
+
+// src/hooks/use-mailoo-chat-session.ts
+function useMailooChatSession(options) {
+  const {
+    apiOrigin,
+    projectUid,
+    integrationId,
+    isAuthenticated,
+    submitEndpoint = DEFAULT_CHAT_SUBMIT_ENDPOINT,
+    messagesEndpoint = DEFAULT_CHAT_MESSAGES_ENDPOINT,
+    storageKey = DEFAULT_CHAT_SESSION_STORAGE_KEY,
+    guestProfileKey = DEFAULT_CHAT_GUEST_PROFILE_KEY,
+    pollIntervalMs = DEFAULT_CHAT_POLL_INTERVAL_MS,
+    enableRealtime = true,
+    enablePolling = true,
+    enableWebSocket = true,
+    enabled = true,
+    onSessionCreated,
+    onMessageSent,
+    onError,
+    onFault
+  } = options;
+  const [sessionPublicId, setSessionPublicId] = (0, import_react.useState)(null);
+  const [messages, setMessages] = (0, import_react.useState)([]);
+  const [sending, setSending] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [fault, setFault] = (0, import_react.useState)(null);
+  const [connectionState, setConnectionState] = (0, import_react.useState)("idle");
+  const [guestEmail, setGuestEmail] = (0, import_react.useState)("");
+  const [guestName, setGuestName] = (0, import_react.useState)("");
+  const [guestContactOk, setGuestContactOk] = (0, import_react.useState)(isAuthenticated);
+  const [guestProfileHydrated, setGuestProfileHydrated] = (0, import_react.useState)(false);
+  const wsRef = (0, import_react.useRef)(null);
+  const pollRef = (0, import_react.useRef)(null);
+  const sessionPublicIdRef = (0, import_react.useRef)(null);
+  const sinceRef = (0, import_react.useRef)(void 0);
+  const faultRef = (0, import_react.useRef)(null);
+  const onSessionCreatedRef = (0, import_react.useRef)(onSessionCreated);
+  const onMessageSentRef = (0, import_react.useRef)(onMessageSent);
+  const onErrorRef = (0, import_react.useRef)(onError);
+  const onFaultRef = (0, import_react.useRef)(onFault);
+  sessionPublicIdRef.current = sessionPublicId;
+  faultRef.current = fault;
+  onSessionCreatedRef.current = onSessionCreated;
+  onMessageSentRef.current = onMessageSent;
+  onErrorRef.current = onError;
+  onFaultRef.current = onFault;
+  const clearFault = (0, import_react.useCallback)(() => {
+    faultRef.current = null;
+    setFault(null);
+  }, []);
+  const reportFault = (0, import_react.useCallback)((next) => {
+    faultRef.current = next;
+    setFault(next);
+    setError(null);
+    onFaultRef.current?.(next);
+    onErrorRef.current?.(next.message);
+  }, []);
+  const reportError = (0, import_react.useCallback)((message) => {
+    setError(message);
+    if (message) {
+      clearFault();
+      onErrorRef.current?.(message);
+    }
+  }, [clearFault]);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const existing = sessionStorage.getItem(storageKey);
+    if (existing) setSessionPublicId(existing);
+  }, [storageKey]);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined" || isAuthenticated) {
+      setGuestProfileHydrated(true);
+      return;
+    }
+    try {
+      const raw = sessionStorage.getItem(guestProfileKey);
+      if (raw) {
+        const j = JSON.parse(raw);
+        const em = typeof j.email === "string" ? j.email.trim().toLowerCase() : "";
+        if (em && isValidEmail(em)) {
+          setGuestEmail(em);
+          setGuestName(typeof j.name === "string" ? j.name.trim() : "");
+          setGuestContactOk(true);
+        }
+      }
+    } catch {
+    }
+    setGuestProfileHydrated(true);
+  }, [isAuthenticated, guestProfileKey]);
+  (0, import_react.useEffect)(() => {
+    if (isAuthenticated) {
+      setGuestContactOk(true);
+    }
+  }, [isAuthenticated]);
+  const persistGuestProfile = (0, import_react.useCallback)(
+    (email, name) => {
+      try {
+        sessionStorage.setItem(
+          guestProfileKey,
+          JSON.stringify({
+            email: email.trim().toLowerCase(),
+            name: name.trim()
+          })
+        );
+      } catch {
+      }
+    },
+    [guestProfileKey]
+  );
+  const confirmGuestContact = (0, import_react.useCallback)(
+    (invalidEmailMessage) => {
+      reportError(null);
+      if (isAuthenticated) {
+        setGuestContactOk(true);
+        return true;
+      }
+      if (!isValidEmail(guestEmail)) {
+        reportError(
+          invalidEmailMessage ?? "Please enter a valid email address."
+        );
+        return false;
+      }
+      persistGuestProfile(guestEmail, guestName);
+      setGuestContactOk(true);
+      return true;
+    },
+    [
+      isAuthenticated,
+      guestEmail,
+      guestName,
+      persistGuestProfile,
+      reportError
+    ]
+  );
+  const resetGuestContact = (0, import_react.useCallback)(() => {
+    setGuestContactOk(false);
+    reportError(null);
+  }, [reportError]);
+  const mergeIncoming = (0, import_react.useCallback)((rows) => {
+    const parsed = parseChatMessages(rows);
+    setMessages((prev) => {
+      const next = mergeChatMessages(prev, parsed);
+      sinceRef.current = latestMessageCreatedAt(next);
+      return next;
+    });
+  }, []);
+  const mergeMessage = (0, import_react.useCallback)((message) => {
+    setMessages((prev) => {
+      const next = mergeChatMessages(prev, [message]);
+      sinceRef.current = latestMessageCreatedAt(next);
+      return next;
+    });
+  }, []);
+  const clearSession = (0, import_react.useCallback)(() => {
+    try {
+      sessionStorage.removeItem(storageKey);
+    } catch {
+    }
+    setSessionPublicId(null);
+    sessionPublicIdRef.current = null;
+    setMessages([]);
+    sinceRef.current = void 0;
+  }, [storageKey]);
+  const stopRealtime = (0, import_react.useCallback)(() => {
+    if (pollRef.current) {
+      clearInterval(pollRef.current);
+      pollRef.current = null;
+    }
+    wsRef.current?.close();
+    wsRef.current = null;
+    setConnectionState("closed");
+  }, []);
+  const refreshMessages = (0, import_react.useCallback)(
+    async (sid, opts) => {
+      const id = sid ?? sessionPublicIdRef.current;
+      if (!id) return;
+      if (faultRef.current) return;
+      const params = new URLSearchParams({ sessionPublicId: id });
+      if (!opts?.full && sinceRef.current) {
+        params.set("since", sinceRef.current);
+      }
+      let res;
+      try {
+        res = await fetch(`${messagesEndpoint}?${params.toString()}`);
+      } catch {
+        const next = classifyChatFault(0, null, "Network error");
+        if (next) {
+          reportFault(next);
+          stopRealtime();
+        }
+        return;
+      }
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        if (isChatSessionNotFound(res.status, data)) {
+          clearSession();
+          reportError(null);
+          return;
+        }
+        const classified = classifyChatFault(
+          res.status,
+          data,
+          "Failed to load messages"
+        );
+        if (classified) {
+          reportFault(classified);
+          stopRealtime();
+          return;
+        }
+        reportError(messageFromPayload(data, "Failed to load messages"));
+        return;
+      }
+      if (Array.isArray(data.data)) {
+        mergeIncoming(data.data);
+      }
+    },
+    [
+      messagesEndpoint,
+      mergeIncoming,
+      clearSession,
+      reportError,
+      reportFault,
+      stopRealtime
+    ]
+  );
+  (0, import_react.useEffect)(() => {
+    const realtimeOn = enabled && enableRealtime && guestContactOk && !fault;
+    if (!realtimeOn || !sessionPublicId) {
+      return;
+    }
+    const connectWs = () => {
+      if (!enableWebSocket || !apiOrigin || !projectUid || !integrationId) {
+        return;
+      }
+      try {
+        const url = buildVisitorWsUrl(
+          apiOrigin,
+          projectUid,
+          integrationId,
+          sessionPublicId
+        );
+        setConnectionState("connecting");
+        const ws = new WebSocket(url);
+        wsRef.current = ws;
+        ws.onopen = () => setConnectionState("open");
+        ws.onmessage = (ev) => {
+          try {
+            const msg = JSON.parse(ev.data);
+            if (msg.type !== "chat.message") return;
+            const p = msg.payload;
+            if (p && typeof p.messageId === "string" && typeof p.content === "string") {
+              mergeMessage({
+                id: p.messageId,
+                content: p.content,
+                messageType: typeof p.messageType === "string" ? p.messageType : "OUTBOUND",
+                senderEmail: typeof p.senderEmail === "string" ? p.senderEmail : null,
+                senderName: typeof p.senderName === "string" ? p.senderName : null,
+                createdAt: typeof p.createdAt === "string" ? p.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+            void refreshMessages(sessionPublicId);
+          } catch {
+          }
+        };
+        ws.onclose = () => {
+          wsRef.current = null;
+          setConnectionState("closed");
+        };
+      } catch {
+        setConnectionState("closed");
+      }
+    };
+    connectWs();
+    void refreshMessages(sessionPublicId, { full: true });
+    if (enablePolling) {
+      pollRef.current = setInterval(() => {
+        void refreshMessages(sessionPublicId);
+      }, pollIntervalMs);
+    }
+    return () => {
+      if (pollRef.current) clearInterval(pollRef.current);
+      pollRef.current = null;
+      wsRef.current?.close();
+      wsRef.current = null;
+      setConnectionState("idle");
+    };
+  }, [
+    enabled,
+    enableRealtime,
+    enablePolling,
+    enableWebSocket,
+    guestContactOk,
+    fault,
+    sessionPublicId,
+    apiOrigin,
+    projectUid,
+    integrationId,
+    pollIntervalMs,
+    refreshMessages,
+    mergeMessage
+  ]);
+  const sendMessage = (0, import_react.useCallback)(
+    async (content, opts) => {
+      const text = content.trim();
+      if (!text || sending) return false;
+      if (faultRef.current) return false;
+      if (!isAuthenticated && !isValidEmail(guestEmail)) {
+        reportError(
+          opts?.invalidEmailMessage ?? "Please enter a valid email address."
+        );
+        return false;
+      }
+      setSending(true);
+      reportError(null);
+      clearFault();
+      try {
+        const buildBody = (includeSession) => {
+          const body = { content: text };
+          const pageUrl = opts?.pageUrl ?? (typeof window !== "undefined" ? window.location.href : void 0);
+          if (pageUrl) body.pageUrl = pageUrl;
+          const sid = includeSession ? sessionPublicIdRef.current : null;
+          if (sid) body.sessionPublicId = sid;
+          else if (opts?.topicId?.trim()) {
+            body.topicId = opts.topicId.trim();
+          }
+          if (!isAuthenticated) {
+            body.senderEmail = guestEmail.trim().toLowerCase();
+            if (guestName.trim()) body.senderName = guestName.trim();
+          }
+          return body;
+        };
+        const post = async (includeSession) => {
+          let res2;
+          try {
+            res2 = await fetch(submitEndpoint, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(buildBody(includeSession))
+            });
+          } catch {
+            return {
+              res: null,
+              data: {},
+              networkError: true
+            };
+          }
+          const data2 = await res2.json().catch(() => ({}));
+          return { res: res2, data: data2, networkError: false };
+        };
+        let result = await post(true);
+        if (result.networkError) {
+          const next = classifyChatFault(0, null, "Network error");
+          if (next) {
+            reportFault(next);
+            stopRealtime();
+          }
+          return false;
+        }
+        let { res, data } = result;
+        if (!res) return false;
+        if (!res.ok && isChatSessionNotFound(res.status, data)) {
+          clearSession();
+          result = await post(false);
+          if (result.networkError) {
+            const next = classifyChatFault(0, null, "Network error");
+            if (next) {
+              reportFault(next);
+              stopRealtime();
+            }
+            return false;
+          }
+          ;
+          ({ res, data } = result);
+          if (!res) return false;
+        }
+        if (!res.ok) {
+          const classified = classifyChatFault(
+            res.status,
+            data,
+            "Send failed"
+          );
+          if (classified) {
+            reportFault(classified);
+            stopRealtime();
+            return false;
+          }
+          reportError(messageFromPayload(data, "Send failed"));
+          return false;
+        }
+        if (data.sessionPublicId) {
+          persistSessionPublicId(data.sessionPublicId, storageKey, {
+            sessionPublicIdRef,
+            setSessionPublicId,
+            onCreated: onSessionCreatedRef.current
+          });
+        }
+        if (!isAuthenticated) {
+          persistGuestProfile(guestEmail, guestName);
+        }
+        if (typeof data.messageId === "string" && data.messageId) {
+          mergeMessage({
+            id: data.messageId,
+            content: text,
+            messageType: "INBOUND",
+            senderEmail: isAuthenticated ? null : guestEmail.trim().toLowerCase(),
+            senderName: isAuthenticated ? null : guestName.trim() || null,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        const nextSid = data.sessionPublicId ?? sessionPublicIdRef.current;
+        if (nextSid) {
+          await refreshMessages(nextSid, { full: true });
+        }
+        onMessageSentRef.current?.(text);
+        return true;
+      } catch (e) {
+        reportError(e instanceof Error ? e.message : "Send failed");
+        return false;
+      } finally {
+        setSending(false);
+      }
+    },
+    [
+      sending,
+      isAuthenticated,
+      guestEmail,
+      guestName,
+      submitEndpoint,
+      storageKey,
+      persistGuestProfile,
+      mergeMessage,
+      refreshMessages,
+      clearSession,
+      reportError,
+      reportFault,
+      clearFault,
+      stopRealtime
+    ]
+  );
+  const retryAfterFault = (0, import_react.useCallback)(() => {
+    clearFault();
+    reportError(null);
+  }, [clearFault, reportError]);
+  const canCompose = isAuthenticated || guestProfileHydrated && guestContactOk;
+  return {
+    sessionPublicId,
+    messages,
+    sending,
+    error,
+    fault,
+    setError: reportError,
+    clearFault,
+    retryAfterFault,
+    connectionState,
+    guestEmail,
+    guestName,
+    setGuestEmail,
+    setGuestName,
+    guestContactOk,
+    guestProfileHydrated,
+    confirmGuestContact,
+    resetGuestContact,
+    canCompose,
+    sendMessage,
+    refreshMessages,
+    clearSession
+  };
+}
+
+// src/hooks/index.ts
+function useMailooChatSubmit(options) {
+  const endpoint = options?.endpoint ?? DEFAULT_CHAT_SUBMIT_ENDPOINT;
+  const [pending, setPending] = (0, import_react2.useState)(false);
+  const submit = (0, import_react2.useCallback)(
+    async (body) => {
+      setPending(true);
+      try {
+        const res = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            ok: false,
+            status: res.status,
+            message: messageFromPayload(data, "Send failed")
+          };
+        }
+        return { ok: true, status: res.status, data };
+      } catch {
+        return { ok: false, status: 0, message: "Network error" };
+      } finally {
+        setPending(false);
+      }
+    },
+    [endpoint]
+  );
+  return { submit, pending };
+}
+function useMailooChatMessages(options) {
+  const endpoint = options?.endpoint ?? DEFAULT_CHAT_MESSAGES_ENDPOINT;
+  const [pending, setPending] = (0, import_react2.useState)(false);
+  const refresh = (0, import_react2.useCallback)(
+    async (sessionPublicId, since) => {
+      setPending(true);
+      try {
+        const params = new URLSearchParams({ sessionPublicId });
+        if (since) params.set("since", since);
+        const res = await fetch(`${endpoint}?${params.toString()}`);
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          return {
+            ok: false,
+            status: res.status,
+            message: messageFromPayload(data, "Fetch failed")
+          };
+        }
+        const rows = Array.isArray(data.data) ? data.data : [];
+        return {
+          ok: true,
+          status: res.status,
+          data,
+          messages: parseChatMessages(rows)
+        };
+      } catch {
+        return { ok: false, status: 0, message: "Network error" };
+      } finally {
+        setPending(false);
+      }
+    },
+    [endpoint]
+  );
+  return { refresh, pending };
+}
+function useMailooChatStatus(options) {
+  const endpoint = options?.endpoint ?? DEFAULT_CHAT_STATUS_ENDPOINT;
+  const enabled = options?.enabled ?? true;
+  const [status, setStatus] = (0, import_react2.useState)(null);
+  const [pending, setPending] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const refresh = (0, import_react2.useCallback)(async () => {
+    setPending(true);
+    setError(null);
+    try {
+      const res = await fetch(endpoint);
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        setError(messageFromPayload(data, "Status fetch failed"));
+        return null;
+      }
+      if (typeof data.status !== "string" || typeof data.name !== "string" || typeof data.type !== "string" || typeof data.lastActivity !== "string") {
+        setError("Invalid status payload");
+        return null;
+      }
+      const parsed = {
+        status: data.status,
+        name: data.name,
+        type: data.type,
+        lastActivity: data.lastActivity
+      };
+      setStatus(parsed);
+      return parsed;
+    } catch {
+      setError("Network error");
+      return null;
+    } finally {
+      setPending(false);
+    }
+  }, [endpoint]);
+  (0, import_react2.useEffect)(() => {
+    if (!enabled) return;
+    void refresh();
+  }, [enabled, refresh]);
+  return { status, pending, error, refresh };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CHAT_GUEST_PROFILE_KEY,
+  DEFAULT_CHAT_MESSAGES_ENDPOINT,
+  DEFAULT_CHAT_POLL_INTERVAL_MS,
+  DEFAULT_CHAT_SESSION_STORAGE_KEY,
+  DEFAULT_CHAT_STATUS_ENDPOINT,
+  DEFAULT_CHAT_SUBMIT_ENDPOINT,
+  classifyChatFault,
+  isChatSessionNotFound,
+  messageFromPayload,
+  useMailooChatMessages,
+  useMailooChatSession,
+  useMailooChatStatus,
+  useMailooChatSubmit
+});
+//# sourceMappingURL=index.cjs.map