@opencx/widget 3.0.89 → 3.0.91

package/dist/widget.ctx-uAWzif3-.js

@@ -0,0 +1,688 @@
+import M from "openapi-fetch";
+import O from "lodash.isequal";
+import { v4 as E } from "uuid";
+const F = (g) => {
+  console.log(g.error);
+}, _ = (g) => {
+  const a = M({
+    baseUrl: g.baseUrl
+  }), o = {
+    onRequest: g.onRequest,
+    onResponse: g.onResponse,
+    onError: g.onError || F
+  };
+  return a.use(o), a;
+};
+class T {
+  constructor({ config: a }) {
+    var n, e;
+    this.userToken = null, this.constructClientOptions = (t) => {
+      const s = this.config.apiUrl || "https://api.open.cx", i = {
+        "X-Bot-Token": this.config.token,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: t ? `Bearer ${t}` : void 0
+      };
+      return { baseUrl: s, headers: i };
+    }, this.createOpenAPIClient = ({
+      baseUrl: t,
+      headers: s
+    }) => _({
+      baseUrl: t,
+      onRequest: ({ request: i }) => {
+        Object.entries(s).forEach(([c, r]) => {
+          r && i.headers.set(c, r);
+        });
+      }
+    }), this.setAuthToken = (t) => {
+      this.userToken = t;
+      const { baseUrl: s, headers: i } = this.constructClientOptions(t);
+      this.client = this.createOpenAPIClient({ baseUrl: s, headers: i });
+    }, this.getExternalWidgetConfig = async () => await this.client.GET("/backend/widget/v2/config", {
+      params: { header: { "X-Bot-Token": this.config.token } }
+    }), this.widgetPrelude = async () => await this.client.GET("/backend/widget/v2/prelude", {
+      params: { header: { "X-Bot-Token": this.config.token } }
+    }), this.sendMessage = async (t, s) => await this.client.POST("/backend/widget/v2/chat/send", {
+      body: t,
+      signal: s
+    }), this.createUnverifiedContact = async (t) => await this.client.POST(
+      "/backend/widget/v2/contact/create-unverified",
+      {
+        params: { header: { "x-bot-token": this.config.token } },
+        body: t
+      }
+    ), this.createSession = async (t) => await this.client.POST("/backend/widget/v2/create-session", {
+      body: t
+    }), this.pollSessionAndHistory = async ({
+      sessionId: t,
+      lastMessageTimestamp: s,
+      abortSignal: i
+    }) => {
+      const c = s ? { lastMessageTimestamp: s } : void 0;
+      return await this.client.GET("/backend/widget/v2/poll/{sessionId}", {
+        params: { path: { sessionId: t }, query: c },
+        signal: i
+      });
+    }, this.getSessions = async ({
+      cursor: t,
+      filters: s,
+      abortSignal: i
+    }) => await this.client.GET("/backend/widget/v2/sessions", {
+      params: { query: { cursor: t, filters: JSON.stringify(s) } },
+      signal: i
+    }), this.uploadFile = async ({
+      file: t,
+      abortSignal: s,
+      onProgress: i
+    }) => new Promise((c, r) => {
+      var v;
+      const d = new FormData();
+      d.append("file", t);
+      const l = new XMLHttpRequest();
+      if (s && (s.addEventListener("abort", () => {
+        l.abort(), r(new DOMException("Aborted", "AbortError"));
+      }), s.aborted)) {
+        r(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      l.upload.addEventListener("progress", (u) => {
+        if (u.lengthComputable && i) {
+          const S = Math.round(u.loaded / u.total * 100);
+          i(S);
+        }
+      }), l.addEventListener("load", () => {
+        if (l.status >= 200 && l.status < 300)
+          try {
+            const u = JSON.parse(l.responseText);
+            c(u);
+          } catch (u) {
+            r(new Error(`Failed to parse response: ${u}`));
+          }
+        else
+          r(new Error(`Upload failed with status: ${l.status}`));
+      }), l.addEventListener("error", () => {
+        r(new Error("Network error occurred"));
+      }), l.addEventListener("timeout", () => {
+        r(new Error("Upload timed out"));
+      });
+      const { baseUrl: C } = this.constructClientOptions(this.userToken), p = `${C}/backend/widget/v2/upload`;
+      l.open("POST", p), l.setRequestHeader("X-Bot-Token", this.config.token), this.userToken ?? ((v = this.config.user) == null ? void 0 : v.token) ? l.setRequestHeader("Authorization", `Bearer ${this.userToken}`) : console.error("User token not set"), l.send(d);
+    }), this.vote = async (t) => await this.client.POST("/backend/widget/v2/chat/vote", { body: t }), this.resolveSession = async (t, s) => await this.client.POST("/backend/widget/v2/session/resolve", {
+      body: t,
+      signal: s
+    }), this.createStateCheckpoint = async (t) => await this.client.POST("/backend/widget/v2/checkpoint", {
+      body: t
+    }), this.config = a, this.userToken = ((n = a.user) == null ? void 0 : n.token) || null;
+    const { baseUrl: o, headers: h } = this.constructClientOptions(
+      (e = a.user) == null ? void 0 : e.token
+    );
+    this.client = this.createOpenAPIClient({ baseUrl: o, headers: h });
+  }
+}
+class P {
+  constructor(a) {
+    this.subscribers = /* @__PURE__ */ new Set(), this.get = () => this.state, this.set = (o) => {
+      O(this.state, o) || (this.state = o, this.notifySubscribers(o));
+    }, this.setPartial = (o) => {
+      if (o == null) return;
+      const h = { ...this.state, ...o };
+      this.set(h);
+    }, this.reset = () => {
+      this.set(this.initialState);
+    }, this.notifySubscribers = (o) => {
+      Array.from(this.subscribers).forEach((n) => {
+        try {
+          n(o);
+        } catch (e) {
+          console.error(e);
+        }
+      });
+    }, this.subscribe = (o) => (this.subscribers.add(o), () => {
+      this.subscribers.delete(o);
+    }), this.state = a, this.initialState = a;
+  }
+}
+class R {
+  constructor() {
+    this.state = new P({
+      isPolling: !1,
+      isError: !1
+    }), this.abortController = new AbortController(), this.reset = () => {
+      var a;
+      this.abortController.abort("Resetting poller"), (a = this.stopPolling) == null || a.call(this), this.stopPolling = null;
+    }, this.stopPolling = null, this.startPolling = (a, o) => {
+      if (this.stopPolling) return;
+      const h = [], n = async () => {
+        this.abortController = new AbortController(), this.state.setPartial({ isPolling: !0 });
+        try {
+          await a(this.abortController.signal);
+        } catch (e) {
+          if (this.abortController.signal.aborted)
+            return;
+          console.error("Failed to poll:", e), this.state.setPartial({ isError: !0 });
+        } finally {
+          this.state.setPartial({ isPolling: !1 });
+        }
+        this.abortController.signal.aborted ? console.log("Poller aborted, not scheduling anymore") : h.push(setTimeout(n, o));
+      };
+      n(), this.stopPolling = () => {
+        h.forEach(clearTimeout), this.state.reset();
+      };
+    };
+  }
+}
+function D(g) {
+  try {
+    const a = g();
+    return a instanceof Promise ? a.then((o) => ({ data: o })).catch((o) => ({ error: o })) : { data: a };
+  } catch (a) {
+    return { error: a };
+  }
+}
+class L {
+  constructor({
+    api: a,
+    config: o,
+    sessionCtx: h,
+    messageCtx: n,
+    sessionPollingIntervalSeconds: e
+  }) {
+    this.poller = new R(), this.registerPolling = () => {
+      this.sessionCtx.sessionState.subscribe(({ session: t }) => {
+        t != null && t.id ? this.poller.startPolling(async (s) => {
+          this.hackAndSlash(t.id, s);
+        }, this.sessionPollingIntervalSeconds * 1e3) : this.poller.reset();
+      });
+    }, this.hackAndSlash = async (t, s) => {
+      var d;
+      this.messageCtx.state.get().messages.length === 0 && this.messageCtx.state.setPartial({ isInitialFetchLoading: !0 });
+      const i = this.messageCtx.state.get().messages, c = i.length > 0 ? (d = i[i.length - 1]) == null ? void 0 : d.timestamp : void 0, { data: r } = await this.api.pollSessionAndHistory({
+        sessionId: t,
+        abortSignal: s,
+        lastMessageTimestamp: c
+      });
+      if (r != null && r.session && (this.sessionCtx.sessionState.setPartial({ session: r.session }), this.sessionCtx.setSessions([r.session])), r != null && r.history && r.history.length > 0) {
+        const l = this.messageCtx.state.get().messages, C = r.history.map(this.mapHistoryToMessage).filter(
+          (x) => !l.some((p) => p.id === x.id)
+        );
+        this.messageCtx.state.setPartial({
+          messages: [...l, ...C]
+        });
+      }
+      this.messageCtx.state.get().isInitialFetchLoading && this.messageCtx.state.setPartial({ isInitialFetchLoading: !1 });
+    }, this.mapHistoryToMessage = (t) => {
+      var c, r;
+      const s = {
+        id: t.publicId,
+        timestamp: t.sentAt || "",
+        attachments: t.attachments || void 0
+      };
+      if (t.sender.kind === "user")
+        return {
+          ...s,
+          type: "FROM_USER",
+          content: t.content.text || "",
+          deliveredAt: t.sentAt || ""
+        };
+      if (t.sender.kind === "agent")
+        return {
+          ...s,
+          type: "FROM_AGENT",
+          component: "agent_message",
+          data: {
+            message: t.content.text || ""
+          },
+          agent: {
+            name: t.sender.name || "",
+            avatar: t.sender.avatar || "",
+            id: null,
+            isAi: !1
+          }
+        };
+      const i = t.actionCalls && t.actionCalls.length > 0 ? t.actionCalls[t.actionCalls.length - 1] : void 0;
+      return {
+        ...s,
+        type: "FROM_BOT",
+        component: "bot_message",
+        agent: {
+          id: null,
+          name: ((c = this.config.bot) == null ? void 0 : c.name) || "",
+          isAi: !0,
+          avatar: ((r = this.config.bot) == null ? void 0 : r.avatar) || ""
+        },
+        data: {
+          message: t.content.text || "",
+          action: i ? {
+            name: i.actionName,
+            data: this.extractActionResult(i)
+          } : void 0
+        }
+      };
+    }, this.extractActionResult = (t) => {
+      const s = t.result;
+      if (s === null || typeof s != "object") return s;
+      if ("responseBodyText" in s && typeof s.responseBodyText == "string") {
+        const i = s.responseBodyText, c = D(() => JSON.parse(i)).data;
+        if (c) return c;
+      }
+      return t.result;
+    }, this.api = a, this.config = o, this.sessionCtx = h, this.messageCtx = n, this.sessionPollingIntervalSeconds = e, this.registerPolling();
+  }
+}
+class B {
+  constructor({
+    config: a,
+    api: o,
+    storageCtx: h
+  }) {
+    var n;
+    this.shouldCollectData = () => {
+      var e;
+      return !!(!((e = this.state.get().contact) != null && e.token) && this.config.collectUserData);
+    }, this.autoCreateUnverifiedUserIfNotExists = async () => {
+      var e, t, s, i, c, r, d, l, C, x, p, w, v, u;
+      if (!((e = this.config.user) != null && e.token)) {
+        if (this.config.collectUserData && !((s = (t = this.config.user) == null ? void 0 : t.data) != null && s.email)) {
+          if ((i = this.config.extraDataCollectionFields) != null && i.length)
+            return;
+          const S = await ((c = this.storageCtx) == null ? void 0 : c.getContactToken());
+          S && await this.setUnverifiedContact(S);
+          return;
+        }
+        if (!((d = (r = this.config.user) == null ? void 0 : r.data) != null && d.email)) {
+          const S = await ((l = this.storageCtx) == null ? void 0 : l.getContactToken());
+          if (S) {
+            await this.setUnverifiedContact(S);
+            return;
+          }
+        }
+        await this.createUnverifiedContact({
+          email: (x = (C = this.config.user) == null ? void 0 : C.data) == null ? void 0 : x.email,
+          non_verified_name: ((w = (p = this.config.user) == null ? void 0 : p.data) == null ? void 0 : w.name) || "Anonymous",
+          non_verified_custom_data: (u = (v = this.config.user) == null ? void 0 : v.data) == null ? void 0 : u.customData
+        });
+      }
+    }, this.createUnverifiedContact = async (e, t) => {
+      this.state.setPartial({ extraCollectedData: t });
+      try {
+        this.state.setPartial({
+          isCreatingUnverifiedContact: !0,
+          isErrorCreatingUnverifiedContact: !1
+        });
+        const { data: s } = await this.api.createUnverifiedContact(e);
+        s != null && s.token ? await this.setUnverifiedContact(s.token) : this.state.setPartial({ isErrorCreatingUnverifiedContact: !0 });
+      } finally {
+        this.state.setPartial({ isCreatingUnverifiedContact: !1 });
+      }
+    }, this.setUnverifiedContact = async (e) => {
+      var i, c, r, d;
+      const t = await ((i = this.storageCtx) == null ? void 0 : i.getExternalContactId()), s = ((c = this.config.user) == null ? void 0 : c.externalId) || t || E();
+      this.api.setAuthToken(e), await ((r = this.storageCtx) == null ? void 0 : r.setContactToken(e)), await ((d = this.storageCtx) == null ? void 0 : d.setExternalContactId(s)), this.state.setPartial({ contact: { token: e, externalId: s } });
+    }, this.config = a, this.storageCtx = h, this.api = o, this.state = new P({
+      contact: (n = a.user) != null && n.token ? {
+        token: a.user.token,
+        // Set optional externalId from config... not local storage
+        externalId: a.user.externalId
+      } : null,
+      extraCollectedData: void 0,
+      isCreatingUnverifiedContact: !1,
+      isErrorCreatingUnverifiedContact: !1
+    }), this.autoCreateUnverifiedUserIfNotExists();
+  }
+}
+function y() {
+  return E();
+}
+class q {
+  constructor({
+    api: a,
+    contactCtx: o,
+    sessionsPollingIntervalSeconds: h
+  }) {
+    this.sessionsRefresher = new R(), this.sessionState = new P({
+      session: null,
+      isCreatingSession: !1,
+      isResolvingSession: !1
+    }), this.sessionsState = new P({
+      data: [],
+      cursor: void 0,
+      isLastPage: !1,
+      didStartInitialFetch: !1,
+      /**
+       * Initialize this as `true` so it always starts loading until the first fetch is done
+       */
+      isInitialFetchLoading: !0
+    }), this.reset = async () => {
+      this.sessionState.reset();
+    }, this.registerSessionsRefresherWrapper = () => {
+      var n;
+      // If the widget config was initially provided with a contact token, no state change would be triggered, so we just fetch
+      (n = this.contactCtx.state.get().contact) != null && n.token && !this.sessionsState.get().didStartInitialFetch ? this.registerSessionsRefresher() : this.contactCtx.state.subscribe(({ contact: e }) => {
+        e != null && e.token && !this.sessionsState.get().didStartInitialFetch && this.registerSessionsRefresher();
+      });
+    }, this.registerSessionsRefresher = () => {
+      this.sessionsRefresher.startPolling(async () => {
+        this.sessionsState.get().didStartInitialFetch === !1 && this.sessionsState.setPartial({ didStartInitialFetch: !0 }), await this.refreshSessions(), this.sessionsState.get().isInitialFetchLoading === !0 && this.sessionsState.setPartial({ isInitialFetchLoading: !1 });
+      }, this.sessionsPollingIntervalSeconds * 1e3);
+    }, this.createSession = async () => {
+      var s;
+      this.sessionState.setPartial({ session: null, isCreatingSession: !0 });
+      const n = (s = this.contactCtx.state.get().contact) == null ? void 0 : s.externalId, { data: e, error: t } = await this.api.createSession({
+        customData: n ? {
+          external_id: n
+        } : void 0
+      });
+      return e ? (this.sessionState.setPartial({ session: e, isCreatingSession: !1 }), e) : (this.sessionState.setPartial({ isCreatingSession: !1 }), console.error("Failed to create session:", t), null);
+    }, this.loadMoreSessions = async () => {
+      if (this.sessionsState.get().isLastPage) return;
+      const { data: n } = await this.getSessions({
+        cursor: this.sessionsState.get().cursor
+      });
+      if (n) {
+        const t = [...this.sessionsState.get().data, ...n.items].filter(
+          (s, i, c) => i === c.findIndex((r) => s.id === r.id)
+        );
+        this.sessionsState.setPartial({
+          data: t,
+          cursor: n.next || void 0,
+          isLastPage: n.next === null
+        });
+      }
+    }, this.getSessions = async ({ cursor: n }) => {
+      var t, s;
+      if (!((t = this.contactCtx.state.get().contact) != null && t.token)) return { data: null };
+      const e = (s = this.contactCtx.state.get().contact) == null ? void 0 : s.externalId;
+      return await this.api.getSessions({
+        cursor: n,
+        filters: e ? {
+          external_id: e
+        } : {}
+      });
+    }, this.setSessions = (n) => {
+      const e = [...n, ...this.sessionsState.get().data].filter(
+        (t, s, i) => s === i.findIndex((c) => t.id === c.id)
+      );
+      this.sessionsState.setPartial({ data: e });
+    }, this.refreshSessions = async () => {
+      const { data: n } = await this.getSessions({ cursor: void 0 });
+      n && this.setSessions(n.items);
+    }, this.resolveSession = async () => {
+      const n = this.sessionState.get().session;
+      if (!n || !n.isOpened)
+        return { success: !1, error: "Session is not opened" };
+      this.sessionState.setPartial({ isResolvingSession: !0 });
+      const { data: e, error: t } = await this.api.resolveSession({
+        session_id: n.id
+      });
+      return e ? (this.sessionState.setPartial({ session: e, isResolvingSession: !1 }), { success: !0, data: e }) : (this.sessionState.setPartial({ isResolvingSession: !1 }), { success: !1, error: t });
+    }, this.createStateCheckpoint = async (n) => {
+      var i;
+      const e = (i = this.sessionState.get().session) == null ? void 0 : i.id;
+      if (!e) return;
+      const { data: t, error: s } = await this.api.createStateCheckpoint({
+        session_id: e,
+        payload: n
+      });
+      return t ? { data: t } : { success: !1, error: s };
+    }, this.api = a, this.contactCtx = o, this.sessionsPollingIntervalSeconds = h, this.registerSessionsRefresherWrapper();
+  }
+}
+class $ {
+  constructor({
+    config: a,
+    api: o,
+    sessionCtx: h,
+    contactCtx: n
+  }) {
+    this.state = new P({
+      messages: [],
+      isSendingMessage: !1,
+      lastAIResMightSolveUserIssue: !1,
+      isInitialFetchLoading: !1
+    }), this.sendMessageAbortController = new AbortController(), this.reset = () => {
+      this.sendMessageAbortController.abort("Resetting chat"), this.state.reset();
+    }, this.sendMessage = async (e) => {
+      var r, d, l, C, x, p, w, v;
+      if (!e.content.trim() && (!e.attachments || e.attachments.length === 0)) {
+        console.warn("Cannot send an empty message of no content or attachments");
+        return;
+      }
+      const t = this.state.get().isSendingMessage, s = ((r = this.sessionCtx.sessionState.get().session) == null ? void 0 : r.assignee.kind) === "ai", i = this.state.get().messages, c = i.length > 0 ? i[i.length - 1] : void 0;
+      if (s && t || // If last message is from user, then bot response did not arrive yet
+      s && (c == null ? void 0 : c.type) === "FROM_USER") {
+        console.warn("Cannot send messages while awaiting AI response");
+        return;
+      }
+      this.sendMessageAbortController = new AbortController(), this.state.setPartial({ lastAIResMightSolveUserIssue: !1 });
+      try {
+        this.state.setPartial({ isSendingMessage: !0 });
+        const u = this.toUserMessage(
+          e.content.trim(),
+          e.attachments || void 0
+        ), S = this.state.get().messages;
+        if (this.state.setPartial({
+          messages: [...S, u]
+        }), !((d = this.sessionCtx.sessionState.get().session) != null && d.id)) {
+          if (!await this.sessionCtx.createSession()) {
+            console.error("Failed to create session");
+            return;
+          }
+          this.sessionCtx.refreshSessions();
+        }
+        const k = (l = this.sessionCtx.sessionState.get().session) == null ? void 0 : l.id;
+        if (!k) return;
+        const { data: f } = await this.api.sendMessage(
+          {
+            uuid: u.id,
+            bot_token: this.config.token,
+            headers: this.config.headers,
+            query_params: this.config.queryParams,
+            body_properties: this.config.bodyProperties,
+            session_id: k,
+            content: u.content,
+            attachments: e.attachments,
+            clientContext: this.config.context,
+            custom_data: {
+              ...this.config.messageCustomData || {},
+              ...e.customData || {}
+            },
+            language: this.config.language,
+            exit_mode_prompt: e.exitModePrompt
+          },
+          this.sendMessageAbortController.signal
+        );
+        if (f != null && f.success) {
+          const b = this.toBotMessage(f);
+          if (b) {
+            const I = this.state.get().messages;
+            if (!!I.some(
+              (A) => A.id === b.id
+            )) {
+              this.state.setPartial({
+                lastAIResMightSolveUserIssue: ((C = f.autopilotResponse) == null ? void 0 : C.mightSolveUserIssue) || ((x = f.uiResponse) == null ? void 0 : x.mightSolveUserIssue)
+              });
+              return;
+            }
+            this.state.setPartial({
+              messages: [...I, b],
+              lastAIResMightSolveUserIssue: ((p = f.autopilotResponse) == null ? void 0 : p.mightSolveUserIssue) || ((w = f.uiResponse) == null ? void 0 : w.mightSolveUserIssue)
+            });
+          }
+          f.session && this.sessionCtx.sessionState.setPartial({ session: f.session });
+        } else {
+          const b = this.toBotErrorMessage(
+            ((v = f == null ? void 0 : f.error) == null ? void 0 : v.message) || "Unknown error occurred"
+          ), I = this.state.get().messages;
+          this.state.setPartial({
+            messages: [...I, b]
+          });
+        }
+      } catch (u) {
+        this.sendMessageAbortController.signal.aborted || console.error("Failed to send message:", u);
+      } finally {
+        this.state.setPartial({ isSendingMessage: !1 });
+      }
+    }, this.toUserMessage = (e, t) => {
+      const s = (() => {
+        const i = this.contactCtx.state.get().extraCollectedData;
+        return this.state.get().messages.length === 0 && i && Object.keys(i).length > 0 ? `${Object.entries(i).filter(([r, d]) => !!d).map(([r, d]) => `${r}: ${d}`).join(` 
+`)} 
+
+${e}` : e;
+      })();
+      return {
+        id: y(),
+        type: "FROM_USER",
+        content: s,
+        deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        attachments: t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }, this.toBotMessage = (e) => {
+      var t;
+      return e.success && e.autopilotResponse ? {
+        type: "FROM_BOT",
+        id: e.autopilotResponse.id || y(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: "bot_message",
+        agent: this.config.bot ? {
+          name: this.config.bot.name || "",
+          isAi: !0,
+          avatar: this.config.bot.avatar || "",
+          id: null
+        } : void 0,
+        data: {
+          message: e.autopilotResponse.value.content,
+          action: (t = e.uiResponse) != null && t.value.name ? {
+            name: e.uiResponse.value.name,
+            data: e.uiResponse.value.request_response
+          } : void 0
+        }
+      } : null;
+    }, this.toBotErrorMessage = (e) => ({
+      type: "FROM_BOT",
+      id: y(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: "TEXT",
+      data: {
+        message: e,
+        variant: "error",
+        action: void 0
+      }
+    }), this.config = a, this.api = o, this.sessionCtx = h, this.contactCtx = n;
+  }
+}
+class N {
+  constructor({
+    config: a,
+    contactCtx: o,
+    sessionCtx: h,
+    resetChat: n
+  }) {
+    var e;
+    this.registerRoutingListener = () => {
+      this.contactCtx.state.subscribe(({ contact: t }) => {
+        var s;
+        t != null && t.token && this.state.get().screen === "welcome" && this.state.setPartial({
+          screen: (s = this.config.router) != null && s.chatScreenOnly ? "chat" : "sessions"
+        });
+      }), this.sessionCtx.sessionsState.subscribe(
+        ({ isInitialFetchLoading: t, data: s }) => {
+          var i, c, r, d;
+          if ((i = this.config.router) != null && i.chatScreenOnly && // Do not route to a chat if we are currently inside one already
+          // This also applies to newly created sessions; the new session will be in `sessionState` before it is refreshed and included in `sessionsState`
+          !((c = this.sessionCtx.sessionState.get().session) != null && c.id)) {
+            const l = (r = s.find((C) => C.isOpened)) == null ? void 0 : r.id;
+            return l ? this.toChatScreen(l) : void 0;
+          }
+          s.length || ((d = this.config.router) == null ? void 0 : d.goToChatIfNoSessions) !== !1 && !t && this.state.get().screen !== "chat" && this.toChatScreen();
+        }
+      );
+    }, this.toSessionsScreen = () => {
+      this.resetChat(), this.state.setPartial({ screen: "sessions" });
+    }, this.toChatScreen = (t) => {
+      if (this.resetChat(), t) {
+        const s = this.sessionCtx.sessionsState.get().data.find((i) => i.id === t);
+        if (!s) return;
+        this.sessionCtx.sessionState.setPartial({ session: s });
+      }
+      this.state.setPartial({ screen: "chat" });
+    }, this.config = a, this.contactCtx = o, this.sessionCtx = h, this.resetChat = n, this.state = new P({
+      screen: this.contactCtx.shouldCollectData() ? "welcome" : (e = this.config.router) != null && e.chatScreenOnly ? "chat" : "sessions"
+    }), this.registerRoutingListener();
+  }
+}
+class H {
+  constructor({ storage: a }) {
+    this.KEYS = {
+      contactToken: "opencx__widget__contactToken",
+      externalContactId: "opencx__widget__externalContactId"
+    }, this.setContactToken = async (o) => {
+      await this.storage.set(this.KEYS.contactToken, o);
+    }, this.getContactToken = async () => this.storage.get(this.KEYS.contactToken), this.setExternalContactId = async (o) => {
+      await this.storage.set(this.KEYS.externalContactId, o);
+    }, this.getExternalContactId = async () => this.storage.get(this.KEYS.externalContactId), this.storage = a;
+  }
+}
+const m = class m {
+  constructor({
+    config: a,
+    storage: o,
+    modes: h
+  }) {
+    if (this.modes = [], this.resetChat = () => {
+      this.sessionCtx.reset(), this.messageCtx.reset();
+    }, !m.pollingIntervalsSeconds)
+      throw Error(
+        "Widget polling values are not defined, did you call WidgetCtx.initialize()"
+      );
+    this.config = a, this.api = new T({ config: a }), this.storageCtx = o ? new H({ storage: o }) : void 0, this.modes = h, this.contactCtx = new B({
+      api: this.api,
+      config: this.config,
+      storageCtx: this.storageCtx
+    }), this.sessionCtx = new q({
+      api: this.api,
+      contactCtx: this.contactCtx,
+      sessionsPollingIntervalSeconds: m.pollingIntervalsSeconds.sessions
+    }), this.messageCtx = new $({
+      config: this.config,
+      api: this.api,
+      sessionCtx: this.sessionCtx,
+      contactCtx: this.contactCtx
+    }), this.activeSessionPollingCtx = new L({
+      api: this.api,
+      config: this.config,
+      sessionCtx: this.sessionCtx,
+      messageCtx: this.messageCtx,
+      sessionPollingIntervalSeconds: m.pollingIntervalsSeconds.session
+    }), this.routerCtx = new N({
+      config: this.config,
+      contactCtx: this.contactCtx,
+      sessionCtx: this.sessionCtx,
+      resetChat: this.resetChat
+    });
+  }
+};
+m.pollingIntervalsSeconds = null, m.initialize = async ({
+  config: a,
+  storage: o
+}) => {
+  var n, e, t;
+  const h = await new T({
+    config: a
+  }).getExternalWidgetConfig();
+  return m.pollingIntervalsSeconds = {
+    session: ((n = h.data) == null ? void 0 : n.sessionPollingIntervalSeconds) || 10,
+    sessions: ((e = h.data) == null ? void 0 : e.sessionsPollingIntervalSeconds) || 60
+  }, new m({
+    config: a,
+    storage: o,
+    modes: ((t = h.data) == null ? void 0 : t.modes) || []
+  });
+};
+let U = m;
+export {
+  P,
+  U as W
+};
+//# sourceMappingURL=widget.ctx-uAWzif3-.js.map