@akropolys/sdk 1.0.2 → 1.1.0

package/dist/chunk-UKF434HE.mjs

@@ -0,0 +1,1100 @@
+'use client';
+
+// src/api.ts
+var MAX_RETRIES = 3;
+var RETRY_DELAYS = [500, 1e3, 2e3];
+function log(level, msg, data) {
+  const prefix = "[Akropolys]";
+  if (level === "error") console.error(prefix, msg, data ?? "");
+  else if (level === "warn") console.warn(prefix, msg, data ?? "");
+  else console.log(prefix, msg, data ?? "");
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var AkropolysAPI = class {
+  constructor(apiUrl, siteId, apiToken, getShopperId, getSessionId, vertical) {
+    this.apiUrl = apiUrl;
+    this.siteId = siteId;
+    this.apiToken = apiToken;
+    this.getShopperId = getShopperId;
+    this.getSessionId = getSessionId;
+    this.vertical = vertical;
+  }
+  async post(path, body, attempt = 0) {
+    const url = `${this.apiUrl}${path}`;
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Akropolys-Token": this.apiToken,
+        "X-Akropolys-Site": this.siteId
+      };
+      const shopperId = this.getShopperId?.();
+      if (shopperId) {
+        headers["X-Akropolys-Shopper-Id"] = shopperId;
+      }
+      const sessionId = this.getSessionId?.();
+      if (sessionId) {
+        headers["X-Akropolys-Session-Id"] = sessionId;
+      }
+      if (typeof window !== "undefined") {
+        const phone = localStorage.getItem("akropolys_user_phone");
+        if (phone) {
+          headers["X-Akropolys-Shopper-Phone"] = phone;
+        }
+      }
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        let message = text;
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed && typeof parsed.error === "string") {
+            message = parsed.error;
+          }
+        } catch {
+        }
+        const err = { status: res.status, message };
+        if (res.status >= 400 && res.status < 500) {
+          log("error", `${path} failed [${res.status}]`, text);
+          throw err;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} [${res.status}] retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} failed after ${MAX_RETRIES} attempts`, err);
+        throw err;
+      }
+      return res.json();
+    } catch (e) {
+      if (e.status === void 0) {
+        if (attempt < MAX_RETRIES - 1) {
+          log("warn", `${path} network error, retrying (${attempt + 1}/${MAX_RETRIES})...`);
+          await sleep(RETRY_DELAYS[attempt]);
+          return this.post(path, body, attempt + 1);
+        }
+        log("error", `${path} unreachable after ${MAX_RETRIES} attempts`);
+      }
+      throw e;
+    }
+  }
+  async ingest(product) {
+    log("info", "ingesting product", product.name || product.id || "");
+    return this.post("/ingest", { siteId: this.siteId, product });
+  }
+  async ingestBatch(products) {
+    log("info", `ingesting batch of ${products.length} products`);
+    return this.post("/ingest/batch", { siteId: this.siteId, products });
+  }
+  async search(query, limit = 10) {
+    log("info", "search query", query);
+    return this.post("/search", { query, siteId: this.siteId, limit });
+  }
+  // Pure vector search — no LLM, instant results.
+  async searchVector(query, limit = 10) {
+    return this.post("/search/vector", { query, siteId: this.siteId, limit });
+  }
+  // Autocomplete — pure in-memory Trie, <1ms, no Upstash call. Only true prefix matches.
+  async searchAutocomplete(query, limit = 8) {
+    return this.post("/search/autocomplete", { query, siteId: this.siteId, limit });
+  }
+  // LLM chat — conversational search with history context.
+  async chat(query, history = []) {
+    log("info", "chat query", query);
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat" : `/chat/${this.vertical}`;
+    return this.post(path, { query, siteId: this.siteId, history });
+  }
+  // Streaming variant — returns the raw fetch Response.
+  // The caller reads body as a ReadableStream of SSE frames.
+  async chatStream(query, history = [], signal) {
+    log("info", "chatStream query", query);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = this.getShopperId?.();
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = this.getSessionId?.();
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) headers["X-Akropolys-Shopper-Phone"] = phone;
+    }
+    const path = !this.vertical || this.vertical === "commerce" ? "/chat/stream" : `/chat/stream/${this.vertical}`;
+    const res = await fetch(`${this.apiUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, siteId: this.siteId, history }),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Stream request failed: ${res.status}`);
+    }
+    return res;
+  }
+  // --- Cart System ---
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Akropolys-Token": this.apiToken,
+      "X-Akropolys-Site": this.siteId
+    };
+    const shopperId = this.getShopperId?.();
+    if (shopperId) headers["X-Akropolys-Shopper-Id"] = shopperId;
+    const sessionId = this.getSessionId?.();
+    if (sessionId) headers["X-Akropolys-Session-Id"] = sessionId;
+    if (typeof window !== "undefined") {
+      const phone = localStorage.getItem("akropolys_user_phone");
+      if (phone) {
+        headers["X-Akropolys-Shopper-Phone"] = phone;
+      }
+    }
+    return headers;
+  }
+  async getCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch cart");
+    return res.json();
+  }
+  async clearCart() {
+    const res = await fetch(`${this.apiUrl}/cart?siteId=${this.siteId}`, {
+      method: "DELETE",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to clear cart");
+    return res.json();
+  }
+  async checkoutCart() {
+    const res = await fetch(`${this.apiUrl}/cart/checkout`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({ siteId: this.siteId })
+    });
+    if (!res.ok) throw new Error("Failed to checkout cart");
+    return res.json();
+  }
+  async getCheckoutConfig() {
+    const res = await fetch(`${this.apiUrl}/checkout/config?site_id=${this.siteId}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to fetch checkout config");
+    return res.json();
+  }
+  async initiatePayment(phoneNumber, email, firstName, lastName) {
+    const res = await fetch(`${this.apiUrl}/payment/initiate`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify({
+        siteId: this.siteId,
+        phoneNumber,
+        email,
+        firstName,
+        lastName
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error("Failed to initiate payment: " + errText);
+    }
+    return res.json();
+  }
+  async getPaymentStatus(ref) {
+    const res = await fetch(`${this.apiUrl}/payment/status?ref=${ref}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!res.ok) throw new Error("Failed to get payment status");
+    return res.json();
+  }
+};
+
+// src/stream.ts
+function parseSSEChunk(raw) {
+  const frames = [];
+  const blocks = raw.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    let event = "";
+    let data = "";
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) data = line.slice(5);
+    }
+    if (data !== "") frames.push({ event, data });
+  }
+  return frames;
+}
+var KikuStream = class {
+  constructor(responsePromise, abortController) {
+    this.listeners = {};
+    this.aborted = false;
+    this.responsePromise = responsePromise;
+    this.abortController = abortController;
+    this.startReading();
+  }
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+    return this;
+  }
+  off(event, callback) {
+    if (!this.listeners[event]) return this;
+    this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+    return this;
+  }
+  destroy() {
+    this.aborted = true;
+    this.abortController.abort();
+  }
+  emit(event, ...args) {
+    const list = this.listeners[event];
+    if (!list) return;
+    for (const cb of list) {
+      try {
+        cb(...args);
+      } catch (err) {
+        console.error(`[Akropolys] Error in KikuStream event listener for "${event}":`, err);
+      }
+    }
+  }
+  async startReading() {
+    try {
+      const response = await this.responsePromise;
+      if (this.aborted) return;
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let accumulatedMessage = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || this.aborted) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lastBoundary = buffer.lastIndexOf("\n\n");
+        if (lastBoundary === -1) continue;
+        const complete = buffer.slice(0, lastBoundary + 2);
+        buffer = buffer.slice(lastBoundary + 2);
+        const frames = parseSSEChunk(complete);
+        for (const { event, data } of frames) {
+          if (this.aborted) return;
+          if (event === "meta") {
+            try {
+              const meta = JSON.parse(data);
+              this.emit("meta", meta);
+            } catch {
+            }
+            continue;
+          }
+          if (event === "done") {
+            break;
+          }
+          if (event === "error") {
+            let msg = "Stream error";
+            try {
+              msg = JSON.parse(data).error ?? msg;
+            } catch {
+              msg = data;
+            }
+            throw new Error(msg);
+          }
+          const token = data.replace(/\\n/g, "\n");
+          accumulatedMessage += token;
+          this.emit("token", token);
+        }
+      }
+      if (!this.aborted) {
+        this.emit("done", accumulatedMessage);
+      }
+    } catch (err) {
+      if (!this.aborted) {
+        this.emit("error", err);
+      }
+    }
+  }
+};
+
+// src/client.ts
+var defaultVertical = "commerce";
+function setSDKDefaultVertical(v) {
+  defaultVertical = v;
+}
+function getEnvVar(key) {
+  if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_SITE_ID;
+    } catch {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_URL;
+    } catch {
+    }
+  }
+  if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") {
+    try {
+      return process.env.NEXT_PUBLIC_AKROPOLYS_API_TOKEN;
+    } catch {
+    }
+  }
+  try {
+    const metaEnv = import.meta.env;
+    if (metaEnv) {
+      if (key === "NEXT_PUBLIC_AKROPOLYS_SITE_ID") return metaEnv.NEXT_PUBLIC_AKROPOLYS_SITE_ID || metaEnv.VITE_AKROPOLYS_SITE_ID;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_URL") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_URL || metaEnv.VITE_AKROPOLYS_API_URL;
+      if (key === "NEXT_PUBLIC_AKROPOLYS_API_TOKEN") return metaEnv.NEXT_PUBLIC_AKROPOLYS_API_TOKEN || metaEnv.VITE_AKROPOLYS_API_TOKEN;
+    }
+  } catch {
+  }
+  if (typeof globalThis !== "undefined") {
+    const g = globalThis;
+    if (g.process && g.process.env) {
+      return g.process.env[key];
+    }
+  }
+  return void 0;
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var _AkropolysClient = class _AkropolysClient {
+  constructor(config) {
+    this.ingestQueue = [];
+    this.ingestTimer = null;
+    this.ingestedUrls = /* @__PURE__ */ new Set();
+    this.onlineHandler = null;
+    this.sessionId = "";
+    this.isFlushing = false;
+    this.retryCount = 0;
+    const siteId = config.siteId || getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID") || "";
+    const apiUrl = config.apiUrl || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL") || "";
+    const apiToken = config.apiToken || getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN") || "";
+    if (!siteId) console.error('[Akropolys] Missing siteId. Set it via <AkropolysProvider siteId="..."> or NEXT_PUBLIC_AKROPOLYS_SITE_ID.');
+    if (!apiUrl) console.error('[Akropolys] Missing apiUrl. Set it via <AkropolysProvider apiUrl="..."> or NEXT_PUBLIC_AKROPOLYS_API_URL.');
+    if (!apiToken) console.error('[Akropolys] Missing apiToken. Set it via <AkropolysProvider apiToken="..."> or NEXT_PUBLIC_AKROPOLYS_API_TOKEN.');
+    this.shopperId = config.shopperId;
+    this.authLoading = config.authLoading;
+    this.onCheckout = config.onCheckout;
+    this.onError = config.onError;
+    this.vertical = config.vertical || defaultVertical;
+    this.initSession();
+    this.loadIngestedCache();
+    this.api = new AkropolysAPI(
+      apiUrl,
+      siteId,
+      apiToken,
+      () => this.getShopperId(),
+      () => this.sessionId,
+      this.vertical
+    );
+    instance = this;
+    if (typeof window !== "undefined") {
+      this.onlineHandler = () => {
+        console.log("[Akropolys] Connectivity restored, flushing queued ingestions.");
+        this.flushQueue();
+      };
+      window.addEventListener("online", this.onlineHandler);
+    }
+  }
+  // 24h
+  loadIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      const raw = localStorage.getItem(_AkropolysClient.INGEST_CACHE_KEY);
+      if (!raw) return;
+      const { ts, urls } = JSON.parse(raw);
+      if (Date.now() - ts > _AkropolysClient.INGEST_CACHE_TTL) {
+        localStorage.removeItem(_AkropolysClient.INGEST_CACHE_KEY);
+        return;
+      }
+      this.ingestedUrls = new Set(urls);
+    } catch {
+    }
+  }
+  saveIngestedCache() {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(
+        _AkropolysClient.INGEST_CACHE_KEY,
+        JSON.stringify({ ts: Date.now(), urls: [...this.ingestedUrls] })
+      );
+    } catch {
+    }
+  }
+  chat(query, history = []) {
+    const abortController = new AbortController();
+    const responsePromise = this.api.chatStream(query, history, abortController.signal);
+    return new KikuStream(responsePromise, abortController);
+  }
+  reRegister() {
+    instance = this;
+    if (typeof window !== "undefined" && !this.onlineHandler) {
+      this.onlineHandler = () => this.flushQueue();
+      window.addEventListener("online", this.onlineHandler);
+    }
+  }
+  setShopperId(id) {
+    this.shopperId = id;
+    if (!this.authLoading) {
+      this.flushQueue();
+    }
+  }
+  setAuthLoading(loading) {
+    const wasLoading = this.authLoading;
+    this.authLoading = loading;
+    if (wasLoading && !loading) {
+      this.flushQueue();
+    }
+  }
+  getShopperId() {
+    return this.shopperId || "guest_" + this.sessionId;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  initSession() {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        let sid = window.sessionStorage.getItem("akropolys_session_id");
+        if (!sid) {
+          sid = generateUUID();
+          window.sessionStorage.setItem("akropolys_session_id", sid);
+        }
+        this.sessionId = sid;
+        return;
+      } catch (e) {
+      }
+    }
+    this.sessionId = generateUUID();
+  }
+  destroy() {
+    if (typeof window !== "undefined" && this.onlineHandler) {
+      window.removeEventListener("online", this.onlineHandler);
+      this.onlineHandler = null;
+    }
+    if (this.ingestTimer) {
+      clearTimeout(this.ingestTimer);
+      this.ingestTimer = null;
+    }
+    if (instance === this) instance = null;
+  }
+  async queueIngest(rawItem) {
+    const id = rawItem.id ?? rawItem.productId ?? rawItem.slug ?? rawItem.url ?? rawItem.name ?? "";
+    const url = rawItem.url || (typeof window !== "undefined" ? window.location.href : "");
+    if (!id && !url) {
+      console.warn("[Akropolys] Ingestion warning: Item is missing both a stable identifier and a URL. Skipping.");
+      return;
+    }
+    if (url) {
+      if (this.ingestedUrls.has(url)) {
+        return;
+      }
+      this.ingestedUrls.add(url);
+      this.saveIngestedCache();
+    }
+    this.ingestQueue.push(rawItem);
+    this.scheduleFlush();
+  }
+  async queueIngestBatch(rawItems) {
+    let hasNew = false;
+    rawItems.forEach((rawItem) => {
+      const id = rawItem.id ?? rawItem.productId ?? rawItem.slug ?? rawItem.url ?? rawItem.name ?? "";
+      const url = rawItem.url || (typeof window !== "undefined" ? window.location.href : "");
+      if (!id && !url) {
+        console.warn("[Akropolys] Ingestion warning: Item is missing both a stable identifier and a URL. Skipping.");
+        return;
+      }
+      if (url) {
+        if (this.ingestedUrls.has(url)) {
+          return;
+        }
+        this.ingestedUrls.add(url);
+        hasNew = true;
+      }
+      this.ingestQueue.push(rawItem);
+    });
+    if (hasNew) {
+      this.saveIngestedCache();
+    }
+    if (this.ingestQueue.length > 0) {
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.ingestTimer || this.isFlushing) return;
+    this.ingestTimer = setTimeout(() => {
+      this.flushQueue();
+    }, 300);
+  }
+  async flushQueue() {
+    if (this.isFlushing) return;
+    this.isFlushing = true;
+    if (this.ingestTimer) {
+      clearTimeout(this.ingestTimer);
+      this.ingestTimer = null;
+    }
+    if (this.authLoading) {
+      console.log("[Akropolys] Authentication is loading. Deferring ingestion flush.");
+      this.isFlushing = false;
+      return;
+    }
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      console.warn("[Akropolys] Browser offline. Postponing ingestion.");
+      this.isFlushing = false;
+      return;
+    }
+    const maxBatchSize = 50;
+    try {
+      while (this.ingestQueue.length > 0) {
+        const batch = this.ingestQueue.slice(0, maxBatchSize);
+        try {
+          await this.api.ingestBatch(batch);
+          this.ingestQueue.splice(0, batch.length);
+          this.retryCount = 0;
+        } catch (e) {
+          const status = e.status || 500;
+          const message = e.message || "Unknown network error";
+          if (this.onError) {
+            try {
+              this.onError({ status, message });
+            } catch (err) {
+              console.error("[Akropolys] Error inside onError callback:", err);
+            }
+          }
+          if (status >= 400 && status < 500 && status !== 429) {
+            console.error("[Akropolys] Ingestion discarded due to client error:", message);
+            this.ingestQueue.splice(0, batch.length);
+            continue;
+          } else {
+            console.warn("[Akropolys] Ingestion temporarily failed. Retrying later.", message);
+            this.scheduleFlushWithBackoff();
+            break;
+          }
+        }
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  scheduleFlushWithBackoff() {
+    if (this.ingestTimer) return;
+    const baseDelay = 1e3;
+    const jitter = Math.random() * 1e3;
+    const delay = Math.min(baseDelay * Math.pow(2, this.retryCount), 3e4) + jitter;
+    this.retryCount++;
+    this.ingestTimer = setTimeout(() => {
+      this.flushQueue();
+    }, delay);
+  }
+};
+_AkropolysClient.INGEST_CACHE_KEY = "akropolys_ingested_v2";
+_AkropolysClient.INGEST_CACHE_TTL = 24 * 60 * 60 * 1e3;
+var AkropolysClient = _AkropolysClient;
+var instance = null;
+function initAkropolys(config) {
+  instance = new AkropolysClient(config);
+  return instance;
+}
+function getAkropolysClient() {
+  if (!instance) {
+    const siteId = getEnvVar("NEXT_PUBLIC_AKROPOLYS_SITE_ID");
+    const apiUrl = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_URL");
+    const apiToken = getEnvVar("NEXT_PUBLIC_AKROPOLYS_API_TOKEN");
+    if (siteId && apiUrl && apiToken) {
+      instance = new AkropolysClient({ siteId, apiUrl, apiToken });
+    } else {
+      throw new Error("[Akropolys] Call initAkropolys() or set NEXT_PUBLIC_AKROPOLYS_* environment variables before using the client.");
+    }
+  }
+  return instance;
+}
+
+// src/Provider.tsx
+import { createContext, useContext, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var AkropolysContext = createContext(null);
+function AkropolysProvider({
+  siteId,
+  apiUrl,
+  apiToken,
+  shopperId,
+  vertical,
+  authLoading,
+  onCheckout,
+  onError,
+  children
+}) {
+  const clientRef = useRef(null);
+  if (!clientRef.current) {
+    clientRef.current = new AkropolysClient({
+      siteId,
+      apiUrl,
+      apiToken,
+      shopperId,
+      vertical,
+      authLoading,
+      onCheckout,
+      onError
+    });
+  } else {
+    clientRef.current.reRegister();
+  }
+  useEffect(() => {
+    clientRef.current?.setShopperId(shopperId);
+  }, [shopperId]);
+  useEffect(() => {
+    clientRef.current?.setAuthLoading(!!authLoading);
+  }, [authLoading]);
+  useEffect(() => {
+    if (clientRef.current) {
+      clientRef.current.onError = onError;
+      clientRef.current.onCheckout = onCheckout;
+    }
+  }, [onError, onCheckout]);
+  useEffect(() => {
+    clientRef.current?.reRegister();
+  }, []);
+  useEffect(() => {
+    return () => {
+      clientRef.current?.destroy();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(AkropolysContext.Provider, { value: clientRef.current, children });
+}
+function useAkropolysContext() {
+  const context = useContext(AkropolysContext);
+  if (!context) {
+    return getAkropolysClient();
+  }
+  return context;
+}
+
+// src/hooks/useAkropolys.ts
+import { useRef as useRef2 } from "react";
+function useAkropolys(config) {
+  const clientRef = useRef2(null);
+  if (!clientRef.current) {
+    console.warn("[Akropolys] useAkropolys() is deprecated. Please wrap your application in <AkropolysProvider> instead.");
+    clientRef.current = initAkropolys(config);
+  }
+  return clientRef.current;
+}
+
+// src/hooks/useSearch.ts
+import { useState, useCallback, useRef as useRef3 } from "react";
+function useSearch() {
+  const client = useAkropolysContext();
+  const [results, setResults] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const genRef = useRef3(0);
+  const search = useCallback(async (query, limit = 8) => {
+    if (!query.trim()) {
+      setResults([]);
+      setLoading(false);
+      return;
+    }
+    const gen = ++genRef.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await client.api.searchAutocomplete(query, limit);
+      if (gen === genRef.current) {
+        setResults(res.results ?? []);
+      }
+    } catch (e) {
+      if (gen === genRef.current) {
+        let msg = e?.message ?? "Search failed";
+        try {
+          const parsed = JSON.parse(msg);
+          if (parsed && parsed.error) {
+            msg = parsed.error;
+          }
+        } catch {
+        }
+        setError(msg);
+      }
+    } finally {
+      if (gen === genRef.current) setLoading(false);
+    }
+  }, [client]);
+  const clear = useCallback(() => {
+    genRef.current++;
+    setResults([]);
+    setError(null);
+    setLoading(false);
+  }, []);
+  return { results, loading, error, search, clear };
+}
+
+// src/hooks/useIngest.ts
+import { useCallback as useCallback2 } from "react";
+
+// src/utils/TTLCache.ts
+var TTLCache = class {
+  constructor(ttlMs = 24 * 60 * 60 * 1e3) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttl = ttlMs;
+  }
+  add(key) {
+    this.cache.set(key, Date.now());
+    this.evictExpired();
+  }
+  has(key) {
+    const timestamp = this.cache.get(key);
+    if (timestamp === void 0) return false;
+    if (Date.now() - timestamp > this.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  evictExpired() {
+    const now = Date.now();
+    for (const [key, timestamp] of this.cache.entries()) {
+      if (now - timestamp > this.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+
+// src/hooks/useIngest.ts
+var recentlyIngested = new TTLCache(24 * 60 * 60 * 1e3);
+function getProductKey(p) {
+  return p.id || p.productId || p.slug || p.url || p.name || p.title || p.productName || null;
+}
+function useIngest() {
+  const client = useAkropolysContext();
+  const ingest = useCallback2((product) => {
+    const key = getProductKey(product);
+    if (key) {
+      if (recentlyIngested.has(key)) return;
+      recentlyIngested.add(key);
+    }
+    client.queueIngest(product).catch(() => {
+    });
+  }, [client]);
+  const ingestBatch = useCallback2((products) => {
+    const toIngest = products.filter((p) => {
+      const key = getProductKey(p);
+      if (!key) return true;
+      if (recentlyIngested.has(key)) return false;
+      recentlyIngested.add(key);
+      return true;
+    });
+    if (!toIngest.length) return;
+    client.queueIngestBatch(toIngest).catch(() => {
+    });
+  }, [client]);
+  return { ingest, ingestBatch, loading: false, error: null };
+}
+
+// src/hooks/useListIngest.ts
+import { useEffect as useEffect2, useRef as useRef4 } from "react";
+function useListIngest(items) {
+  const { ingestBatch } = useIngest();
+  const processedIdsRef = useRef4(/* @__PURE__ */ new Set());
+  const listKey = (items || []).map((p) => p.id ?? p.productId ?? p.slug ?? p.url ?? p.name ?? "").join(",");
+  useEffect2(() => {
+    if (!items || !items.length) return;
+    const newItems = items.filter((item) => {
+      const id = item.id ?? item.productId ?? item.slug ?? item.url ?? item.name ?? "";
+      if (!id) return true;
+      if (processedIdsRef.current.has(id)) {
+        return false;
+      }
+      processedIdsRef.current.add(id);
+      return true;
+    });
+    if (newItems.length > 0) {
+      ingestBatch(newItems);
+    }
+  }, [listKey, ingestBatch]);
+}
+
+// src/hooks/usePageIngest.ts
+import { useEffect as useEffect3, useRef as useRef5 } from "react";
+function usePageIngest(product) {
+  const lastIngestedKey = useRef5(null);
+  const uniqueId = product ? product.id ?? product.productId ?? product.slug ?? product.url ?? "" : "";
+  useEffect3(() => {
+    if (!product || !uniqueId) return;
+    if (lastIngestedKey.current === uniqueId) return;
+    lastIngestedKey.current = uniqueId;
+    try {
+      getAkropolysClient().queueIngest(product);
+    } catch (err) {
+      if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production") {
+        console.warn("[Akropolys] Ingestion failed inside usePageIngest:", err);
+      }
+    }
+  }, [uniqueId]);
+}
+
+// src/hooks/useKiku.ts
+import { useState as useState2, useCallback as useCallback3, useRef as useRef6, useEffect as useEffect4 } from "react";
+function useKiku(options = {}) {
+  const client = useAkropolysContext();
+  const [messages, setMessages] = useState2(options.initialMessages ?? []);
+  const [sources, setSources] = useState2([]);
+  const [loading, setLoading] = useState2(false);
+  const [streaming, setStreaming] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [lastAction, setLastAction] = useState2(null);
+  const [lastIntent, setLastIntent] = useState2(null);
+  const activeStreamRef = useRef6(null);
+  const onTokenRef = useRef6(options.onToken);
+  const onMetaRef = useRef6(options.onMeta);
+  const onDoneRef = useRef6(options.onDone);
+  const onErrorRef = useRef6(options.onError);
+  useEffect4(() => {
+    onTokenRef.current = options.onToken;
+    onMetaRef.current = options.onMeta;
+    onDoneRef.current = options.onDone;
+    onErrorRef.current = options.onError;
+  }, [options.onToken, options.onMeta, options.onDone, options.onError]);
+  useEffect4(() => {
+    return () => {
+      activeStreamRef.current?.destroy();
+    };
+  }, []);
+  const send = useCallback3(async (query, displayQuery) => {
+    if (!query.trim() || loading) return;
+    activeStreamRef.current?.destroy();
+    const userMsg = { role: "user", content: displayQuery ?? query };
+    setMessages((prev) => [...prev, userMsg]);
+    setLoading(true);
+    setStreaming(false);
+    setError(null);
+    try {
+      const history = messages.map((m) => ({ role: m.role, content: m.content }));
+      const stream = client.chat(query, history);
+      activeStreamRef.current = stream;
+      let messageInitialized = false;
+      let lastMeta = null;
+      stream.on("meta", (meta) => {
+        lastMeta = meta;
+        setSources(meta.sources ?? []);
+        if (meta.intent) setLastIntent(meta.intent);
+        if (meta.action) setLastAction(meta.action);
+        onMetaRef.current?.(meta);
+      });
+      stream.on("token", (token) => {
+        if (!messageInitialized) {
+          setLoading(false);
+          setStreaming(true);
+          setMessages((prev) => [...prev, { role: "assistant", content: token }]);
+          messageInitialized = true;
+        } else {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = {
+                ...next[next.length - 1],
+                content: next[next.length - 1].content + token
+              };
+            }
+            return next;
+          });
+        }
+        onTokenRef.current?.(token);
+      });
+      stream.on("done", (fullMessage) => {
+        setLoading(false);
+        setStreaming(false);
+        const metaAction = lastMeta?.action;
+        const metaCheckout = lastMeta?.checkout;
+        const isCartAction = metaAction?.type === "add_to_cart" || metaAction?.type === "remove_from_cart" || metaAction?.type === "clear_cart" || metaAction?.type === "view_cart";
+        if (isCartAction || metaCheckout) {
+          setMessages((prev) => {
+            const next = [...prev];
+            if (next.length > 0 && next[next.length - 1].role === "assistant") {
+              next[next.length - 1] = {
+                ...next[next.length - 1],
+                cartSnapshot: metaCheckout,
+                actionType: metaAction?.type
+              };
+            }
+            return next;
+          });
+          window.dispatchEvent(new CustomEvent("akropolys:cart_updated", { detail: metaCheckout }));
+        }
+        if (metaAction?.type === "checkout") {
+          window.dispatchEvent(new CustomEvent("akropolys:trigger_checkout", { detail: metaCheckout }));
+        }
+        if (metaAction?.type === "awaiting_payment") {
+          window.dispatchEvent(new CustomEvent("akropolys:awaiting_payment", { detail: metaAction }));
+        }
+        if (metaCheckout && client.onCheckout) {
+          client.onCheckout(metaCheckout);
+        }
+        onDoneRef.current?.(fullMessage);
+      });
+      stream.on("error", (err) => {
+        setLoading(false);
+        setStreaming(false);
+        setError(err.message);
+        setMessages((prev) => prev.slice(0, -1));
+        onErrorRef.current?.(err);
+      });
+    } catch (err) {
+      setLoading(false);
+      setStreaming(false);
+      setError(err?.message ?? "Chat request failed");
+      setMessages((prev) => prev.slice(0, -1));
+      onErrorRef.current?.(err);
+    }
+  }, [client, messages, loading]);
+  const reset = useCallback3(() => {
+    activeStreamRef.current?.destroy();
+    setMessages([]);
+    setSources([]);
+    setStreaming(false);
+    setError(null);
+    setLoading(false);
+    setLastAction(null);
+    setLastIntent(null);
+  }, []);
+  return { messages, sources, loading, streaming, error, lastAction, lastIntent, send, reset };
+}
+
+// src/hooks/useCart.ts
+import { useState as useState3, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+function useCart() {
+  const client = useAkropolysContext();
+  const [cart, setCart] = useState3(null);
+  const [loading, setLoading] = useState3(false);
+  const shopperId = client.getShopperId();
+  const fetchCart = useCallback4(async () => {
+    if (!shopperId) return;
+    setLoading(true);
+    try {
+      const res = await client.api.getCart();
+      setCart(res);
+    } catch (e) {
+      console.error("[Akropolys] Failed to fetch cart", e);
+    } finally {
+      setLoading(false);
+    }
+  }, [client, shopperId]);
+  useEffect5(() => {
+    fetchCart();
+    const handleCartUpdate = (e) => {
+      if (e.detail) {
+        setCart(e.detail);
+      } else {
+        fetchCart();
+      }
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("akropolys:cart_updated", handleCartUpdate);
+      return () => window.removeEventListener("akropolys:cart_updated", handleCartUpdate);
+    }
+  }, [fetchCart, shopperId]);
+  return { cart, loading, fetchCart };
+}
+
+// src/hooks/usePaymentPolling.ts
+import { useState as useState4, useEffect as useEffect6, useRef as useRef7 } from "react";
+function usePaymentPolling({
+  client,
+  merchantReference,
+  onSuccess,
+  onFailure,
+  intervalMs = 3e3,
+  timeoutMs = 3e5
+  // 5 minutes default
+}) {
+  const [status, setStatus] = useState4("IDLE");
+  const [error, setError] = useState4(null);
+  const onSuccessRef = useRef7(onSuccess);
+  const onFailureRef = useRef7(onFailure);
+  useEffect6(() => {
+    onSuccessRef.current = onSuccess;
+    onFailureRef.current = onFailure;
+  }, [onSuccess, onFailure]);
+  useEffect6(() => {
+    if (!merchantReference) {
+      setStatus("IDLE");
+      setError(null);
+      return;
+    }
+    setStatus("PENDING");
+    setError(null);
+    const startTime = Date.now();
+    let timerId = null;
+    async function checkStatus() {
+      try {
+        if (Date.now() - startTime >= timeoutMs) {
+          setStatus("FAILED");
+          setError("Payment session timed out");
+          if (onFailureRef.current) onFailureRef.current("Payment session timed out");
+          return;
+        }
+        const res = await client.getPaymentStatus(merchantReference);
+        if (res.status === "COMPLETED") {
+          setStatus("COMPLETED");
+          if (onSuccessRef.current) onSuccessRef.current();
+        } else if (res.status === "FAILED") {
+          setStatus("FAILED");
+          setError("Payment failed");
+          if (onFailureRef.current) onFailureRef.current("Payment failed");
+        } else {
+          timerId = setTimeout(checkStatus, intervalMs);
+        }
+      } catch (err) {
+        console.error("[Akropolys Polling Error]", err);
+        timerId = setTimeout(checkStatus, intervalMs);
+      }
+    }
+    timerId = setTimeout(checkStatus, intervalMs);
+    return () => {
+      if (timerId) {
+        clearTimeout(timerId);
+      }
+    };
+  }, [client, merchantReference, intervalMs, timeoutMs]);
+  return { status, error };
+}
+
+export {
+  AkropolysAPI,
+  KikuStream,
+  setSDKDefaultVertical,
+  AkropolysClient,
+  initAkropolys,
+  getAkropolysClient,
+  AkropolysProvider,
+  useAkropolysContext,
+  useAkropolys,
+  useSearch,
+  useIngest,
+  useListIngest,
+  usePageIngest,
+  useKiku,
+  useCart,
+  usePaymentPolling
+};
+//# sourceMappingURL=chunk-UKF434HE.mjs.map