@opencx/widget 2.5.1 → 2.6.1

package/dist/api-DRZ9vPwy.js

@@ -0,0 +1,1360 @@
+var ne = Object.defineProperty;
+var Q = (s) => {
+  throw TypeError(s);
+};
+var ae = (s, e, t) => e in s ? ne(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var h = (s, e, t) => ae(s, typeof e != "symbol" ? e + "" : e, t), V = (s, e, t) => e.has(s) || Q("Cannot " + t);
+var A = (s, e, t) => (V(s, e, "read from private field"), t ? t.call(s) : e.get(s)), G = (s, e, t) => e.has(s) ? Q("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), k = (s, e, t, r) => (V(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t);
+import ie from "lodash.isequal";
+import { v4 as oe } from "uuid";
+class M extends Error {
+  constructor(e) {
+    super(e), this.name = "OpenCXError";
+  }
+}
+class _e extends M {
+  constructor(e = "Connection failed") {
+    super(e), this.name = "ConnectionError";
+  }
+}
+class Me extends M {
+  constructor(e = "Authentication failed") {
+    super(e), this.name = "AuthenticationError";
+  }
+}
+class le extends M {
+  constructor(e = "Session error occurred") {
+    super(e), this.name = "SessionError";
+  }
+}
+class Fe extends le {
+  constructor(e = "Session not defined") {
+    super(e), this.name = "SessionNotDefinedError";
+  }
+}
+class ke extends M {
+  constructor(e = "Transport error occurred") {
+    super(e), this.name = "TransportError";
+  }
+}
+class Ne extends M {
+  constructor(e = "File upload failed") {
+    super(e), this.name = "FileUploadError";
+  }
+}
+class ce extends M {
+  constructor(e = "Storage is not available") {
+    super(e), this.name = "StorageNotAvailableError";
+  }
+}
+class je extends M {
+  constructor(e = "External ID is not defined") {
+    super(e), this.name = "ExternalIdNotDefinedError";
+  }
+}
+var ue = /* @__PURE__ */ ((s) => (s.INIT = "init", s.STATE_CHANGE = "stateChange", s.BEFORE_UPDATE = "beforeUpdate", s.AFTER_UPDATE = "afterUpdate", s.DESTROY = "destroy", s.ERROR = "error", s))(ue || {}), C, N;
+class X {
+  constructor(e) {
+    h(this, "subscribers", /* @__PURE__ */ new Set());
+    G(this, C);
+    h(this, "initialState");
+    G(this, N);
+    h(this, "lifecycleListeners", /* @__PURE__ */ new Map());
+    h(this, "emitLifecycle", (e, t) => {
+      const r = this.lifecycleListeners.get(e);
+      if (r) {
+        const a = {
+          type: e,
+          timestamp: Date.now(),
+          data: t
+        };
+        r.forEach((o) => {
+          try {
+            o(a);
+          } catch {
+          }
+        });
+      }
+    });
+    h(this, "notifySubscribers", (e) => {
+      Array.from(this.subscribers).forEach((r) => {
+        try {
+          r(e);
+        } catch (a) {
+          this.emitLifecycle("error", { error: a });
+        }
+      });
+    });
+    /**
+     * Subscribe to state changes
+     * @param callback Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    h(this, "subscribe", (e) => (this.subscribers.add(e), () => {
+      this.subscribers.delete(e);
+    }));
+    h(this, "onLifecycle", (e, t) => {
+      this.lifecycleListeners.has(e) || this.lifecycleListeners.set(e, /* @__PURE__ */ new Set());
+      const r = this.lifecycleListeners.get(e);
+      return r.add(t), () => {
+        r.delete(t), r.size === 0 && this.lifecycleListeners.delete(e);
+      };
+    });
+    /**
+     * Get the current state
+     */
+    h(this, "getState", () => A(this, C));
+    /**
+     * Set the state and notify subscribers if the state changes
+     * @param newState The new state to set
+     */
+    h(this, "setState", (e) => {
+      this.emitLifecycle("beforeUpdate", {
+        previousState: A(this, C),
+        nextState: e
+      }), ie(A(this, C), e) || (k(this, C, e), k(this, N, Date.now()), this.emitLifecycle("stateChange", { state: e }), this.notifySubscribers(e)), this.emitLifecycle("afterUpdate", { state: e });
+    });
+    h(this, "setStatePartial", (e) => {
+      if (e == null) return;
+      const t = { ...A(this, C), ...e };
+      this.setState(t);
+    });
+    /**
+     * Clear all subscriptions
+     */
+    h(this, "clear", () => {
+      this.emitLifecycle(
+        "destroy"
+        /* DESTROY */
+      ), this.subscribers = /* @__PURE__ */ new Set(), this.lifecycleListeners = /* @__PURE__ */ new Map();
+    });
+    h(this, "reset", () => {
+      this.setState(this.initialState);
+    });
+    h(this, "lastUpdated", () => A(this, N));
+    k(this, C, e), this.initialState = e, k(this, N, Date.now()), this.emitLifecycle("init", { initialState: A(this, C) });
+  }
+}
+C = new WeakMap(), N = new WeakMap();
+function qe(s) {
+  return new X(s);
+}
+function L(s) {
+  if (!s) return !1;
+  try {
+    return typeof s.isAvailable == "function" ? s.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function Y(s, e) {
+  try {
+    return { success: !0, result: await s(), error: null };
+  } catch (t) {
+    return {
+      success: !1,
+      result: null,
+      error: {
+        message: t instanceof Error ? t.message || "Unknown error" : (t == null ? void 0 : t.toString()) || "Unknown error",
+        code: "STORAGE_OPERATION_FAILED",
+        context: e
+      }
+    };
+  }
+}
+function $e(s = {}) {
+  const {
+    level: e = "info",
+    prefix: t = "[openCx]",
+    enabled: r = !0
+  } = s;
+  let a = e;
+  const o = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  function c(i) {
+    return r && o[i] >= o[a];
+  }
+  function n(i) {
+    return `${t} ${i}`;
+  }
+  function m(i) {
+    return i.map((l) => {
+      if (l instanceof Error)
+        return {
+          name: l.name,
+          message: l.message,
+          stack: l.stack
+        };
+      if (typeof l == "object")
+        try {
+          return JSON.stringify(l, null, 2);
+        } catch {
+          return l;
+        }
+      return l;
+    });
+  }
+  return {
+    debug(i, ...l) {
+      c("debug") && console.debug(n(i), ...m(l));
+    },
+    info(i, ...l) {
+      c("info") && console.info(n(i), ...m(l));
+    },
+    warn(i, ...l) {
+      c("warn") && console.warn(n(i), ...m(l));
+    },
+    error(i, ...l) {
+      c("error") && console.error(n(i), ...m(l));
+    },
+    setLevel(i) {
+      a = i;
+    }
+  };
+}
+function fe(s) {
+  if (!s) return !1;
+  try {
+    return typeof s.isAvailable == "function" ? s.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function de(s, e) {
+  try {
+    return await s(), { success: !0, error: null };
+  } catch (t) {
+    return {
+      success: !1,
+      error: {
+        message: t instanceof Error ? t.message || "Unknown error" : (t == null ? void 0 : t.toString()) || "Unknown error",
+        code: "AUDIO_OPERATION_FAILED",
+        context: e
+      }
+    };
+  }
+}
+function B() {
+  return oe();
+}
+function ge({ config: s }, e) {
+  const t = new X({
+    contact: null,
+    loading: { isLoading: !1, reason: null },
+    error: { hasError: !1 }
+  });
+  function r() {
+    var c;
+    return !((c = t.getState().contact) != null && c.id) && s.getConfig().collectUserData ? {
+      should: !0,
+      reason: "No contact id and collectUserData is true"
+    } : {
+      should: !1
+    };
+  }
+  async function a() {
+    try {
+      t.setStatePartial({
+        loading: { isLoading: !0, reason: "cleaning_up" },
+        error: { hasError: !1 }
+      }), t.setState({
+        contact: null,
+        loading: { isLoading: !1, reason: null },
+        error: { hasError: !1 }
+      }), t.clear();
+    } catch (o) {
+      t.setStatePartial({
+        error: {
+          hasError: !0,
+          message: o instanceof Error ? o.message : "Failed to cleanup contact data",
+          code: "CONTACT_CLEANUP_FAILED"
+        }
+      });
+    } finally {
+      t.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  return {
+    contactState: t,
+    shouldCollectData: r,
+    cleanup: a
+  };
+}
+const J = {
+  SESSION: 1e4,
+  // every 10 seconds
+  MESSAGES: 5e3
+  // every 5 seconds
+};
+function me(s) {
+  const e = {
+    id: s.publicId,
+    timestamp: s.sentAt || "",
+    attachments: s.attachments || void 0
+  };
+  return s.sender.kind === "user" ? {
+    ...e,
+    type: "FROM_USER",
+    content: s.content.text || "",
+    deliveredAt: s.sentAt || ""
+  } : s.sender.kind === "agent" ? {
+    id: s.publicId,
+    type: "FROM_AGENT",
+    component: "agent_message",
+    data: {
+      message: s.content.text || ""
+    },
+    timestamp: s.sentAt || "",
+    attachments: s.attachments || void 0
+  } : {
+    ...e,
+    type: "FROM_BOT",
+    component: "bot_message",
+    agent: {
+      id: null,
+      name: s.sender.name || "",
+      isAi: s.sender.kind === "ai",
+      avatar: s.sender.avatar || null
+    },
+    data: {
+      message: s.content.text
+    }
+  };
+}
+function Se(s, e, t, r, a) {
+  async function o(i) {
+    var b;
+    const l = e.getState().messages, g = (b = e.getState().messages.at(-1)) == null ? void 0 : b.timestamp, { data: u } = await s.getSessionHistory(
+      i.id,
+      g
+    );
+    if (u && u.length > 0) {
+      const w = u.map(me).filter(
+        (D) => !l.some((S) => S.id === D.id)
+      );
+      w.length > 0 && (t == null || t.debug("Adding new messages to state", {
+        count: w.length,
+        messageIds: w.map((S) => S.id),
+        messageTypes: w.map((S) => S.type)
+      }), r != null && r.getConfig().settings.useSoundEffects && (a != null && a.audio) && fe(a.audio) && w.filter(
+        (P) => P.type === "FROM_BOT"
+      ).length > 0 && await de(
+        () => a.audio.playNotification(),
+        "Failed to play notification sound for new messages"
+      ), e.setStatePartial({
+        messages: [...l, ...w]
+      }));
+    }
+  }
+  function c(i, l) {
+    return {
+      id: B(),
+      type: "FROM_USER",
+      content: i,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attachments: l,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  function n(i) {
+    if (i.success && i.autopilotResponse)
+      return {
+        type: "FROM_BOT",
+        id: i.autopilotResponse.id || B(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: "bot_message",
+        data: {
+          message: i.autopilotResponse.value.content
+        }
+      };
+    if (i.success && i.uiResponse) {
+      const l = i.uiResponse.value;
+      return {
+        type: "FROM_BOT",
+        id: B(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: l.name,
+        data: l.request_response
+      };
+    }
+    return null;
+  }
+  function m(i) {
+    return {
+      type: "FROM_BOT",
+      id: B(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: "TEXT",
+      data: {
+        message: i,
+        variant: "error"
+      }
+    };
+  }
+  return {
+    fetchHistoryMessages: o,
+    toUserMessage: c,
+    toBotMessage: n,
+    addErrorMessage: m
+  };
+}
+function he(s, e, t, r, a, o) {
+  var v, p;
+  let c = null;
+  const n = (v = o.platform) == null ? void 0 : v.logger, m = (p = o.platform) == null ? void 0 : p.storage, i = () => a.getConfig().settings.persistSession;
+  if (i() && !L(m))
+    throw new ce();
+  i() && !a.getConfig().user.external_id && (n == null || n.error(
+    "session persistence is enabled but external id is not defined"
+  ));
+  const { token: l, user: g } = a.getConfig(), u = `${g.external_id ?? g.email ?? "unknown"}:${l}:session`;
+  async function b() {
+    n == null || n.debug("Restoring session from storage", {
+      sessionStorageKey: u,
+      stroageAvailable: L(m)
+    }), L(m) && Y(async () => {
+      n == null || n.debug("Attempting to restore session from storage");
+      const d = await m.getItem(u);
+      if (d) {
+        const f = JSON.parse(d);
+        n == null || n.info("Session restored from storage", {
+          sessionId: f.id
+        }), e.setState(f), await r.fetchHistoryMessages(f), D();
+      }
+    }, "Error restoring session from storage");
+  }
+  function w() {
+    n == null || n.debug("Setting up session persistence", {
+      sessionStorageKey: u,
+      stroageAvailable: L(m)
+    }), L(m) && e.subscribe(async (d) => {
+      try {
+        d ? (await m.setItem(u, JSON.stringify(d)), n == null || n.debug("Session persisted to storage", {
+          sessionId: d.id
+        })) : (await m.removeItem(u), n == null || n.debug("Session removed from storage"));
+      } catch (f) {
+        n == null || n.error("Error persisting session:", f), t.setStatePartial({
+          error: {
+            hasError: !0,
+            message: f instanceof Error ? f.message : "Failed to persist session",
+            code: "SESSION_PERSISTENCE_FAILED"
+          }
+        });
+      }
+    });
+  }
+  function D() {
+    if (c) return;
+    n == null || n.debug("Starting polling");
+    const d = [];
+    d.push(
+      setInterval(async () => {
+        const f = e.getState();
+        if (f != null && f.id)
+          try {
+            const E = /* @__PURE__ */ new Date();
+            t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                session: {
+                  isPolling: !0,
+                  lastPollTime: E.toISOString(),
+                  nextPollTime: new Date(
+                    E.getTime() + J.SESSION
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            });
+            const { data: q } = await s.getSession(f.id);
+            q && e.setState(q), t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                session: {
+                  ...t.getState().polling.session,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (E) {
+            n == null || n.error("Error polling session:", E), t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                session: {
+                  ...t.getState().polling.session,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: E instanceof Error ? E.message : "Failed to poll session",
+                    code: "SESSION_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, J.SESSION)
+    ), d.push(
+      setInterval(async () => {
+        const f = e.getState();
+        if (f != null && f.id)
+          try {
+            const E = /* @__PURE__ */ new Date();
+            t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                messages: {
+                  isPolling: !0,
+                  lastPollTime: E.toISOString(),
+                  nextPollTime: new Date(
+                    E.getTime() + J.MESSAGES
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            }), await r.fetchHistoryMessages(f), t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                messages: {
+                  ...t.getState().polling.messages,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (E) {
+            n == null || n.error("Error polling messages:", E), t.setStatePartial({
+              polling: {
+                ...t.getState().polling,
+                messages: {
+                  ...t.getState().polling.messages,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: E instanceof Error ? E.message : "Failed to poll messages",
+                    code: "MESSAGES_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, J.MESSAGES)
+    ), c = () => {
+      n == null || n.debug("Stopping polling"), d.forEach(clearInterval), t.setStatePartial({
+        polling: {
+          session: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          },
+          messages: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          }
+        }
+      });
+    };
+  }
+  async function S() {
+    n == null || n.info("Creating new session"), t.setStatePartial({
+      loading: { isLoading: !0, reason: "creating_session" },
+      error: { hasError: !1 }
+    });
+    const { data: d, error: f } = await s.createSession();
+    if (d)
+      return n == null || n.info("Session created successfully", { sessionId: d.id }), e.setState(d), t.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      }), D(), d;
+    n == null || n.error("Failed to create session:", f);
+    const E = {
+      hasError: !0,
+      message: f instanceof Error ? f.message : "Failed to create session",
+      code: "SESSION_CREATION_FAILED"
+    };
+    return t.setStatePartial({
+      error: E,
+      loading: { isLoading: !1, reason: null }
+    }), null;
+  }
+  async function P() {
+    var f;
+    const d = e.getState();
+    if (d != null && d.id)
+      try {
+        c && (c(), c = null), e.setState(null), i() && m && await m.removeItem(u), t.setState({
+          messages: [],
+          keyboard: null,
+          loading: { isLoading: !1, reason: null },
+          error: { hasError: !1 },
+          polling: {
+            session: {
+              isPolling: !1,
+              lastPollTime: null,
+              nextPollTime: null,
+              error: { hasError: !1 }
+            },
+            messages: {
+              isPolling: !1,
+              lastPollTime: null,
+              nextPollTime: null,
+              error: { hasError: !1 }
+            }
+          }
+        }), (f = o.onSessionDestroy) == null || f.call(o);
+      } catch (E) {
+        t.setStatePartial({
+          error: {
+            hasError: !0,
+            message: E instanceof Error ? E.message : "Failed to clear session",
+            code: "SESSION_CLEAR_FAILED"
+          }
+        });
+      }
+  }
+  function x(d = !1) {
+    try {
+      c && (c(), c = null), d && i() && L(m) && (console.log("removing session data", u), Y(
+        () => m.removeItem(u),
+        "Error removing session data"
+      )), t.setState({
+        messages: [],
+        keyboard: null,
+        loading: { isLoading: !1, reason: null },
+        error: { hasError: !1 },
+        polling: {
+          session: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          },
+          messages: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          }
+        }
+      }), e.setState(null), t.clear(), e.clear();
+    } catch (f) {
+      t.setStatePartial({
+        error: {
+          hasError: !0,
+          message: f instanceof Error ? f.message : "Failed to cleanup",
+          code: "SESSION_CLEAR_FAILED"
+        }
+      });
+    }
+  }
+  async function T(d) {
+    return s.getSession(d);
+  }
+  async function F() {
+    const d = e.getState();
+    if (!(d != null && d.id)) return;
+    const { data: f } = await T(d.id);
+    return f && e.setState(f), f;
+  }
+  return i() && L(m) && (n == null || n.debug("Initializing session persistence", {
+    sessionStorageKey: u,
+    stroageAvailable: L(m)
+  }), b(), w()), {
+    createSession: S,
+    clearSession: P,
+    cleanup: x,
+    startPolling: D,
+    fetchSession: T,
+    refetchSession: F,
+    sessionStorageKey: u
+  };
+}
+function ze(s) {
+  var b;
+  const e = (b = s.platform) == null ? void 0 : b.logger, t = {
+    messages: [],
+    keyboard: null,
+    loading: { isLoading: !1, reason: null },
+    error: { hasError: !1 },
+    polling: {
+      session: {
+        isPolling: !1,
+        lastPollTime: null,
+        nextPollTime: null,
+        error: { hasError: !1 }
+      },
+      messages: {
+        isPolling: !1,
+        lastPollTime: null,
+        nextPollTime: null,
+        error: { hasError: !1 }
+      }
+    }
+  }, r = new X(t), {
+    contactState: a,
+    cleanup: o,
+    shouldCollectData: c
+  } = ge(
+    { config: s.config, api: s.api },
+    s.platform
+  ), n = new X(null), m = Se(
+    s.api,
+    r,
+    e,
+    s.config,
+    s.platform
+  ), i = he(
+    s.api,
+    n,
+    r,
+    m,
+    s.config,
+    s
+  );
+  async function l(w, D) {
+    var x;
+    let S = n.getState(), P = !1;
+    if (!(S != null && S.id)) {
+      if (e == null || e.debug("No active session, creating new session"), S = await i.createSession(), !S)
+        return {
+          success: !1,
+          createdSession: P
+        };
+      P = !0;
+    }
+    S.assignee.kind === "ai" && (S = await i.refetchSession() ?? S);
+    try {
+      e == null || e.debug("Sending message", { sessionId: S.id }), S.assignee.kind === "ai" ? r.setStatePartial({
+        loading: { isLoading: !0, reason: "sending_message_to_bot" },
+        error: { hasError: !1 }
+      }) : r.setStatePartial({
+        loading: { isLoading: !0, reason: "sending_message_to_agent" },
+        error: { hasError: !1 }
+      });
+      const T = m.toUserMessage(
+        w.content,
+        w.attachments || void 0
+      ), F = r.getState().messages;
+      r.setStatePartial({
+        messages: [...F, T]
+      });
+      const v = s.config.getConfig(), { data: p } = await s.api.handleMessage(
+        {
+          uuid: T.id,
+          bot_token: v.token,
+          headers: v.headers,
+          query_params: v.queryParams,
+          session_id: S.id,
+          user: v.user,
+          ...w
+        },
+        D
+      );
+      if (p != null && p.success) {
+        e == null || e.debug("Message sent successfully");
+        const d = m.toBotMessage(p);
+        if (d) {
+          const f = r.getState().messages;
+          r.setStatePartial({
+            messages: [...f, d]
+          });
+        }
+        return {
+          success: !0,
+          createdSession: P,
+          botMessage: d
+        };
+      } else {
+        e == null || e.warn("Message send failed", p == null ? void 0 : p.error);
+        const d = m.addErrorMessage(
+          ((x = p == null ? void 0 : p.error) == null ? void 0 : x.message) || "Unknown error occurred"
+        ), f = r.getState().messages;
+        return r.setStatePartial({
+          messages: [...f, d]
+        }), {
+          success: !1,
+          createdSession: P,
+          error: p == null ? void 0 : p.error
+        };
+      }
+    } catch (T) {
+      return e == null || e.error("Error sending message:", T), r.setStatePartial({
+        error: {
+          hasError: !0,
+          message: T instanceof Error ? T.message : "Failed to send message",
+          code: "MESSAGE_SEND_FAILED"
+        }
+      }), {
+        success: !1,
+        createdSession: P,
+        error: T
+      };
+    } finally {
+      r.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  async function g() {
+    await i.clearSession(), await i.createSession();
+  }
+  const u = () => {
+    o(), i.cleanup();
+  };
+  return {
+    chatState: r,
+    sessionState: n,
+    sendMessage: l,
+    createSession: i.createSession,
+    clearSession: i.clearSession,
+    cleanup: u,
+    initialState: t,
+    sessionStorageKey: i.sessionStorageKey,
+    recreateSession: g,
+    contactState: a,
+    shouldCollectData: c
+  };
+}
+const pe = {
+  messageArrived: "https://cloud.opencopilot.so/sfx/notification3.mp3"
+}, Ee = {
+  primaryColor: "hsl(211,65%,59%)",
+  triggerOffset: "20px"
+}, te = {
+  persistSession: !1,
+  useSoundEffects: !1
+}, ye = 1e3 * 3;
+function be(s, e, t) {
+  const r = e.logger, a = e.storage;
+  let o = s ?? te;
+  async function c() {
+    if (!(!a || !L(a)))
+      try {
+        r == null || r.debug("Attempting to restore settings from storage");
+        const l = await a.getItem(t);
+        l && (o = JSON.parse(l), r == null || r.debug("Settings restored from storage", o));
+      } catch (l) {
+        r == null || r.error("Error restoring settings:", l);
+      }
+  }
+  async function n(l) {
+    if (!(!a || !L(a)))
+      try {
+        await a.setItem(t, JSON.stringify(l)), r == null || r.debug("Settings persisted to storage", l);
+      } catch (g) {
+        r == null || r.error("Error persisting settings:", g);
+      }
+  }
+  function m(l) {
+    o = {
+      ...o,
+      ...l
+    }, n(o);
+  }
+  function i() {
+    return o;
+  }
+  return c(), {
+    getSettings: i,
+    updateSettings: m
+  };
+}
+function He(s, e) {
+  var c, n, m, i, l;
+  if (!s.token)
+    throw new Error("Token is required");
+  if (s.pollingInterval && s.pollingInterval < ye)
+    throw new Error("Polling interval must be at least 3 seconds");
+  const t = {
+    ...s,
+    collectUserData: s.collectUserData ?? !1,
+    initialMessages: s.initialMessages ?? [],
+    apiUrl: s.apiUrl ?? "https://api.open.cx",
+    pollingInterval: s.pollingInterval ?? 3e3,
+    headers: s.headers ?? {},
+    queryParams: s.queryParams ?? {},
+    pathParams: s.pathParams ?? {},
+    bot: {
+      name: ((c = s.bot) == null ? void 0 : c.name) ?? "Bot",
+      avatar: ((n = s.bot) == null ? void 0 : n.avatar) ?? null,
+      id: ((m = s.bot) == null ? void 0 : m.id) ?? null,
+      isAi: ((i = s.bot) == null ? void 0 : i.isAi) ?? !0
+    },
+    contactToken: s.contactToken,
+    debug: s.debug ?? !1,
+    language: s.language ?? "en",
+    user: s.user ?? {},
+    soundEffectFiles: Object.assign({}, pe, s.soundEffectFiles),
+    theme: Object.assign({}, Ee, s.theme),
+    settings: Object.assign({}, te, s.settings),
+    assets: {
+      organizationLogo: ((l = s.assets) == null ? void 0 : l.organizationLogo) ?? ""
+    }
+  }, r = `${t.token}:settings`, { getSettings: a, updateSettings: o } = be(t.settings, e, r);
+  return {
+    config: t,
+    updateSettings: o,
+    getConfig: () => ({
+      ...t,
+      settings: a()
+    }),
+    getApiConfig: () => ({
+      apiUrl: t.apiUrl,
+      token: t.token,
+      headers: t.headers,
+      queryParams: t.queryParams,
+      pathParams: t.pathParams
+    }),
+    getBotConfig: () => t.bot,
+    getThemeConfig: () => t.theme,
+    getSoundEffects: () => t.soundEffectFiles,
+    getUser: () => t.user,
+    getLanguage: () => t.language,
+    getDebugMode: () => t.debug
+  };
+}
+const we = /\{[^{}]+\}/g, Pe = () => {
+  var s, e;
+  return typeof process == "object" && Number.parseInt((e = (s = process == null ? void 0 : process.versions) == null ? void 0 : s.node) == null ? void 0 : e.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function Te() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function Ae(s) {
+  let {
+    baseUrl: e = "",
+    Request: t = globalThis.Request,
+    fetch: r = globalThis.fetch,
+    querySerializer: a,
+    bodySerializer: o,
+    headers: c,
+    requestInitExt: n = void 0,
+    ...m
+  } = { ...s };
+  n = Pe() ? n : void 0, e = ee(e);
+  const i = [];
+  async function l(g, u) {
+    const {
+      baseUrl: b,
+      fetch: w = r,
+      Request: D = t,
+      headers: S,
+      params: P = {},
+      parseAs: x = "json",
+      querySerializer: T,
+      bodySerializer: F = o ?? Oe,
+      body: v,
+      ...p
+    } = u || {};
+    b && (e = ee(b));
+    let d = typeof a == "function" ? a : Z(a);
+    T && (d = typeof T == "function" ? T : Z({
+      ...typeof a == "object" ? a : {},
+      ...T
+    }));
+    const f = v === void 0 ? void 0 : F(v), E = (
+      // with no body, we should not to set Content-Type
+      f === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      f instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      }
+    ), q = {
+      redirect: "follow",
+      ...m,
+      ...p,
+      body: f,
+      headers: ve(E, c, S, P.header)
+    };
+    let $, z, U = new t(Re(g, { baseUrl: e, params: P, querySerializer: d }), q);
+    for (const I in p)
+      I in U || (U[I] = p[I]);
+    if (i.length) {
+      $ = Te(), z = Object.freeze({
+        baseUrl: e,
+        fetch: w,
+        parseAs: x,
+        querySerializer: d,
+        bodySerializer: F
+      });
+      for (const I of i)
+        if (I && typeof I == "object" && typeof I.onRequest == "function") {
+          const O = await I.onRequest({
+            request: U,
+            schemaPath: g,
+            params: P,
+            options: z,
+            id: $
+          });
+          if (O) {
+            if (!(O instanceof t))
+              throw new Error("onRequest: must return new Request() when modifying the request");
+            U = O;
+          }
+        }
+    }
+    let y;
+    try {
+      y = await w(U, n);
+    } catch (I) {
+      let O = I;
+      if (i.length)
+        for (let _ = i.length - 1; _ >= 0; _--) {
+          const H = i[_];
+          if (H && typeof H == "object" && typeof H.onError == "function") {
+            const j = await H.onError({
+              request: U,
+              error: O,
+              schemaPath: g,
+              params: P,
+              options: z,
+              id: $
+            });
+            if (j) {
+              if (j instanceof Response) {
+                O = void 0, y = j;
+                break;
+              }
+              if (j instanceof Error) {
+                O = j;
+                continue;
+              }
+              throw new Error("onError: must return new Response() or instance of Error");
+            }
+          }
+        }
+      if (O)
+        throw O;
+    }
+    if (i.length)
+      for (let I = i.length - 1; I >= 0; I--) {
+        const O = i[I];
+        if (O && typeof O == "object" && typeof O.onResponse == "function") {
+          const _ = await O.onResponse({
+            request: U,
+            response: y,
+            schemaPath: g,
+            params: P,
+            options: z,
+            id: $
+          });
+          if (_) {
+            if (!(_ instanceof Response))
+              throw new Error("onResponse: must return new Response() when modifying the response");
+            y = _;
+          }
+        }
+      }
+    if (y.status === 204 || y.headers.get("Content-Length") === "0")
+      return y.ok ? { data: void 0, response: y } : { error: void 0, response: y };
+    if (y.ok)
+      return x === "stream" ? { data: y.body, response: y } : { data: await y[x](), response: y };
+    let K = await y.text();
+    try {
+      K = JSON.parse(K);
+    } catch {
+    }
+    return { error: K, response: y };
+  }
+  return {
+    request(g, u, b) {
+      return l(u, { ...b, method: g.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(g, u) {
+      return l(g, { ...u, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(g, u) {
+      return l(g, { ...u, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(g, u) {
+      return l(g, { ...u, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(g, u) {
+      return l(g, { ...u, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(g, u) {
+      return l(g, { ...u, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(g, u) {
+      return l(g, { ...u, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(g, u) {
+      return l(g, { ...u, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(g, u) {
+      return l(g, { ...u, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...g) {
+      for (const u of g)
+        if (u) {
+          if (typeof u != "object" || !("onRequest" in u || "onResponse" in u || "onError" in u))
+            throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+          i.push(u);
+        }
+    },
+    /** Unregister middleware */
+    eject(...g) {
+      for (const u of g) {
+        const b = i.indexOf(u);
+        b !== -1 && i.splice(b, 1);
+      }
+    }
+  };
+}
+function W(s, e, t) {
+  if (e == null)
+    return "";
+  if (typeof e == "object")
+    throw new Error(
+      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
+    );
+  return `${s}=${(t == null ? void 0 : t.allowReserved) === !0 ? e : encodeURIComponent(e)}`;
+}
+function se(s, e, t) {
+  if (!e || typeof e != "object")
+    return "";
+  const r = [], a = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[t.style] || "&";
+  if (t.style !== "deepObject" && t.explode === !1) {
+    for (const n in e)
+      r.push(n, t.allowReserved === !0 ? e[n] : encodeURIComponent(e[n]));
+    const c = r.join(",");
+    switch (t.style) {
+      case "form":
+        return `${s}=${c}`;
+      case "label":
+        return `.${c}`;
+      case "matrix":
+        return `;${s}=${c}`;
+      default:
+        return c;
+    }
+  }
+  for (const c in e) {
+    const n = t.style === "deepObject" ? `${s}[${c}]` : c;
+    r.push(W(n, e[c], t));
+  }
+  const o = r.join(a);
+  return t.style === "label" || t.style === "matrix" ? `${a}${o}` : o;
+}
+function re(s, e, t) {
+  if (!Array.isArray(e))
+    return "";
+  if (t.explode === !1) {
+    const o = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[t.style] || ",", c = (t.allowReserved === !0 ? e : e.map((n) => encodeURIComponent(n))).join(o);
+    switch (t.style) {
+      case "simple":
+        return c;
+      case "label":
+        return `.${c}`;
+      case "matrix":
+        return `;${s}=${c}`;
+      default:
+        return `${s}=${c}`;
+    }
+  }
+  const r = { simple: ",", label: ".", matrix: ";" }[t.style] || "&", a = [];
+  for (const o of e)
+    t.style === "simple" || t.style === "label" ? a.push(t.allowReserved === !0 ? o : encodeURIComponent(o)) : a.push(W(s, o, t));
+  return t.style === "label" || t.style === "matrix" ? `${r}${a.join(r)}` : a.join(r);
+}
+function Z(s) {
+  return function(t) {
+    const r = [];
+    if (t && typeof t == "object")
+      for (const a in t) {
+        const o = t[a];
+        if (o != null) {
+          if (Array.isArray(o)) {
+            if (o.length === 0)
+              continue;
+            r.push(
+              re(a, o, {
+                style: "form",
+                explode: !0,
+                ...s == null ? void 0 : s.array,
+                allowReserved: (s == null ? void 0 : s.allowReserved) || !1
+              })
+            );
+            continue;
+          }
+          if (typeof o == "object") {
+            r.push(
+              se(a, o, {
+                style: "deepObject",
+                explode: !0,
+                ...s == null ? void 0 : s.object,
+                allowReserved: (s == null ? void 0 : s.allowReserved) || !1
+              })
+            );
+            continue;
+          }
+          r.push(W(a, o, s));
+        }
+      }
+    return r.join("&");
+  };
+}
+function Ie(s, e) {
+  let t = s;
+  for (const r of s.match(we) ?? []) {
+    let a = r.substring(1, r.length - 1), o = !1, c = "simple";
+    if (a.endsWith("*") && (o = !0, a = a.substring(0, a.length - 1)), a.startsWith(".") ? (c = "label", a = a.substring(1)) : a.startsWith(";") && (c = "matrix", a = a.substring(1)), !e || e[a] === void 0 || e[a] === null)
+      continue;
+    const n = e[a];
+    if (Array.isArray(n)) {
+      t = t.replace(r, re(a, n, { style: c, explode: o }));
+      continue;
+    }
+    if (typeof n == "object") {
+      t = t.replace(r, se(a, n, { style: c, explode: o }));
+      continue;
+    }
+    if (c === "matrix") {
+      t = t.replace(r, `;${W(a, n)}`);
+      continue;
+    }
+    t = t.replace(r, c === "label" ? `.${encodeURIComponent(n)}` : encodeURIComponent(n));
+  }
+  return t;
+}
+function Oe(s) {
+  return s instanceof FormData ? s : JSON.stringify(s);
+}
+function Re(s, e) {
+  var a;
+  let t = `${e.baseUrl}${s}`;
+  (a = e.params) != null && a.path && (t = Ie(t, e.params.path));
+  let r = e.querySerializer(e.params.query ?? {});
+  return r.startsWith("?") && (r = r.substring(1)), r && (t += `?${r}`), t;
+}
+function ve(...s) {
+  const e = new Headers();
+  for (const t of s) {
+    if (!t || typeof t != "object")
+      continue;
+    const r = t instanceof Headers ? t.entries() : Object.entries(t);
+    for (const [a, o] of r)
+      if (o === null)
+        e.delete(a);
+      else if (Array.isArray(o))
+        for (const c of o)
+          e.append(a, c);
+      else o !== void 0 && e.set(a, o);
+  }
+  return e;
+}
+function ee(s) {
+  return s.endsWith("/") ? s.substring(0, s.length - 1) : s;
+}
+const Le = (s) => {
+  console.log(s.error);
+}, Ce = (s) => {
+  const e = Ae({
+    baseUrl: s.baseUrl
+  }), t = {
+    onRequest: s.onRequest,
+    onResponse: s.onResponse,
+    onError: s.onError || Le
+  };
+  return e.use(t), e;
+};
+var R;
+class Ge {
+  constructor(e) {
+    G(this, R);
+    h(this, "me", async () => await A(this, R).GET("/backend/widget/v2/me"));
+    h(this, "widgetPrelude", async () => await A(this, R).GET("/backend/widget/v2/prelude", {
+      params: { header: { "X-Bot-Token": this.options.config.token } }
+    }));
+    h(this, "handleMessage", async (e, t) => await A(this, R).POST("/backend/widget/v2/chat/send", {
+      body: e,
+      signal: t
+    }));
+    h(this, "getSessionHistory", async (e, t) => {
+      const r = t ? { lastMessageTimestamp: t } : void 0;
+      return await A(this, R).GET(
+        "/backend/widget/v2/session/history/{sessionId}",
+        { params: { path: { sessionId: e }, query: r } }
+      );
+    });
+    h(this, "createSession", async () => await A(this, R).POST("/backend/widget/v2/create-session"));
+    h(this, "getSession", async (e) => await A(this, R).GET("/backend/widget/v2/session/{sessionId}", {
+      params: { path: { sessionId: e } }
+    }));
+    h(this, "uploadFile", async ({
+      file: e,
+      abortSignal: t
+    }) => {
+      const r = new FormData();
+      return r.append("file", e.file), await A(this, R).POST("/backend/widget/v2/upload", {
+        params: { query: { fileId: e.id, sessionId: "" } },
+        body: r,
+        signal: t,
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    });
+    h(this, "vote", async (e) => await A(this, R).POST("/backend/widget/v2/chat/vote", { body: e }));
+    this.options = e;
+    const t = this.options.config.user, r = {
+      claim: "",
+      value: ""
+    };
+    t != null && t.email ? (r.claim = "email", r.value = t.email) : t != null && t.phone && (r.claim = "phone", r.value = t.phone), k(this, R, Ce({
+      baseUrl: this.options.config.apiUrl,
+      onRequest: ({ request: a }) => {
+        a.headers.set("X-Bot-Token", this.options.config.token), a.headers.set(
+          "X-Consumer-Id",
+          `${r.claim}:${r.value}`
+        ), a.headers.set("Content-Type", "application/json"), a.headers.set("Accept", "application/json"), this.options.config.contactToken && a.headers.set(
+          "Authorization",
+          `Bearer ${this.options.config.contactToken}`
+        );
+      }
+    }));
+  }
+}
+R = new WeakMap();
+export {
+  Ge as A,
+  _e as C,
+  je as E,
+  Ne as F,
+  ue as L,
+  M as O,
+  X as P,
+  le as S,
+  ke as T,
+  ge as a,
+  He as b,
+  ze as c,
+  $e as d,
+  Me as e,
+  Fe as f,
+  ce as g,
+  qe as h,
+  L as i,
+  fe as j,
+  de as k,
+  Y as s
+};
+//# sourceMappingURL=api-DRZ9vPwy.js.map