@picked/client 0.0.1-dev.1764626732123 → 0.0.1-dev.1764632196476

package/dist/esm/index.js

@@ -1,120 +1,768 @@
-var y = Object.defineProperty;
-var x = (i, e, t) => e in i ? y(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
-var n = (i, e, t) => x(i, typeof e != "symbol" ? e + "" : e, t);
-import { c as I, a as P, b as k, d as w, e as E, f as v, g as S, h as F, i as C, j as b, p as A, s as R, k as u, l as j, m as B, n as z, o as U, q as $, r as K, t as L, u as d } from "../user-session-YEUZkOjt.js";
-import { l as c } from "../logger-C9a75KZn.js";
-import { c as O, d as W, e as l } from "../experience-instance-C2AnM2J_.js";
-import { i as pe } from "../experience-instance-C2AnM2J_.js";
-import { createEvent as _ } from "effector";
-import { s as f, a as D, b as H } from "../supports-DBMT17KZ.js";
-import { g as de, k as le, d as he, i as fe, e as me, c as ge, f as ye, h as xe, j as Ie } from "../supports-DBMT17KZ.js";
-import { c as q, s as h } from "../storage-Cb_71y48.js";
-import { l as ke, a as we } from "../storage-Cb_71y48.js";
-const N = (i, e, t) => {
-  const s = e.name, r = e.setup(i);
-  if (r) {
-    const o = t[s] ?? {};
-    t[s] = Object.freeze({ ...o, ...r });
-  }
-}, T = () => _(), V = () => "0.0.1-dev.1764626732123";
-function G() {
-  if (f()) {
-    const i = [
+var X = Object.defineProperty;
+var Z = (t, e, s) => e in t ? X(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var m = (t, e, s) => Z(t, typeof e != "symbol" ? e + "" : e, s);
+import { createDomain as F, createApi as b, createEffect as U, attach as ee, sample as x, combine as O, createEvent as C } from "effector";
+import { createFactory as k, invoke as w } from "@withease/factories";
+import { g as L, t as te, c as se, i as re, e as E, a as ne, b as ie, d as oe } from "../experience-instance-C4INDX6a.js";
+import { f as kt } from "../experience-instance-C4INDX6a.js";
+import { l as v } from "../logger-C9a75KZn.js";
+import { c as B, s as j, l as D } from "../storage-Cb_71y48.js";
+import { a as It } from "../storage-Cb_71y48.js";
+import { g as ae } from "../id-BW-g3y32.js";
+import { i as ce } from "../object-JwZ58NOH.js";
+import { s as H, a as ue, b as K, c as le, d as de } from "../supports-BjhuLJ8z.js";
+import { h as bt, f as xt, j as Et, e as Pt, g as Rt, i as Bt, k as At } from "../supports-BjhuLJ8z.js";
+const q = F("experience"), pe = k(
+  ({ client: t, experience: e }) => {
+    const s = q.store(e), n = b(s, {
+      merge(u, h) {
+        return {
+          ...u,
+          ...h.experience
+        };
+      }
+    }), a = s.map((u) => ({
+      name: u.name,
+      decisionLogic: u.condition ?? u.decide,
+      targetSelectors: u.targets,
+      initializeOpenLogic: e.initializeOpen
+    })), l = t.components.listStore.map(
+      (u) => u.find((h) => h.name === `experience:${e.id}`) || u.find((h) => h.name === "experience"),
+      { skipVoid: !1 }
+    ), r = s.map((u) => ({
+      steps: u.steps,
+      nodes: u.nodes,
+      edges: u.edges,
+      conditionals: u.conditionals
+    })), i = e.actions ?? [];
+    return {
+      id: e.id,
+      configStore: a,
+      treeStore: r,
+      componentStore: l,
+      actions: i,
+      merge: n.merge
+    };
+  }
+);
+function ge(t) {
+  return w(pe, t);
+}
+const fe = k(({ client: t }) => {
+  const e = q.store({}), s = b(e, {
+    register(r, i) {
+      return {
+        ...r,
+        [i.id]: i
+      };
+    }
+  });
+  function n(r) {
+    const i = e.getState()[r.id];
+    if (i) {
+      i.merge({ experience: r, strategy: "override" });
+      return;
+    }
+    const u = ge({ client: t, experience: r });
+    s.register(u);
+  }
+  const a = e.map((r) => Object.values(r));
+  function l(r) {
+    return e.map((i) => i[r], { skipVoid: !1 });
+  }
+  return {
+    register: n,
+    getById: l,
+    listStore: a
+  };
+});
+function me(t) {
+  return w(fe, t);
+}
+const he = (t, e) => {
+  e.register(t);
+}, G = (t, e) => {
+  const { targetSelectors: s } = e.configStore.getState(), n = L(s, e.id);
+  n.forEach(
+    ({ elements: l }) => l.forEach((r) => te(r, e.id))
+  ), se(n, e.id).forEach((l) => {
+    t.experienceInstances.spawn(e, l);
+  });
+}, M = async (t) => {
+  await Promise.all(
+    t.experiences.listStore.getState().map(async (e) => {
+      await ye(t, e) && G(t, e);
+    })
+  );
+}, ye = async (t, e) => {
+  const { decisionLogic: s, targetSelectors: n } = e.configStore.getState();
+  return L(n, e.id).length < 1 || n.length === 0 ? !1 : s && re(s) ? await E(t, s) === !0 : !0;
+}, Se = (t, e, s) => {
+  const n = e.name, a = e.setup(t);
+  if (a) {
+    const l = s[n] ?? {};
+    s[n] = Object.freeze({ ...l, ...a });
+  }
+}, ve = F("component"), ke = k(
+  ({ client: t, component: e, name: s }) => {
+    const n = t.frameworks.getByName(e.frameworkName);
+    return {
+      name: s,
+      component: e,
+      frameworkStore: n
+    };
+  }
+);
+function we(t) {
+  return w(ke, t);
+}
+const Ie = k(({ client: t }) => {
+  const e = ve.store({}), s = b(e, {
+    register(r, i) {
+      return {
+        ...r,
+        [i.name]: i
+      };
+    }
+  });
+  function n(r, i) {
+    e.getState()[r] && v(
+      "warn",
+      `Component '${r}' already registered. Registering again will override the previous registration.`
+    );
+    const h = we({ client: t, name: r, component: i });
+    s.register(h);
+  }
+  const a = e.map((r) => Object.values(r));
+  function l(r) {
+    return e.map((i) => i[r], { skipVoid: !1 });
+  }
+  return {
+    register: n,
+    getByName: l,
+    listStore: a
+  };
+});
+function Fe(t) {
+  return w(Ie, t);
+}
+const V = (t, e, s) => {
+  s.register(t, e);
+}, be = F("framework"), xe = k(({ client: t }) => {
+  const e = be.store({}), s = b(e, {
+    register(r, i) {
+      return {
+        ...r,
+        [i.name]: i.framework
+      };
+    }
+  });
+  function n(r, i) {
+    e.getState()[r] && v(
+      "warn",
+      `Framework '${r}' already registered. Registering again will override the previous registration.`
+    ), s.register({ name: r, framework: i });
+  }
+  const a = e.map((r) => Object.values(r));
+  function l(r) {
+    return e.map((i) => i[r], { skipVoid: !1 });
+  }
+  return {
+    register: n,
+    getByName: l,
+    listStore: a
+  };
+});
+function Ee(t) {
+  return w(xe, t);
+}
+const Pe = (t, e) => {
+  e.register(t.name, t);
+}, Re = 6e3, T = B("last_ping", "global"), Be = (t) => `${t}/api/v1/ping`, Ae = async (t) => {
+  try {
+    const e = Date.now(), s = localStorage.getItem(T);
+    if (s && e - parseInt(s) < Re)
+      return !0;
+    const n = Be(t.apiUrl), a = {
+      projectId: t.projectId,
+      path: window.location.pathname
+    }, l = JSON.stringify(a), r = {
+      "Content-Type": "application/json"
+    }, i = document.getElementById("picked_script"), u = i == null ? void 0 : i.dataset.verceltoken;
+    u && (r["x-vercel-protection-bypass"] = u);
+    const S = (await fetch(n, {
+      method: "POST",
+      headers: r,
+      body: l
+    })).ok;
+    return S && localStorage.setItem(T, e.toString()), S;
+  } catch (e) {
+    return v("error", e), !1;
+  }
+};
+function $e(t) {
+  const e = typeof window < "u", s = {
+    client: t,
+    responses: t.responses.listStore.getState(),
+    fields: t.fields.listStore.getState(),
+    location: e ? window.location : void 0,
+    document: e ? window.document : void 0,
+    sessionStorage: e ? window.sessionStorage : void 0,
+    localStorage: e ? window.localStorage : void 0
+  };
+  return Object.freeze(s);
+}
+const je = F("predicate"), De = k(({ client: t }) => {
+  const e = je.store({}), s = b(e, {
+    register(r, i) {
+      return {
+        ...r,
+        [i.name]: {
+          name: i.name,
+          predicate: i.predicate
+        }
+      };
+    }
+  });
+  function n(r, i) {
+    e.getState()[r] && v(
+      "warn",
+      `Predicate '${r}' already registered. Registering again will override the previous registration.`
+    ), s.register(Object.freeze({ name: r, predicate: i }));
+  }
+  const a = e.map((r) => Object.values(r));
+  function l(r) {
+    return e.map((i) => i[r], { skipVoid: !1 });
+  }
+  return {
+    register: n,
+    getByName: l,
+    listStore: a
+  };
+});
+function Oe(t) {
+  return w(De, t);
+}
+const Ce = (t, e, s) => {
+  s.register(t, e);
+}, N = F("feature"), Ue = k(({ client: t }) => {
+  const e = N.store({}), s = N.store([]), n = b(e, {
+    register(d, c) {
+      return {
+        ...d,
+        [c.id]: c.feature
+      };
+    }
+  });
+  function a(d, c) {
+    e.getState()[d] && v(
+      "warn",
+      `Feature '${d}' already registered. Registering again will override the previous registration.`
+    );
+    const p = {
+      id: d,
+      feature: {
+        ...c,
+        id: d
+      }
+    };
+    n.register(
+      Object.freeze({
+        id: d,
+        feature: p
+      })
+    );
+  }
+  const l = U(
+    async ({
+      id: d,
+      key: c,
+      storage: o = "local"
+    }) => {
+      const p = B(`feature:${d}:${c}`, "global"), g = (o === "session" ? j : D).get(p).boolean();
+      return g === null ? null : { id: d, key: c, bucket: g, storage: o };
+    }
+  ), r = U((d) => {
+    if (!d)
+      return null;
+    const c = B(`feature:${d.id}:${d.key}`, "global");
+    (d.storage === "session" ? j : D).set(c, d.bucket);
+  }), i = /* @__PURE__ */ new Map(), u = ee({
+    source: { allFeaturesStore: e, resolvedFeaturesStore: s },
+    effect: async ({ allFeaturesStore: d, resolvedFeaturesStore: c }, { id: o, decide: p, key: f }) => {
+      const g = c.find(
+        ($) => $.id === o && $.key === f
+      );
+      if (g)
+        return g;
+      const y = d[o];
+      if (!y)
+        throw new Error(`Feature with id '${o}' not found`);
+      const I = i.get(`${o}:${f}`);
+      if (I !== void 0) {
+        const $ = await I;
+        return { id: y.id, bucket: $, key: f, storage: y.feature.storage };
+      }
+      const A = p();
+      i.set(`${o}:${f}`, A);
+      const P = await A;
+      return { id: y.id, bucket: P, key: f, storage: y.feature.storage };
+    }
+  });
+  x({
+    clock: n.register,
+    fn: (d) => {
+      const { id: c, feature: o } = d;
+      return { id: c, key: o.feature.key, storage: o.feature.storage };
+    },
+    target: l
+  }), x({
+    source: e,
+    clock: u.doneData,
+    fn: (d, c) => {
+      var y;
+      const { id: o, bucket: p, storage: f } = c, g = (y = d[o]) == null ? void 0 : y.feature.key;
+      return g ? { key: g, id: o, bucket: p, storage: f } : null;
+    },
+    target: r
+  });
+  const h = O({ allFeaturesStore: e, resolvedFeaturesStore: s }).map(
+    ({
+      allFeaturesStore: d,
+      resolvedFeaturesStore: c
+    }) => Object.values(d).map((o) => {
+      const p = c.find(
+        (f) => f.id === o.id && f.key === o.feature.key
+      );
+      return p ? {
+        id: o.id,
+        name: o.feature.name,
+        key: o.feature.key,
+        getBucket: () => ({ id: o.id, bucket: p.bucket }),
+        isResolved: !0
+      } : {
+        id: o.id,
+        name: o.feature.name,
+        key: o.feature.key,
+        getBucket: async () => await u(o.feature),
+        isResolved: !1
+      };
+    })
+  );
+  x({
+    clock: u.doneData,
+    source: { resolvedFeatures: s },
+    filter: ({ resolvedFeatures: d }, { id: c, key: o }) => !d.some(
+      (f) => f.id === c && f.key === o
+    ),
+    fn: (d, c) => c,
+    target: t.eventBus.prepend((d) => ({
+      type: "feature_decide",
+      feature: d
+    }))
+  }), x({
+    clock: [l.doneData, u.doneData],
+    source: s,
+    fn: (d, c) => !c || d.some(
+      (p) => p.id === c.id && p.key === c.key
+    ) ? d : [...d, c],
+    target: s
+  });
+  function S(d) {
+    return e.map((c) => c[d], { skipVoid: !1 });
+  }
+  return {
+    register: a,
+    getByName: S,
+    listStore: h
+  };
+});
+function Me(t) {
+  return w(Ue, t);
+}
+const Ve = (t, e, s) => {
+  s.register(t, e);
+}, R = F("history");
+function _(t, e) {
+  return {
+    // eslint-disable-next-line sonarjs/pseudo-random
+    id: ae(`history-entry-${Date.now()}-${Math.random()}}`),
+    node: e,
+    at: Date.now(),
+    experienceId: t
+  };
+}
+const Te = k(() => {
+  const t = R.store({ entries: [] }), e = R.event(), s = R.event(), n = R.event(), a = R.event();
+  t.on(e, (r, i) => ({
+    entries: [...r.entries, _(i.experienceId, i.node)]
+  })), t.on(s, (r, i) => ({
+    entries: [
+      ...r.entries.slice(0, -1),
+      _(i.experienceId, i.node)
+    ]
+  })), t.on(a, (r, i) => i);
+  function l(r, i) {
+    const u = { lastStepIndex: -1, secondLastStepIndex: -1 };
+    for (let h = r.length - 1; h >= 0; h--) {
+      const S = r[h], d = S == null ? void 0 : S.node;
+      if (!(!d || !ne(d)) && !(i && (S == null ? void 0 : S.experienceId) !== i))
+        if (u.lastStepIndex === -1)
+          u.lastStepIndex = h;
+        else {
+          u.secondLastStepIndex = h;
+          break;
+        }
+    }
+    return u;
+  }
+  return t.on(n, (r, i) => {
+    const { secondLastStepIndex: u } = l(r.entries, i.experienceId), h = u !== -1 ? r.entries.slice(0, u + 1) : r.entries;
+    return {
+      ...r,
+      entries: h
+    };
+  }), {
+    push: e,
+    replace: s,
+    back: n,
+    restore: a,
+    entriesStore: t.map((r) => r.entries)
+  };
+});
+function Ne() {
+  return w(Te);
+}
+const _e = () => C(), ze = F("field"), Le = k(() => {
+  const t = ze.store({}), e = b(t, {
+    register(r, i) {
+      return {
+        ...r,
+        [i.field.id]: i.field
+      };
+    }
+  });
+  function s(r) {
+    e.register({ field: r });
+  }
+  const n = t.map((r) => Object.values(r));
+  function a(r) {
+    return t.map((i) => i[r] || null);
+  }
+  function l(r) {
+    return t.map((i) => Object.values(i).find((u) => u.name === r) || null);
+  }
+  return {
+    register: s,
+    getById: a,
+    listStore: n,
+    getByName: l
+  };
+});
+function He() {
+  return w(Le);
+}
+const Ke = (t, e) => {
+  e.register(t);
+}, qe = F("action"), Ge = k(() => {
+  const t = qe.store({}), e = b(t, {
+    register(l, r) {
+      return {
+        ...l,
+        [r.name]: {
+          name: r.name,
+          action: r.action
+        }
+      };
+    }
+  });
+  function s(l, r) {
+    e.register({ name: l, action: r });
+  }
+  const n = t.map((l) => Object.values(l));
+  function a(l) {
+    return t.map((r) => r[l], { skipVoid: !1 });
+  }
+  return {
+    register: s,
+    getByName: a,
+    listStore: n
+  };
+});
+function We() {
+  return w(Ge);
+}
+const Ye = (t, e, s) => {
+  s.register(t, e);
+};
+function z(t) {
+  return typeof t > "u" || t === null || t === "" || Array.isArray(t) && !t.length;
+}
+const Je = F("response"), Qe = k(({ client: t }) => {
+  const e = Je.store({}), s = C(), n = C(), a = b(e, {
+    register(c, o) {
+      return {
+        ...c,
+        [o.fieldId]: o.response
+      };
+    },
+    registerBatch(c, o) {
+      return {
+        ...c,
+        ...o
+      };
+    },
+    clear(c, o) {
+      const { [o]: p, ...f } = c;
+      return f;
+    },
+    clearAll() {
+      return {};
+    }
+  });
+  function l(c, o) {
+    a.register({ fieldId: c, response: o });
+  }
+  async function r(c) {
+    const o = [];
+    return await Promise.allSettled(
+      Object.entries(c).map(async ([p, f]) => {
+        let g = f;
+        const y = t.fields.getById(p).getState();
+        if (!y) {
+          o.push({
+            fieldId: p,
+            userMessage: `Field '${p}' not found`,
+            systemMessage: `No field with ID '${p}' exists. Available field IDs are: ${Object.keys(t.fields.listStore.getState()).join(",")}.`,
+            value: g
+          });
+          return;
+        }
+        if (y.multiple && (typeof g == "string" || typeof g == "number" || typeof g == "boolean") && (g = [g]), y.validation && !ce(y.validation) && !z(g)) {
+          const I = await E(t, y.validation, {
+            $input: g
+          });
+          if (typeof I == "string") {
+            o.push({
+              fieldId: p,
+              userMessage: I,
+              systemMessage: `Field validation resulted in an error: ${I}.`,
+              value: g
+            });
+            return;
+          }
+          if (I === !1) {
+            o.push({
+              fieldId: p,
+              userMessage: "This field is invalid",
+              systemMessage: "Field validation resulted in an unspecified error.",
+              value: g
+            });
+            return;
+          }
+        }
+        if (y.required && z(g)) {
+          o.push({
+            fieldId: p,
+            userMessage: "This field is required",
+            systemMessage: "Field is required.",
+            value: g
+          });
+          return;
+        }
+        if (!y.multiple && Array.isArray(g) && g.length > 1) {
+          o.push({
+            fieldId: p,
+            userMessage: "This field expects a single response",
+            systemMessage: "Field expects a single response.",
+            value: g
+          });
+          return;
+        }
+        if (y.options) {
+          const I = y.options.map((P) => P.value), A = Array.isArray(g) ? g : [g];
+          Array.isArray(g) && (A.every((P) => I.includes(P)) || o.push({
+            fieldId: p,
+            userMessage: "This field expects a valid option",
+            systemMessage: `Field expects a valid option. Valid options are: ${I.join(", ")}`,
+            value: g
+          }));
+        }
+      })
+    ), { responsesToCommit: c, validationErrors: o };
+  }
+  async function i(c) {
+    const { responsesToCommit: o, validationErrors: p } = await r(c);
+    return p.length ? { errors: p } : (a.registerBatch(o), { errors: [] });
+  }
+  const u = e.map((c) => c), h = e.map((c) => Object.keys(c).map((p) => ({
+    fieldId: p,
+    value: c[p]
+  })));
+  function S(c) {
+    const o = t.fields.getById(c), p = e.map((f) => f[c] || null);
+    return O({ f: o, r: p }, ({ f, r: g }) => g || (f != null && f.defaultValue ? f.defaultValue : null));
+  }
+  function d(c) {
+    const o = t.fields.getByName(c);
+    return O({ f: o, s: e }, ({ f: p, s: f }) => {
+      const g = p && f[p.id] || null;
+      return g || (p != null && p.defaultValue ? p.defaultValue : null);
+    });
+  }
+  return x({
+    clock: s,
+    target: a.clearAll
+  }), x({
+    clock: n,
+    target: a.clear
+  }), {
+    register: l,
+    clearAll: s,
+    clear: n,
+    commit: i,
+    getResponsesToCommit: r,
+    listStore: h,
+    getAllStore: u,
+    getByFieldId: S,
+    getByFieldName: d
+  };
+});
+function Xe(t) {
+  return w(Qe, t);
+}
+const Ze = () => "0.0.1-dev.1764632196476";
+function et() {
+  if (H()) {
+    const t = [
       document.currentScript,
       document.getElementById("picked_script"),
       document.getElementById("picked"),
       document.getElementById("cvly"),
       document.getElementById("cvly-x")
     ];
-    for (const e of i)
+    for (const e of t)
       if (e != null && e.dataset.api)
         return e.dataset.api;
   }
   return "https://api.picked.app";
 }
-function J() {
-  if (!D())
+function tt() {
+  if (!ue())
     return {};
-  const i = new URLSearchParams(window.location.search), e = {}, t = /* @__PURE__ */ new Set();
-  for (const [r] of i.entries())
-    r.startsWith("picked-") && t.add(r);
-  for (const r of t) {
-    const o = r.replace("picked-", "");
-    e[o] = i.getAll(r);
-  }
-  const s = q("s");
-  if (t.size > 0)
-    h.set(s, e);
+  const t = new URLSearchParams(window.location.search), e = {}, s = /* @__PURE__ */ new Set();
+  for (const [a] of t.entries())
+    a.startsWith("picked-") && s.add(a);
+  for (const a of s) {
+    const l = a.replace("picked-", "");
+    e[l] = t.getAll(a);
+  }
+  const n = B("s");
+  if (s.size > 0)
+    j.set(n, e);
   else {
-    const r = h.get(s);
-    if (r)
-      return r.json() || {};
+    const a = j.get(n);
+    if (a)
+      return a.json() || {};
   }
   return e;
 }
-class m {
+function st() {
+  if (le())
+    return crypto.randomUUID();
+  const t = Date.now().toString(36), e = Math.random().toString(36).substring(2, 15), s = Math.random().toString(36).substring(2, 15), n = Math.random().toString(36).substring(2, 15);
+  return `${t}-${e}-${s}-${n}`;
+}
+const W = B("session", "global"), Y = () => {
+  const t = K() ? D.get(W) : null;
+  return function(s) {
+    this.isUser = s, t && t.set(this);
+  };
+}, rt = () => ({
+  id: st(),
+  isUser: void 0,
+  setIsUser: Y()
+}), nt = () => {
+  if (!K()) return null;
+  const t = D.get(W);
+  let e = t.isSet() ? t.json() : null;
+  if (!e) {
+    const s = rt();
+    return t.set(s), s;
+  }
+  return {
+    ...e,
+    setIsUser: Y()
+  };
+}, it = () => nt();
+class J {
   constructor(e) {
-    n(this, "options");
-    n(this, "isReady", !1);
-    n(this, "project");
-    n(this, "plugins", {});
-    n(this, "eventBus", T());
-    n(this, "organizationId");
-    n(this, "projectId");
-    n(this, "apiUrl");
-    n(this, "session");
-    n(this, "searchParams", J());
-    n(this, "history", I());
-    n(this, "components", P({ client: this }));
-    n(this, "experienceInstances", O({ client: this }));
-    n(this, "experiences", k({ client: this }));
-    n(this, "frameworks", w({ client: this }));
-    n(this, "predicates", E({ client: this }));
-    n(this, "features", v({ client: this }));
-    n(this, "responses", S({ client: this }));
-    n(this, "fields", F());
-    n(this, "actions", C());
-    c("info", "Picked client initializing."), this.organizationId = e.organizationId, this.projectId = e.projectId, this.options = Object.freeze(e), this.apiUrl = e.apiUrl || G(), this.session = b(), this.setupPlugins(), this.setupFeatures(), this.setupPredicates(), this.setupActions(), this.eventBus({ type: "initialized", version: V() }), c("info", "Picked client initialized.");
+    m(this, "options");
+    m(this, "isReady", !1);
+    m(this, "project");
+    m(this, "plugins", {});
+    m(this, "eventBus", _e());
+    m(this, "organizationId");
+    m(this, "projectId");
+    m(this, "apiUrl");
+    m(this, "session");
+    m(this, "precondition");
+    m(this, "condition");
+    m(this, "searchParams", tt());
+    m(this, "history", Ne());
+    m(this, "components", Fe({ client: this }));
+    m(this, "experienceInstances", ie({ client: this }));
+    m(this, "experiences", me({ client: this }));
+    m(this, "frameworks", Ee({ client: this }));
+    m(this, "predicates", Oe({ client: this }));
+    m(this, "features", Me({ client: this }));
+    m(this, "responses", Xe({ client: this }));
+    m(this, "fields", He());
+    m(this, "actions", We());
+    v("info", "Picked client initializing."), this.organizationId = e.organizationId, this.projectId = e.projectId, this.options = Object.freeze(e), this.apiUrl = e.apiUrl || et(), this.session = it(), this.setupPlugins(), this.setupFeatures(), this.setupPredicates(), this.setupActions(), this.precondition = e.precondition, this.condition = e.condition, this.eventBus({ type: "load", version: Ze() }), v("info", "Picked client initialized.");
   }
   start() {
-    A(this), (async () => {
-      f() && (document.body && d(this), await W(), d(this), this.eventBus({ type: "ready" }), this.isReady = !0, this.session && this.eventBus({ type: "session", ...this.session }));
+    Ae(this), (async () => {
+      if (!H())
+        return;
+      let s = !0, n;
+      this.precondition !== void 0 && await E(this, this.precondition) === !1 && (n = !1, s = !1), this.condition !== void 0 && n !== !1 && await E(this, this.condition) === !1 && (s = !1), this.session && this.session.setIsUser(s), this.eventBus({ type: "initialize", is_user: s }), this.eventBus({ type: "user_decide", value: s }), document.body && s && M(this), await oe(), s && M(this), this.eventBus({ type: "ready" }), this.isReady = !0, this.session && this.eventBus({ type: "session", ...this.session });
     })();
   }
   registerFramework(e) {
-    R(e, this.frameworks);
+    Pe(e, this.frameworks);
   }
-  registerComponent(e, t) {
-    u(e, t, this.components);
+  registerComponent(e, s) {
+    V(e, s, this.components);
   }
   registerPlugin(e) {
-    N(this, e, this.plugins);
+    Se(this, e, this.plugins);
   }
-  registerFeature(e, t) {
-    j(e, t, this.features);
+  registerFeature(e, s) {
+    Ve(e, s, this.features);
   }
-  registerPredicate(e, t) {
-    B(e, t, this.predicates);
+  registerPredicate(e, s) {
+    Ce(e, s, this.predicates);
   }
   registerField(e) {
-    z(e, this.fields);
+    Ke(e, this.fields);
   }
-  registerAction(e, t) {
-    U(e, t, this.actions);
+  registerAction(e, s) {
+    Ye(e, s, this.actions);
   }
   registerExperience(e) {
-    e.component && u(`experience:${e.id}`, e.component, this.components), $(e, this.experiences);
+    e.component && V(`experience:${e.id}`, e.component, this.components), he(e, this.experiences);
   }
   getStateSnapshot() {
-    return K(this);
+    return $e(this);
   }
   async launchExperienceById(e) {
-    const t = this.experiences.getById(e).getState();
-    if (!t) {
-      c("warn", `Experience with id '${e}' not found.`);
+    const s = this.experiences.getById(e).getState();
+    if (!s) {
+      v("warn", `Experience with id '${e}' not found.`);
       return;
     }
-    L(this, t);
+    G(this, s);
   }
   // private async fetchProject() {
   //   if (this.project) {
@@ -127,38 +775,38 @@ class m {
   // }
   setupPlugins() {
     var e;
-    (e = this.options.plugins) == null || e.forEach((t) => {
-      if (Array.isArray(t)) {
-        t.forEach((r) => {
-          this.registerPlugin(r);
+    (e = this.options.plugins) == null || e.forEach((s) => {
+      if (Array.isArray(s)) {
+        s.forEach((a) => {
+          this.registerPlugin(a);
         });
         return;
       }
-      const s = typeof t == "function" ? t() : t;
-      if (Array.isArray(s)) {
-        s.forEach((r) => this.registerPlugin(r));
+      const n = typeof s == "function" ? s() : s;
+      if (Array.isArray(n)) {
+        n.forEach((a) => this.registerPlugin(a));
         return;
       }
-      this.registerPlugin(s);
+      this.registerPlugin(n);
     });
   }
   setupFeatures() {
     const e = this.options.features;
-    e && (Object.entries(e).forEach(([t, s]) => {
-      const r = typeof s == "function" ? s() : s;
-      this.registerFeature(t, r);
-    }), this.searchParams.feature && this.searchParams.feature.forEach((t) => {
+    e && (Object.entries(e).forEach(([s, n]) => {
+      const a = typeof n == "function" ? n() : n;
+      this.registerFeature(s, a);
+    }), this.searchParams.feature && this.searchParams.feature.forEach((s) => {
       try {
-        const [s, r] = t.split(":");
-        if (!s || !r)
+        const [n, a] = s.split(":");
+        if (!n || !a)
           return;
-        let o = r;
-        o === "true" && (o = !0), o === "false" && (o = !1), this.registerFeature(s, {
-          key: `${o}`,
+        let l = a;
+        l === "true" && (l = !0), l === "false" && (l = !1), this.registerFeature(n, {
+          key: `${l}`,
           // use the assigned bucket value as the key
-          name: s,
+          name: n,
           // eslint-disable-next-line sonarjs/function-return-type
-          decide: () => o,
+          decide: () => l,
           storage: "session"
         });
       } catch {
@@ -167,73 +815,73 @@ class m {
   }
   setupPredicates() {
     const e = this.options.predicates;
-    e && Object.entries(e).forEach(([t, s]) => {
-      if (typeof s != "function") {
-        c("warn", `Predicate "${t}" is not a function.`);
+    e && Object.entries(e).forEach(([s, n]) => {
+      if (typeof n != "function") {
+        v("warn", `Predicate "${s}" is not a function.`);
         return;
       }
-      this.registerPredicate(t, s);
+      this.registerPredicate(s, n);
     });
   }
   setupActions() {
     const e = this.options.actions;
-    e && Object.entries(e).forEach(([t, s]) => {
-      if (typeof s != "function") {
-        c("warn", `Action "${t}" is not a function.`);
+    e && Object.entries(e).forEach(([s, n]) => {
+      if (typeof n != "function") {
+        v("warn", `Action "${s}" is not a function.`);
         return;
       }
-      this.registerAction(t, s);
+      this.registerAction(s, n);
     });
   }
   getPluginConfig(e) {
     return this.plugins[e] ?? {};
   }
 }
-n(m, "logger", c);
-function g(i) {
+m(J, "logger", v);
+function Q(t) {
   var e;
-  return ((e = i.options) == null ? void 0 : e.some((t) => "condition" in t)) ?? !1;
+  return ((e = t.options) == null ? void 0 : e.some((s) => "condition" in s)) ?? !1;
 }
-function M(i) {
-  return i.some((e) => e.condition || g(e));
+function ot(t) {
+  return t.some((e) => e.condition || Q(e));
 }
-async function re(i, e) {
-  return e.length === 0 || !M(e) ? e : (await Promise.all(
-    e.map(async (s) => {
-      if (!(s.condition ? await l(i, s.condition) : !0))
+async function ht(t, e) {
+  return e.length === 0 || !ot(e) ? e : (await Promise.all(
+    e.map(async (n) => {
+      if (!(n.condition ? await E(t, n.condition) : !0))
         return null;
-      if (!s.options || !g(s))
-        return s;
-      const p = (await Promise.all(
-        s.options.map(async (a) => a.condition ? await l(i, a.condition) ? a : null : a)
-      )).filter((a) => a !== null);
-      return p.length === s.options.length ? s : p.length === 0 ? null : { ...s, options: p };
+      if (!n.options || !Q(n))
+        return n;
+      const r = (await Promise.all(
+        n.options.map(async (u) => u.condition ? await E(t, u.condition) ? u : null : u)
+      )).filter((u) => u !== null);
+      return r.length === n.options.length ? n : r.length === 0 ? null : { ...n, options: r };
     })
-  )).filter((s) => s !== null);
+  )).filter((n) => n !== null);
 }
-const oe = (i) => {
-  const e = new m(i);
-  return H(e), e;
+const yt = (t) => {
+  const e = new J(t);
+  return de(e), e;
 };
 export {
-  m as Picked,
-  oe as createClient,
-  q as createStorageKey,
-  l as evaluateRuleLogic,
-  re as getStepFields,
-  pe as isPickedRoot,
-  ke as localStore,
-  h as sessionStore,
-  we as subscribe,
-  de as supportsCookies,
+  J as Picked,
+  yt as createClient,
+  B as createStorageKey,
+  E as evaluateRuleLogic,
+  ht as getStepFields,
+  kt as isPickedRoot,
+  D as localStore,
+  j as sessionStore,
+  It as subscribe,
+  bt as supportsCookies,
   le as supportsCryptoRandomUUID,
-  f as supportsDocument,
-  he as supportsHistory,
-  fe as supportsIntersectionObserver,
-  me as supportsLocalStorage,
-  ge as supportsLocation,
-  ye as supportsSessionStorage,
-  xe as supportsShadowRoot,
-  Ie as supportsWebComponents,
-  D as supportsWindow
+  H as supportsDocument,
+  xt as supportsHistory,
+  Et as supportsIntersectionObserver,
+  K as supportsLocalStorage,
+  Pt as supportsLocation,
+  Rt as supportsSessionStorage,
+  Bt as supportsShadowRoot,
+  At as supportsWebComponents,
+  ue as supportsWindow
 };