wealth-alpha-chat-widget 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1110 @@
+"use client";
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var DOMPurify = require('isomorphic-dompurify');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DOMPurify__default = /*#__PURE__*/_interopDefault(DOMPurify);
+
+// src/components/WealthChat.tsx
+
+// src/utils/session.ts
+var SESSION_KEY = "wac_session";
+var DEFAULT_SESSION_TTL_SECONDS = 1800;
+var MAX_HISTORY = 100;
+var FALLBACK_TOKEN_KEYS = ["token", "access_token", "auth_token", "jwt"];
+var isBrowser = () => typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+function base64UrlDecode(input) {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "===".slice((base64.length + 3) % 4);
+  return atob(padded);
+}
+function decodeJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3 || !parts[1]) return null;
+    return JSON.parse(base64UrlDecode(parts[1]));
+  } catch {
+    return null;
+  }
+}
+function jwtExpiresAt(token) {
+  const payload = decodeJwt(token);
+  const exp = payload?.["exp"];
+  if (typeof exp !== "number") return null;
+  return exp * 1e3;
+}
+function jwtUserId(token) {
+  const payload = decodeJwt(token);
+  if (!payload) return "";
+  const id = payload["id"] ?? payload["sub"] ?? payload["user_id"];
+  return id != null ? String(id) : "";
+}
+function readFallbackToken() {
+  if (!isBrowser()) return null;
+  for (const key of FALLBACK_TOKEN_KEYS) {
+    const value = window.localStorage.getItem(key);
+    if (value && value.length > 20) return { token: value, key };
+  }
+  return null;
+}
+var generateId = (prefix) => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}_${crypto.randomUUID()}`;
+  }
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+};
+function newSessionId() {
+  return generateId("ses");
+}
+function newMessageId() {
+  return generateId("msg");
+}
+function readSession() {
+  if (!isBrowser()) return null;
+  try {
+    const raw = window.localStorage.getItem(SESSION_KEY);
+    if (raw) {
+      const session = JSON.parse(raw);
+      const valid = session && typeof session.token === "string" && session.token.length > 0 && typeof session.expiresAt === "number" && Date.now() < session.expiresAt;
+      if (valid) {
+        const fallback2 = readFallbackToken();
+        if (!fallback2 && session.bootSource === "fallback") {
+          clearSession();
+          return null;
+        }
+        if (fallback2 && fallback2.token !== session.token) {
+          return adoptFallbackToken(fallback2.token, session);
+        }
+        return session;
+      }
+      clearSession();
+    }
+  } catch {
+    clearSession();
+  }
+  const fallback = readFallbackToken();
+  if (!fallback) return null;
+  return adoptFallbackToken(fallback.token, null);
+}
+function adoptFallbackToken(token, prior) {
+  const jwtExp = jwtExpiresAt(token);
+  const now = Date.now();
+  const expiresAt = jwtExp ?? now + DEFAULT_SESSION_TTL_SECONDS * 1e3;
+  if (now >= expiresAt) return null;
+  const session = {
+    token,
+    userId: jwtUserId(token) || prior?.userId || "",
+    sessionId: prior?.sessionId ?? newSessionId(),
+    expiresAt,
+    lastActive: now,
+    history: prior?.history ?? [],
+    bootSource: "fallback"
+  };
+  if (isBrowser()) {
+    try {
+      window.localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+    } catch {
+    }
+  }
+  return session;
+}
+function writeSession(data, ttlSeconds = DEFAULT_SESSION_TTL_SECONDS) {
+  if (!isBrowser()) return null;
+  const now = Date.now();
+  const existing = readSession();
+  const base = existing ?? {
+    token: "",
+    userId: "",
+    sessionId: newSessionId(),
+    expiresAt: now + ttlSeconds * 1e3,
+    lastActive: now,
+    history: []
+  };
+  const merged = {
+    ...base,
+    ...data,
+    sessionId: data.sessionId ?? base.sessionId ?? newSessionId(),
+    lastActive: now,
+    expiresAt: now + ttlSeconds * 1e3,
+    history: trimHistory(data.history ?? base.history)
+  };
+  try {
+    window.localStorage.setItem(SESSION_KEY, JSON.stringify(merged));
+    return merged;
+  } catch {
+    return null;
+  }
+}
+function clearSession() {
+  if (!isBrowser()) return;
+  try {
+    window.localStorage.removeItem(SESSION_KEY);
+  } catch {
+  }
+}
+function trimHistory(history) {
+  if (!Array.isArray(history)) return [];
+  if (history.length <= MAX_HISTORY) return history;
+  return history.slice(history.length - MAX_HISTORY);
+}
+function touchSession(ttlSeconds = DEFAULT_SESSION_TTL_SECONDS) {
+  const current = readSession();
+  if (!current) return null;
+  return writeSession({}, ttlSeconds);
+}
+
+// src/api/chatApi.ts
+var DEFAULT_TIMEOUT_MS = 2e4;
+var DEFAULT_RETRIES = 2;
+var RETRY_BASE_DELAY_MS = 400;
+var ApiError = class extends Error {
+  constructor(message, status, requestId) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.requestId = requestId;
+  }
+};
+var AuthExpiredError = class extends ApiError {
+  constructor(requestId) {
+    super("Session expired or invalid", 401, requestId);
+    this.name = "AuthExpiredError";
+  }
+};
+var generateRequestId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var joinUrl = (base, path) => {
+  const trimmedBase = base.replace(/\/+$/, "");
+  const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedBase}${trimmedPath}`;
+};
+async function request(apiBase, path, opts = {}) {
+  const {
+    method = "GET",
+    body,
+    signal,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    retries = DEFAULT_RETRIES,
+    auth = true
+  } = opts;
+  const url = /^https?:\/\//i.test(path) ? path : joinUrl(apiBase, path);
+  const requestId = generateRequestId();
+  let lastError = null;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const onUserAbort = () => controller.abort();
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(timeoutId);
+        throw new DOMException("Aborted", "AbortError");
+      }
+      signal.addEventListener("abort", onUserAbort, { once: true });
+    }
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Request-Id": requestId
+      };
+      if (auth) {
+        const session = readSession();
+        if (session?.token) headers["Authorization"] = `Bearer ${session.token}`;
+      }
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal,
+        credentials: "same-origin"
+      });
+      if (res.status === 401 || res.status === 403) {
+        clearSession();
+        throw new AuthExpiredError(requestId);
+      }
+      if (res.status >= 500 && attempt < retries) {
+        lastError = new ApiError(`Server error ${res.status}`, res.status, requestId);
+        throw lastError;
+      }
+      if (!res.ok) {
+        let detail = res.statusText;
+        try {
+          const errBody = await res.json();
+          detail = errBody.message ?? errBody.detail ?? detail;
+        } catch {
+        }
+        throw new ApiError(detail || `HTTP ${res.status}`, res.status, requestId);
+      }
+      if (res.status === 204) return void 0;
+      return await res.json();
+    } catch (err) {
+      const error = err;
+      const isAbort = error.name === "AbortError";
+      const isAuth = error instanceof AuthExpiredError;
+      const isRetryable = !isAuth && !signal?.aborted && (isAbort || error instanceof TypeError || error.status >= 500);
+      if (isAuth || !isRetryable || attempt === retries) {
+        throw error;
+      }
+      lastError = error;
+      await sleep(RETRY_BASE_DELAY_MS * Math.pow(2, attempt));
+    } finally {
+      clearTimeout(timeoutId);
+      if (signal) signal.removeEventListener("abort", onUserAbort);
+    }
+  }
+  throw lastError ?? new Error("Request failed");
+}
+async function checkAuth(apiBase, authCheck, signal) {
+  return request(apiBase, authCheck, {
+    method: "GET",
+    signal,
+    retries: 1
+  });
+}
+async function sendChip(apiBase, chip, sessionId, signal) {
+  const path = chip.apiPath ?? `/chip/${chip.id}`;
+  return request(apiBase, path, {
+    method: "POST",
+    body: { chipId: chip.id, sessionId },
+    signal
+  });
+}
+async function sendMessage(apiBase, message, sessionId, context, signal) {
+  return request(apiBase, "/message", {
+    method: "POST",
+    body: { message, sessionId, context },
+    signal
+  });
+}
+async function logout(apiBase, signal) {
+  try {
+    await request(apiBase, "/auth/logout", {
+      method: "POST",
+      signal,
+      retries: 0
+    });
+  } finally {
+    clearSession();
+  }
+}
+
+// src/hooks/useAuth.ts
+function useAuth(opts) {
+  const { apiBase, authCheck, enabled = true, onError } = opts;
+  const [user, setUser] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [tick, setTick] = react.useState(0);
+  const onErrorRef = react.useRef(onError);
+  react.useEffect(() => {
+    onErrorRef.current = onError;
+  }, [onError]);
+  react.useEffect(() => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    const session = readSession();
+    if (!session?.token) {
+      setUser(null);
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    checkAuth(apiBase, authCheck, controller.signal).then((u) => {
+      setUser(u);
+      setError(null);
+    }).catch((err) => {
+      if (err.name === "AbortError") return;
+      if (err instanceof AuthExpiredError) {
+        clearSession();
+        setUser(null);
+      } else {
+        setError(err);
+        onErrorRef.current?.(err);
+      }
+    }).finally(() => {
+      if (!controller.signal.aborted) setLoading(false);
+    });
+    return () => controller.abort();
+  }, [apiBase, authCheck, enabled, tick]);
+  const refresh = react.useCallback(() => setTick((t) => t + 1), []);
+  return {
+    isLoggedIn: user !== null,
+    user,
+    loading,
+    error,
+    refresh
+  };
+}
+var initialState = {
+  messages: [],
+  isTyping: false,
+  status: "idle",
+  error: null
+};
+function reducer(state, action) {
+  switch (action.type) {
+    case "ADD_MESSAGE": {
+      const next = [...state.messages, action.payload];
+      const trimmed = next.length > MAX_HISTORY ? next.slice(next.length - MAX_HISTORY) : next;
+      return { ...state, messages: trimmed };
+    }
+    case "SET_TYPING":
+      return { ...state, isTyping: action.payload };
+    case "SET_STATUS":
+      return { ...state, status: action.payload };
+    case "SET_ERROR":
+      return { ...state, error: action.payload };
+    case "DEACTIVATE_CHIPS":
+      return {
+        ...state,
+        messages: state.messages.map(
+          (m) => m.id === action.payload.exceptId ? m : { ...m, chipsActive: false }
+        )
+      };
+    case "LOAD_HISTORY":
+      return { ...state, messages: action.payload };
+    case "CLEAR":
+      return initialState;
+    default:
+      return state;
+  }
+}
+function useChat(opts) {
+  const { apiBase, sessionId, initialMessages, onHistoryChange, onError, onAuthExpired } = opts;
+  const [state, dispatch] = react.useReducer(reducer, initialState);
+  const abortRef = react.useRef(null);
+  const onHistoryChangeRef = react.useRef(onHistoryChange);
+  const onErrorRef = react.useRef(onError);
+  const onAuthExpiredRef = react.useRef(onAuthExpired);
+  react.useEffect(() => {
+    onHistoryChangeRef.current = onHistoryChange;
+    onErrorRef.current = onError;
+    onAuthExpiredRef.current = onAuthExpired;
+  }, [onHistoryChange, onError, onAuthExpired]);
+  react.useEffect(() => {
+    if (initialMessages && initialMessages.length > 0) {
+      dispatch({ type: "LOAD_HISTORY", payload: initialMessages });
+    }
+  }, []);
+  react.useEffect(() => {
+    onHistoryChangeRef.current?.(state.messages);
+  }, [state.messages]);
+  react.useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const appendUserMessage = react.useCallback((content) => {
+    const msg = {
+      id: newMessageId(),
+      role: "user",
+      content,
+      timestamp: Date.now()
+    };
+    dispatch({ type: "ADD_MESSAGE", payload: msg });
+    return msg;
+  }, []);
+  const appendBotResponse = react.useCallback((resp) => {
+    const botMsg = {
+      id: newMessageId(),
+      role: "bot",
+      content: resp.message,
+      chips: resp.chips ?? [],
+      chipsActive: (resp.chips ?? []).length > 0,
+      timestamp: Date.now()
+    };
+    dispatch({ type: "ADD_MESSAGE", payload: botMsg });
+  }, []);
+  const deactivatePriorChips = react.useCallback((keepId) => {
+    dispatch({ type: "DEACTIVATE_CHIPS", payload: { exceptId: keepId } });
+  }, []);
+  const sendText = react.useCallback(
+    async (text) => {
+      const trimmed = text.trim();
+      if (!trimmed || !sessionId) return;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      deactivatePriorChips();
+      appendUserMessage(trimmed);
+      dispatch({ type: "SET_TYPING", payload: true });
+      dispatch({ type: "SET_STATUS", payload: "sending" });
+      dispatch({ type: "SET_ERROR", payload: null });
+      try {
+        const context = state.messages.slice(-20);
+        const resp = await sendMessage(apiBase, trimmed, sessionId, context, controller.signal);
+        appendBotResponse(resp);
+        dispatch({ type: "SET_STATUS", payload: "idle" });
+      } catch (err) {
+        const error = err;
+        if (error.name === "AbortError") return;
+        if (error instanceof AuthExpiredError) {
+          onAuthExpiredRef.current?.();
+        } else {
+          onErrorRef.current?.(error);
+          dispatch({ type: "SET_ERROR", payload: error.message });
+        }
+        dispatch({ type: "SET_STATUS", payload: "error" });
+      } finally {
+        dispatch({ type: "SET_TYPING", payload: false });
+      }
+    },
+    [apiBase, sessionId, state.messages, appendUserMessage, appendBotResponse, deactivatePriorChips]
+  );
+  const clear = react.useCallback(() => {
+    abortRef.current?.abort();
+    dispatch({ type: "CLEAR" });
+  }, []);
+  const loadHistory = react.useCallback((history) => {
+    dispatch({ type: "LOAD_HISTORY", payload: history });
+  }, []);
+  const setTyping = react.useCallback((value) => {
+    dispatch({ type: "SET_TYPING", payload: value });
+  }, []);
+  return {
+    state,
+    sendText,
+    appendBotResponse,
+    appendUserMessage,
+    deactivatePriorChips,
+    clear,
+    loadHistory,
+    setTyping
+  };
+}
+function useChip(opts) {
+  const { apiBase, sessionId, onAuthExpired, onError } = opts;
+  const abortRef = react.useRef(null);
+  const onAuthExpiredRef = react.useRef(onAuthExpired);
+  const onErrorRef = react.useRef(onError);
+  react.useEffect(() => {
+    onAuthExpiredRef.current = onAuthExpired;
+    onErrorRef.current = onError;
+  }, [onAuthExpired, onError]);
+  react.useEffect(() => {
+    return () => abortRef.current?.abort();
+  }, []);
+  const callChip = react.useCallback(
+    async (chip) => {
+      if (!sessionId) return null;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        return await sendChip(apiBase, chip, sessionId, controller.signal);
+      } catch (err) {
+        const error = err;
+        if (error.name === "AbortError") return null;
+        if (error instanceof AuthExpiredError) {
+          onAuthExpiredRef.current?.();
+        } else {
+          onErrorRef.current?.(error);
+        }
+        return null;
+      }
+    },
+    [apiBase, sessionId]
+  );
+  return { callChip };
+}
+function useSession(opts = {}) {
+  const { ttlSeconds = DEFAULT_SESSION_TTL_SECONDS, onExpire } = opts;
+  const [session, setSession] = react.useState(null);
+  const [remainingMs, setRemainingMs] = react.useState(0);
+  const expiredRef = react.useRef(false);
+  const onExpireRef = react.useRef(onExpire);
+  react.useEffect(() => {
+    onExpireRef.current = onExpire;
+  }, [onExpire]);
+  react.useEffect(() => {
+    const current = readSession();
+    setSession(current);
+    setRemainingMs(current ? current.expiresAt - Date.now() : 0);
+  }, []);
+  react.useEffect(() => {
+    if (!session) return;
+    const interval = window.setInterval(() => {
+      const current = readSession();
+      if (!current) {
+        if (!expiredRef.current) {
+          expiredRef.current = true;
+          onExpireRef.current?.();
+        }
+        setSession(null);
+        setRemainingMs(0);
+        return;
+      }
+      setRemainingMs(current.expiresAt - Date.now());
+    }, 15e3);
+    return () => window.clearInterval(interval);
+  }, [session]);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const onStorage = (e) => {
+      if (e.key && e.key !== "wac_session") return;
+      const current = readSession();
+      setSession(current);
+      setRemainingMs(current ? current.expiresAt - Date.now() : 0);
+    };
+    window.addEventListener("storage", onStorage);
+    return () => window.removeEventListener("storage", onStorage);
+  }, []);
+  const setToken = react.useCallback(
+    (token, userId) => {
+      expiredRef.current = false;
+      const updated = writeSession(
+        {
+          token,
+          userId,
+          sessionId: readSession()?.sessionId ?? newSessionId(),
+          history: readSession()?.history ?? []
+        },
+        ttlSeconds
+      );
+      setSession(updated);
+      setRemainingMs(updated ? updated.expiresAt - Date.now() : 0);
+    },
+    [ttlSeconds]
+  );
+  const setHistory = react.useCallback(
+    (history) => {
+      const updated = writeSession({ history }, ttlSeconds);
+      if (updated) {
+        setSession(updated);
+        setRemainingMs(updated.expiresAt - Date.now());
+      }
+    },
+    [ttlSeconds]
+  );
+  const touch = react.useCallback(() => {
+    const updated = touchSession(ttlSeconds);
+    if (updated) {
+      setSession(updated);
+      setRemainingMs(updated.expiresAt - Date.now());
+    }
+  }, [ttlSeconds]);
+  const clear = react.useCallback(() => {
+    clearSession();
+    setSession(null);
+    setRemainingMs(0);
+    expiredRef.current = true;
+  }, []);
+  return { session, remainingMs, setToken, setHistory, touch, clear };
+}
+
+// src/styles/chat.module.css
+var chat_default = {
+  root: "chat_root",
+  floatingButton: "chat_floatingButton",
+  positionRight: "chat_positionRight",
+  positionLeft: "chat_positionLeft",
+  widget: "chat_widget",
+  header: "chat_header",
+  headerTitle: "chat_headerTitle",
+  headerMeta: "chat_headerMeta",
+  headerActions: "chat_headerActions",
+  iconButton: "chat_iconButton",
+  body: "chat_body",
+  bubble: "chat_bubble",
+  markdown: "chat_markdown",
+  bubbleBot: "chat_bubbleBot",
+  bubbleUser: "chat_bubbleUser",
+  chipRow: "chat_chipRow",
+  chip: "chat_chip",
+  chipActive: "chat_chipActive",
+  chipDisabled: "chat_chipDisabled",
+  typing: "chat_typing",
+  typingDot: "chat_typingDot",
+  input: "chat_input",
+  inputBox: "chat_inputBox",
+  sendButton: "chat_sendButton",
+  authGate: "chat_authGate",
+  authGateIcon: "chat_authGateIcon",
+  authGateTitle: "chat_authGateTitle",
+  authGateText: "chat_authGateText",
+  authGateButton: "chat_authGateButton",
+  authGateDisclaimer: "chat_authGateDisclaimer",
+  authGateDisclaimerTitle: "chat_authGateDisclaimerTitle",
+  errorBanner: "chat_errorBanner"
+};
+function AuthGate({ brandName, loginUrl, onLoginClick }) {
+  const handleClick = () => {
+    if (onLoginClick) {
+      onLoginClick();
+      return;
+    }
+    if (typeof window !== "undefined") {
+      window.location.href = loginUrl;
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.authGate, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.authGateIcon, "aria-hidden": "true", children: "\u{1F512}" }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.authGateTitle, children: "Login required" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.authGateText, children: [
+      "To access ",
+      brandName,
+      ", please sign in first."
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: chat_default.authGateButton, onClick: handleClick, children: "Sign in / Register \u2192" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.authGateDisclaimer, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.authGateDisclaimerTitle, children: "DISCLAIMER" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { children: "\u2022 AI-assisted analysis for educational purposes only." }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { children: "\u2022 Not financial advice. Markets involve risk." }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { children: "\u2022 Consult a SEBI-registered advisor before investing." })
+    ] })
+  ] });
+}
+function Chip({ chip, disabled, active, onClick }) {
+  const classes = [
+    chat_default.chip,
+    active ? chat_default.chipActive : "",
+    disabled ? chat_default.chipDisabled : ""
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      className: classes,
+      disabled,
+      onClick: () => !disabled && onClick(chip),
+      children: [
+        chip.icon ? /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", children: chip.icon }) : null,
+        /* @__PURE__ */ jsxRuntime.jsx("span", { children: chip.label })
+      ]
+    }
+  );
+}
+function ChipRow({ chips, disabled, onClick }) {
+  if (!chips || chips.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.chipRow, children: chips.map((c) => /* @__PURE__ */ jsxRuntime.jsx(Chip, { chip: c, disabled, onClick }, c.id)) });
+}
+var ALLOWED_TAGS = [
+  "b",
+  "strong",
+  "i",
+  "em",
+  "u",
+  "ins",
+  "s",
+  "strike",
+  "del",
+  "br",
+  "p",
+  "code",
+  "pre",
+  "a",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "span"
+];
+var ALLOWED_ATTR = ["href", "target", "rel", "class"];
+var SANITIZE_CFG = {
+  ALLOWED_TAGS,
+  ALLOWED_ATTR,
+  // Block javascript: / data: hrefs by stripping URI schemes other than http(s) / mailto
+  ALLOW_UNKNOWN_PROTOCOLS: false,
+  ALLOWED_URI_REGEXP: /^(?:(?:https?|mailto):|[^a-z]|[a-z+.-]+(?:[^a-z+.\-:]|$))/i
+};
+function inlineMarkdownToHtml(text) {
+  return text.replace(/^[ \t]*#{1,6}[ \t]+(.+?)[ \t]*$/gm, "<b>$1</b>").replace(/\*\*([^\n<>]+?)\*\*/g, "<b>$1</b>").replace(/__([^\n<>]+?)__/g, "<b>$1</b>").replace(/(?<!\*)\*([^\n*<>]+?)\*(?!\*)/g, "<b>$1</b>").replace(/(?<![_a-zA-Z0-9])_([^\n_<>]+?)_(?![_a-zA-Z0-9])/g, "<i>$1</i>");
+}
+function renderMarkdown(text) {
+  if (!text) return "";
+  const inlined = inlineMarkdownToHtml(text);
+  const paragraphs = inlined.split(/\n{2,}/).map((para) => para.replace(/\n/g, "<br>")).filter((p) => p.length > 0);
+  const html = paragraphs.length > 1 ? paragraphs.map((p) => `<p>${p}</p>`).join("") : paragraphs[0] ?? "";
+  return DOMPurify__default.default.sanitize(html, SANITIZE_CFG);
+}
+function MessageBubble({ message, onChipClick }) {
+  const isBot = message.role === "bot";
+  const bubbleClass = isBot ? `${chat_default.bubble} ${chat_default.bubbleBot}` : `${chat_default.bubble} ${chat_default.bubbleUser}`;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", flexDirection: "column" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: bubbleClass, children: isBot ? /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: chat_default.markdown,
+        dangerouslySetInnerHTML: { __html: renderMarkdown(message.content) }
+      }
+    ) : message.content }),
+    isBot && message.chips && message.chips.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+      ChipRow,
+      {
+        chips: message.chips,
+        disabled: !message.chipsActive,
+        onClick: onChipClick
+      }
+    ) : null
+  ] });
+}
+function TypingIndicator() {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.typing, "aria-live": "polite", "aria-label": "Assistant is typing", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: chat_default.typingDot }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: chat_default.typingDot }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: chat_default.typingDot })
+  ] });
+}
+function ChatBody({
+  isLoggedIn,
+  loading,
+  messages,
+  isTyping,
+  brandName,
+  loginUrl,
+  error,
+  onChipClick,
+  onLoginClick
+}) {
+  const endRef = react.useRef(null);
+  react.useEffect(() => {
+    endRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages.length, isTyping]);
+  if (loading) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.body, children: /* @__PURE__ */ jsxRuntime.jsx(TypingIndicator, {}) });
+  }
+  if (!isLoggedIn) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.body, children: /* @__PURE__ */ jsxRuntime.jsx(
+      AuthGate,
+      {
+        brandName,
+        loginUrl,
+        onLoginClick
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.body, children: [
+    messages.map((m) => /* @__PURE__ */ jsxRuntime.jsx(MessageBubble, { message: m, onChipClick }, m.id)),
+    isTyping ? /* @__PURE__ */ jsxRuntime.jsx(TypingIndicator, {}) : null,
+    error ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.errorBanner, children: error }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: endRef })
+  ] });
+}
+
+// src/utils/time.ts
+function formatCountdown(remainingMs) {
+  if (remainingMs <= 0) return "expired";
+  const totalSeconds = Math.floor(remainingMs / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m left`;
+  if (minutes > 0) return `${minutes}m ${seconds}s left`;
+  return `${seconds}s left`;
+}
+function ChatHeader({
+  brandName,
+  remainingMs,
+  showCountdown,
+  onClose,
+  onClear
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.header, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: chat_default.headerTitle, children: brandName }),
+      showCountdown && remainingMs > 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.headerMeta, children: [
+        "Session: ",
+        formatCountdown(remainingMs)
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.headerActions, children: [
+      onClear ? /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: chat_default.iconButton,
+          onClick: onClear,
+          "aria-label": "Clear conversation",
+          title: "Clear conversation",
+          children: "\u21BA"
+        }
+      ) : null,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: chat_default.iconButton,
+          onClick: onClose,
+          "aria-label": "Close chat",
+          title: "Close",
+          children: "\u2715"
+        }
+      )
+    ] })
+  ] });
+}
+function ChatInput({ disabled, placeholder, onSend }) {
+  const [value, setValue] = react.useState("");
+  const submit = () => {
+    const trimmed = value.trim();
+    if (!trimmed || disabled) return;
+    onSend(trimmed);
+    setValue("");
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.input, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "text",
+        className: chat_default.inputBox,
+        value,
+        onChange: (e) => setValue(e.target.value),
+        onKeyDown: (e) => {
+          if (e.key === "Enter" && !e.shiftKey) {
+            e.preventDefault();
+            submit();
+          }
+        },
+        disabled,
+        placeholder: placeholder ?? "Type a message\u2026",
+        "aria-label": "Message input"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        className: chat_default.sendButton,
+        onClick: submit,
+        disabled: disabled || value.trim().length === 0,
+        children: "Send"
+      }
+    )
+  ] });
+}
+function FloatingButton({ position, onClick, brandColor }) {
+  const posClass = position === "bottom-left" ? chat_default.positionLeft : chat_default.positionRight;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      className: `${chat_default.floatingButton} ${posClass}`,
+      onClick,
+      "aria-label": "Open chat",
+      style: brandColor ? { background: brandColor } : void 0,
+      children: "\u{1F4AC}"
+    }
+  );
+}
+var DEFAULT_BRAND_NAME = "Wealth Alpha AI";
+var DEFAULT_BRAND_COLOR = "#1a2d5a";
+var DEFAULT_AUTH_CHECK = "/me";
+var DISCLAIMER_BLOCK = "DISCLAIMER:\n\u2022 AI-assisted analysis for educational purposes only.\n\u2022 Not financial advice. Markets involve risk.\n\u2022 Consult a SEBI-registered advisor before investing.";
+var CTA_LINE = "Select a quick command below \u2014 or type your query to ask our AI Research Analyst directly.";
+function buildWelcome(name, plan) {
+  const greeting = name ? `Welcome back, ${name}! You have ${plan ? plan : "Premium"} access.` : `Welcome! You have ${plan ? plan : "Premium"} access.`;
+  return `${greeting}
+
+${DISCLAIMER_BLOCK}
+
+${CTA_LINE}`;
+}
+function WealthChat(props) {
+  const {
+    apiBase,
+    authCheck = DEFAULT_AUTH_CHECK,
+    loginUrl,
+    sessionTTL = DEFAULT_SESSION_TTL_SECONDS,
+    welcomeMessage,
+    brandName = DEFAULT_BRAND_NAME,
+    brandColor = DEFAULT_BRAND_COLOR,
+    position = "bottom-right",
+    defaultOpen = false,
+    showCountdown = true,
+    onLogin,
+    onLogout,
+    onSessionExpire,
+    onError
+  } = props;
+  const [mounted, setMounted] = react.useState(false);
+  const [open, setOpen] = react.useState(defaultOpen);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  const {
+    session,
+    remainingMs,
+    setHistory,
+    touch,
+    clear: clearSessionState
+  } = useSession({
+    ttlSeconds: sessionTTL,
+    onExpire: onSessionExpire
+  });
+  const { isLoggedIn, user, loading: authLoading } = useAuth({
+    apiBase,
+    authCheck,
+    enabled: mounted && open,
+    onError
+  });
+  const handleAuthExpired = react.useCallback(() => {
+    clearSessionState();
+    onSessionExpire?.();
+  }, [clearSessionState, onSessionExpire]);
+  const handleHistoryChange = react.useCallback(
+    (history) => {
+      if (!session) return;
+      setHistory(history);
+    },
+    [session, setHistory]
+  );
+  const {
+    state: chatState,
+    sendText,
+    appendBotResponse,
+    appendUserMessage,
+    deactivatePriorChips,
+    setTyping,
+    loadHistory,
+    clear: clearChat
+  } = useChat({
+    apiBase,
+    sessionId: session?.sessionId ?? null,
+    initialMessages: session?.history,
+    onHistoryChange: handleHistoryChange,
+    onAuthExpired: handleAuthExpired,
+    onError
+  });
+  const { callChip } = useChip({
+    apiBase,
+    sessionId: session?.sessionId ?? null,
+    onAuthExpired: handleAuthExpired,
+    onError
+  });
+  const welcomeShownRef = react.useMemo(() => ({ shown: false }), []);
+  react.useEffect(() => {
+    if (!isLoggedIn || !open) return;
+    if (chatState.messages.length > 0) return;
+    if (welcomeShownRef.shown) return;
+    welcomeShownRef.shown = true;
+    const messageText = welcomeMessage ?? user?.welcomeMessage ?? buildWelcome(user?.name, user?.plan);
+    appendBotResponse({
+      message: messageText,
+      chips: user?.rootChips ?? [],
+      sessionId: session?.sessionId ?? "",
+      endOfFlow: false
+    });
+    onLogin?.();
+  }, [isLoggedIn, open, chatState.messages.length, welcomeMessage, session, user, appendBotResponse, onLogin, welcomeShownRef]);
+  const handleChipClick = react.useCallback(
+    async (chip) => {
+      touch();
+      deactivatePriorChips();
+      appendUserMessage(chip.label);
+      setTyping(true);
+      try {
+        const resp = await callChip(chip);
+        if (resp) appendBotResponse(resp);
+      } finally {
+        setTyping(false);
+      }
+    },
+    [touch, deactivatePriorChips, appendUserMessage, callChip, setTyping, appendBotResponse]
+  );
+  const handleSend = react.useCallback(
+    (text) => {
+      touch();
+      void sendText(text);
+    },
+    [touch, sendText]
+  );
+  const handleClose = react.useCallback(() => setOpen(false), []);
+  const handleClear = react.useCallback(() => {
+    clearChat();
+    welcomeShownRef.shown = false;
+    setHistory([]);
+  }, [clearChat, setHistory, welcomeShownRef]);
+  const handleLoginClick = react.useCallback(() => {
+    if (typeof window !== "undefined") {
+      window.location.href = loginUrl;
+    }
+  }, [loginUrl]);
+  if (!mounted) return null;
+  const rootStyle = {
+    ["--wac-brand"]: brandColor
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chat_default.root, style: rootStyle, children: [
+    !open ? /* @__PURE__ */ jsxRuntime.jsx(FloatingButton, { position, onClick: () => setOpen(true), brandColor }) : null,
+    open ? /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: `${chat_default.widget} ${position === "bottom-left" ? chat_default.positionLeft : chat_default.positionRight}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ChatHeader,
+            {
+              brandName,
+              remainingMs,
+              showCountdown: showCountdown && isLoggedIn,
+              onClose: handleClose,
+              onClear: isLoggedIn ? handleClear : void 0
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ChatBody,
+            {
+              isLoggedIn,
+              loading: authLoading,
+              messages: chatState.messages,
+              isTyping: chatState.isTyping,
+              brandName,
+              loginUrl,
+              error: chatState.error,
+              onChipClick: handleChipClick,
+              onLoginClick: handleLoginClick
+            }
+          ),
+          isLoggedIn ? /* @__PURE__ */ jsxRuntime.jsx(
+            ChatInput,
+            {
+              disabled: chatState.isTyping,
+              onSend: handleSend,
+              placeholder: "Type a message\u2026"
+            }
+          ) : null
+        ]
+      }
+    ) : null
+  ] });
+}
+
+exports.ApiError = ApiError;
+exports.AuthExpiredError = AuthExpiredError;
+exports.AuthGate = AuthGate;
+exports.ChatBody = ChatBody;
+exports.ChatHeader = ChatHeader;
+exports.ChatInput = ChatInput;
+exports.Chip = Chip;
+exports.ChipRow = ChipRow;
+exports.DEFAULT_SESSION_TTL_SECONDS = DEFAULT_SESSION_TTL_SECONDS;
+exports.FloatingButton = FloatingButton;
+exports.MessageBubble = MessageBubble;
+exports.SESSION_KEY = SESSION_KEY;
+exports.TypingIndicator = TypingIndicator;
+exports.WealthChat = WealthChat;
+exports.checkAuth = checkAuth;
+exports.clearSession = clearSession;
+exports.logout = logout;
+exports.readSession = readSession;
+exports.sendChip = sendChip;
+exports.sendMessage = sendMessage;
+exports.touchSession = touchSession;
+exports.useAuth = useAuth;
+exports.useChat = useChat;
+exports.useChip = useChip;
+exports.useSession = useSession;
+exports.writeSession = writeSession;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map