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

package/dist/user-session-YEUZkOjt.js

@@ -0,0 +1,718 @@
+import { createDomain as h, createApi as b, createStore as C, createEffect as B, sample as w, attach as q, combine as A, createEvent as O } from "effector";
+import { createFactory as v, invoke as k } from "@withease/factories";
+import { g as L, t as z, b as G, f as Y, e as _, h as J } from "./experience-instance-C2AnM2J_.js";
+import { l as E } from "./logger-C9a75KZn.js";
+import { c as D, s as V, l as j } from "./storage-Cb_71y48.js";
+import { g as K } from "./id-BW-g3y32.js";
+import { i as Q } from "./object-JwZ58NOH.js";
+import { e as W, k as X } from "./supports-DBMT17KZ.js";
+const U = h("experience"), Z = v(
+  ({ client: e, experience: t }) => {
+    const a = U.store(t), l = b(a, {
+      merge(c, g) {
+        return {
+          ...c,
+          ...g.experience
+        };
+      }
+    }), p = a.map((c) => ({
+      name: c.name,
+      decisionLogic: c.decide,
+      targetSelectors: c.targets,
+      initializeOpenLogic: t.initializeOpen
+    })), f = e.components.listStore.map(
+      (c) => c.find((g) => g.name === `experience:${t.id}`) || c.find((g) => g.name === "experience"),
+      { skipVoid: !1 }
+    ), r = a.map((c) => ({
+      steps: c.steps,
+      nodes: c.nodes,
+      edges: c.edges,
+      conditionals: c.conditionals
+    })), n = t.actions ?? [];
+    return {
+      id: t.id,
+      configStore: p,
+      treeStore: r,
+      componentStore: f,
+      actions: n,
+      merge: l.merge
+    };
+  }
+);
+function ee(e) {
+  return k(Z, e);
+}
+const te = v(({ client: e }) => {
+  const t = U.store({}), a = b(t, {
+    register(r, n) {
+      return {
+        ...r,
+        [n.id]: n
+      };
+    }
+  });
+  function l(r) {
+    const n = t.getState()[r.id];
+    if (n) {
+      n.merge({ experience: r, strategy: "override" });
+      return;
+    }
+    const c = ee({ client: e, experience: r });
+    a.register(c);
+  }
+  const p = t.map((r) => Object.values(r));
+  function f(r) {
+    return t.map((n) => n[r], { skipVoid: !1 });
+  }
+  return {
+    register: l,
+    getById: f,
+    listStore: p
+  };
+});
+function Me(e) {
+  return k(te, e);
+}
+const Pe = (e, t) => {
+  t.register(e);
+}, re = (e, t) => {
+  const { targetSelectors: a } = t.configStore.getState(), l = L(a, t.id);
+  l.forEach(
+    ({ elements: f }) => f.forEach((r) => z(r, t.id))
+  ), G(l, t.id).forEach((f) => {
+    e.experienceInstances.spawn(t, f);
+  });
+}, Te = async (e) => {
+  await Promise.all(
+    e.experiences.listStore.getState().map(async (t) => {
+      await ne(e, t) && re(e, t);
+    })
+  );
+}, ne = async (e, t) => {
+  const { decisionLogic: a, targetSelectors: l } = t.configStore.getState();
+  return L(l, t.id).length < 1 || l.length === 0 ? !1 : a && Y(a) ? await _(e, a) === !0 : !0;
+}, se = h("component"), oe = v(
+  ({ client: e, component: t, name: a }) => {
+    const l = e.frameworks.getByName(t.frameworkName);
+    return {
+      name: a,
+      component: t,
+      frameworkStore: l
+    };
+  }
+);
+function ie(e) {
+  return k(oe, e);
+}
+const ae = v(({ client: e }) => {
+  const t = se.store({}), a = b(t, {
+    register(r, n) {
+      return {
+        ...r,
+        [n.name]: n
+      };
+    }
+  });
+  function l(r, n) {
+    t.getState()[r] && E(
+      "warn",
+      `Component '${r}' already registered. Registering again will override the previous registration.`
+    );
+    const g = ie({ client: e, name: r, component: n });
+    a.register(g);
+  }
+  const p = t.map((r) => Object.values(r));
+  function f(r) {
+    return t.map((n) => n[r], { skipVoid: !1 });
+  }
+  return {
+    register: l,
+    getByName: f,
+    listStore: p
+  };
+});
+function Ne(e) {
+  return k(ae, e);
+}
+const Ce = (e, t, a) => {
+  a.register(e, t);
+}, ce = h("framework"), ue = v(({ client: e }) => {
+  const t = ce.store({}), a = b(t, {
+    register(r, n) {
+      return {
+        ...r,
+        [n.name]: n.framework
+      };
+    }
+  });
+  function l(r, n) {
+    t.getState()[r] && E(
+      "warn",
+      `Framework '${r}' already registered. Registering again will override the previous registration.`
+    ), a.register({ name: r, framework: n });
+  }
+  const p = t.map((r) => Object.values(r));
+  function f(r) {
+    return t.map((n) => n[r], { skipVoid: !1 });
+  }
+  return {
+    register: l,
+    getByName: f,
+    listStore: p
+  };
+});
+function Le(e) {
+  return k(ue, e);
+}
+const _e = (e, t) => {
+  t.register(e.name, e);
+}, le = 6e3, M = D("last_ping", "global"), de = (e) => `${e}/api/v1/ping`, Ue = async (e) => {
+  try {
+    const t = Date.now(), a = localStorage.getItem(M);
+    if (a && t - parseInt(a) < le)
+      return !0;
+    const l = de(e.apiUrl), p = {
+      projectId: e.projectId,
+      path: window.location.pathname
+    }, f = JSON.stringify(p), r = {
+      "Content-Type": "application/json"
+    }, n = document.getElementById("picked_script"), c = n == null ? void 0 : n.dataset.verceltoken;
+    c && (r["x-vercel-protection-bypass"] = c);
+    const m = (await fetch(l, {
+      method: "POST",
+      headers: r,
+      body: f
+    })).ok;
+    return m && localStorage.setItem(M, t.toString()), m;
+  } catch (t) {
+    return E("error", t), !1;
+  }
+};
+function ge(e) {
+  const t = typeof window < "u", a = {
+    client: e,
+    responses: e.responses.listStore.getState(),
+    fields: e.fields.listStore.getState(),
+    location: t ? window.location : void 0,
+    document: t ? window.document : void 0,
+    sessionStorage: t ? window.sessionStorage : void 0,
+    localStorage: t ? window.localStorage : void 0
+  };
+  return Object.freeze(a);
+}
+const pe = h("predicate"), fe = v(({ client: e }) => {
+  const t = pe.store({}), a = b(t, {
+    register(n, c) {
+      return {
+        ...n,
+        [c.name]: {
+          name: c.name,
+          predicate: c.predicate
+        }
+      };
+    }
+  });
+  function l(n, c) {
+    t.getState()[n] && E(
+      "warn",
+      `Predicate '${n}' already registered. Registering again will override the previous registration.`
+    ), a.register(Object.freeze({ name: n, predicate: c }));
+  }
+  const p = t.map((n) => Object.values(n));
+  function f(n) {
+    return t.map((c) => {
+      var g;
+      return (g = c[n]) == null ? void 0 : g.predicate;
+    }, { skipVoid: !1 });
+  }
+  function r(n) {
+    const c = C(() => {
+    }, {
+      skipVoid: !1
+    }), g = B(async () => {
+      const m = f(n).getState();
+      if (!m)
+        return;
+      const F = ge(e);
+      return () => m(F);
+    });
+    return w({
+      source: { responses: e.responses.listStore, fields: e.fields.listStore },
+      target: g
+    }), w({
+      clock: g.doneData,
+      filter: (m) => m !== void 0,
+      target: c
+    }), g(), c;
+  }
+  return {
+    register: l,
+    getByName: f,
+    listStore: p,
+    getEvokablePredicate: r
+  };
+});
+function He(e) {
+  return k(fe, e);
+}
+const qe = (e, t, a) => {
+  a.register(e, t);
+}, P = h("feature"), me = v(({ client: e }) => {
+  const t = P.store({}), a = P.store([]), l = b(t, {
+    register(s, i) {
+      return {
+        ...s,
+        [i.id]: i.feature
+      };
+    }
+  });
+  function p(s, i) {
+    t.getState()[s] && E(
+      "warn",
+      `Feature '${s}' already registered. Registering again will override the previous registration.`
+    );
+    const d = {
+      id: s,
+      feature: {
+        ...i,
+        id: s
+      }
+    };
+    l.register(
+      Object.freeze({
+        id: s,
+        feature: d
+      })
+    );
+  }
+  const f = B(
+    async ({
+      id: s,
+      key: i,
+      storage: o = "local"
+    }) => {
+      const d = D(`feature:${s}:${i}`, "global"), S = (o === "session" ? V : j).get(d).boolean();
+      return S === null ? null : { id: s, key: i, bucket: S, storage: o };
+    }
+  ), r = B((s) => {
+    if (!s)
+      return null;
+    const i = D(`feature:${s.id}:${s.key}`, "global");
+    (s.storage === "session" ? V : j).set(i, s.bucket);
+  }), n = /* @__PURE__ */ new Map(), c = q({
+    source: { allFeaturesStore: t, resolvedFeaturesStore: a },
+    effect: async ({ allFeaturesStore: s, resolvedFeaturesStore: i }, { id: o, decide: d, key: u }) => {
+      const S = i.find(
+        ($) => $.id === o && $.key === u
+      );
+      if (S)
+        return S;
+      const y = s[o];
+      if (!y)
+        throw new Error(`Feature with id '${o}' not found`);
+      const R = n.get(`${o}:${u}`);
+      if (R !== void 0) {
+        const $ = await R;
+        return { id: y.id, bucket: $, key: u, storage: y.feature.storage };
+      }
+      const x = d();
+      n.set(`${o}:${u}`, x);
+      const H = await x;
+      return { id: y.id, bucket: H, key: u, storage: y.feature.storage };
+    }
+  });
+  w({
+    clock: l.register,
+    fn: (s) => {
+      const { id: i, feature: o } = s;
+      return { id: i, key: o.feature.key, storage: o.feature.storage };
+    },
+    target: f
+  }), w({
+    source: t,
+    clock: c.doneData,
+    fn: (s, i) => {
+      var y;
+      const { id: o, bucket: d, storage: u } = i, S = (y = s[o]) == null ? void 0 : y.feature.key;
+      return S ? { key: S, id: o, bucket: d, storage: u } : null;
+    },
+    target: r
+  });
+  const g = A({ allFeaturesStore: t, resolvedFeaturesStore: a }).map(
+    ({
+      allFeaturesStore: s,
+      resolvedFeaturesStore: i
+    }) => Object.values(s).map((o) => {
+      const d = i.find(
+        (u) => u.id === o.id && u.key === o.feature.key
+      );
+      return d ? {
+        id: o.id,
+        name: o.feature.name,
+        key: o.feature.key,
+        getBucket: () => ({ id: o.id, bucket: d.bucket }),
+        isResolved: !0
+      } : {
+        id: o.id,
+        name: o.feature.name,
+        key: o.feature.key,
+        getBucket: async () => await c(o.feature),
+        isResolved: !1
+      };
+    })
+  );
+  w({
+    clock: c.doneData,
+    source: { resolvedFeatures: a },
+    filter: ({ resolvedFeatures: s }, { id: i, key: o }) => !s.some(
+      (u) => u.id === i && u.key === o
+    ),
+    fn: (s, i) => i,
+    target: e.eventBus.prepend((s) => ({
+      type: "feature_decide",
+      feature: s
+    }))
+  }), w({
+    clock: [f.doneData, c.doneData],
+    source: a,
+    fn: (s, i) => !i || s.some(
+      (d) => d.id === i.id && d.key === i.key
+    ) ? s : [...s, i],
+    target: a
+  });
+  function m(s) {
+    return g.map((i) => i.find((o) => o.id === s));
+  }
+  function F(s) {
+    const i = C(
+      async () => {
+      },
+      { skipVoid: !1 }
+    ), o = B(async () => {
+      const d = m(s).getState();
+      if (d)
+        return async () => (await d.getBucket()).bucket;
+    });
+    return w({
+      source: a,
+      filter: (d) => d.some((u) => u.id === s),
+      target: o
+    }), w({
+      clock: o.doneData,
+      filter: (d) => d !== void 0,
+      target: i
+    }), o(), i;
+  }
+  return {
+    register: p,
+    getById: m,
+    listStore: g,
+    getEvokableFeature: F
+  };
+});
+function ze(e) {
+  return k(me, e);
+}
+const Ge = (e, t, a) => {
+  a.register(e, t);
+}, I = h("history");
+function T(e, t) {
+  return {
+    // eslint-disable-next-line sonarjs/pseudo-random
+    id: K(`history-entry-${Date.now()}-${Math.random()}}`),
+    node: t,
+    at: Date.now(),
+    experienceId: e
+  };
+}
+const Se = v(() => {
+  const e = I.store({ entries: [] }), t = I.event(), a = I.event(), l = I.event(), p = I.event();
+  e.on(t, (r, n) => ({
+    entries: [...r.entries, T(n.experienceId, n.node)]
+  })), e.on(a, (r, n) => ({
+    entries: [
+      ...r.entries.slice(0, -1),
+      T(n.experienceId, n.node)
+    ]
+  })), e.on(p, (r, n) => n);
+  function f(r, n) {
+    const c = { lastStepIndex: -1, secondLastStepIndex: -1 };
+    for (let g = r.length - 1; g >= 0; g--) {
+      const m = r[g], F = m == null ? void 0 : m.node;
+      if (!(!F || !J(F)) && !(n && (m == null ? void 0 : m.experienceId) !== n))
+        if (c.lastStepIndex === -1)
+          c.lastStepIndex = g;
+        else {
+          c.secondLastStepIndex = g;
+          break;
+        }
+    }
+    return c;
+  }
+  return e.on(l, (r, n) => {
+    const { secondLastStepIndex: c } = f(r.entries, n.experienceId), g = c !== -1 ? r.entries.slice(0, c + 1) : r.entries;
+    return {
+      ...r,
+      entries: g
+    };
+  }), {
+    push: t,
+    replace: a,
+    back: l,
+    restore: p,
+    entriesStore: e.map((r) => r.entries)
+  };
+});
+function Ye() {
+  return k(Se);
+}
+const ye = h("field"), ve = v(() => {
+  const e = ye.store({}), t = b(e, {
+    register(r, n) {
+      return {
+        ...r,
+        [n.field.id]: n.field
+      };
+    }
+  });
+  function a(r) {
+    t.register({ field: r });
+  }
+  const l = e.map((r) => Object.values(r));
+  function p(r) {
+    return e.map((n) => n[r] || null);
+  }
+  function f(r) {
+    return e.map((n) => Object.values(n).find((c) => c.name === r) || null);
+  }
+  return {
+    register: a,
+    getById: p,
+    listStore: l,
+    getByName: f
+  };
+});
+function Je() {
+  return k(ve);
+}
+const Ke = (e, t) => {
+  t.register(e);
+}, ke = h("action"), we = v(() => {
+  const e = ke.store({}), t = b(e, {
+    register(r, n) {
+      return {
+        ...r,
+        [n.name]: {
+          name: n.name,
+          action: n.action
+        }
+      };
+    }
+  });
+  function a(r, n) {
+    t.register({ name: r, action: n });
+  }
+  const l = e.map((r) => Object.values(r));
+  function p(r) {
+    return e.map((n) => n[r], { skipVoid: !1 });
+  }
+  function f(r) {
+    return e.map(
+      (n) => {
+        const c = n[r];
+        return c ? c.action : void 0;
+      },
+      { skipVoid: !1 }
+    );
+  }
+  return {
+    register: a,
+    getByName: p,
+    listStore: l,
+    getEvokableAction: f
+  };
+});
+function Qe() {
+  return k(we);
+}
+const We = (e, t, a) => {
+  a.register(e, t);
+};
+function N(e) {
+  return typeof e > "u" || e === null || e === "" || Array.isArray(e) && !e.length;
+}
+const he = h("response"), be = v(({ client: e }) => {
+  const t = he.store({}), a = O(), l = O(), p = b(t, {
+    register(s, i) {
+      return {
+        ...s,
+        [i.fieldId]: i.response
+      };
+    },
+    registerBatch(s, i) {
+      return {
+        ...s,
+        ...i
+      };
+    },
+    clear(s, i) {
+      const { [i]: o, ...d } = s;
+      return d;
+    },
+    clearAll() {
+      return {};
+    }
+  });
+  function f(s, i) {
+    if (typeof s == "string") {
+      if (i === void 0)
+        throw new Error("Response is required when registering a single field");
+      p.register({ fieldId: s, response: i });
+    } else
+      p.registerBatch(s);
+  }
+  async function r(s) {
+    const i = [];
+    return await Promise.allSettled(
+      Object.entries(s).map(async ([o, d]) => {
+        let u = d;
+        const S = e.fields.getById(o).getState();
+        if (!S) {
+          i.push({
+            fieldId: o,
+            userMessage: `Field '${o}' not found`,
+            systemMessage: `No field with ID '${o}' exists. Available field IDs are: ${Object.keys(e.fields.listStore.getState()).join(",")}.`,
+            value: u
+          });
+          return;
+        }
+        if (S.multiple && (typeof u == "string" || typeof u == "number" || typeof u == "boolean") && (u = [u]), S.validation && !Q(S.validation) && !N(u)) {
+          const y = await _(e, S.validation, {
+            $input: u
+          });
+          if (typeof y == "string") {
+            i.push({
+              fieldId: o,
+              userMessage: y,
+              systemMessage: `Field validation resulted in an error: ${y}.`,
+              value: u
+            });
+            return;
+          }
+          if (y === !1) {
+            i.push({
+              fieldId: o,
+              userMessage: "This field is invalid",
+              systemMessage: "Field validation resulted in an unspecified error.",
+              value: u
+            });
+            return;
+          }
+        }
+        if (S.required && N(u)) {
+          i.push({
+            fieldId: o,
+            userMessage: "This field is required",
+            systemMessage: "Field is required.",
+            value: u
+          });
+          return;
+        }
+        if (!S.multiple && Array.isArray(u) && u.length > 1) {
+          i.push({
+            fieldId: o,
+            userMessage: "This field expects a single response",
+            systemMessage: "Field expects a single response.",
+            value: u
+          });
+          return;
+        }
+        if (S.options) {
+          const y = S.options.map((x) => x.value), R = Array.isArray(u) ? u : [u];
+          Array.isArray(u) && (R.every((x) => y.includes(x)) || i.push({
+            fieldId: o,
+            userMessage: "This field expects a valid option",
+            systemMessage: `Field expects a valid option. Valid options are: ${y.join(", ")}`,
+            value: u
+          }));
+        }
+      })
+    ), { responsesToCommit: s, validationErrors: i };
+  }
+  async function n(s) {
+    const { responsesToCommit: i, validationErrors: o } = await r(s);
+    return o.length ? { errors: o } : (p.registerBatch(i), { errors: [] });
+  }
+  const c = t.map((s) => s), g = t.map((s) => Object.keys(s).map((o) => ({
+    fieldId: o,
+    value: s[o]
+  })));
+  function m(s) {
+    const i = e.fields.getById(s), o = t.map((d) => d[s] || null);
+    return A({ f: i, r: o }, ({ f: d, r: u }) => u || (d != null && d.defaultValue ? d.defaultValue : null));
+  }
+  function F(s) {
+    const i = e.fields.getByName(s);
+    return A({ f: i, s: t }, ({ f: o, s: d }) => {
+      const u = o && d[o.id] || null;
+      return u || (o != null && o.defaultValue ? o.defaultValue : null);
+    });
+  }
+  return w({
+    clock: a,
+    target: p.clearAll
+  }), w({
+    clock: l,
+    target: p.clear
+  }), {
+    register: f,
+    clearAll: a,
+    clear: l,
+    commit: n,
+    getResponsesToCommit: r,
+    listStore: g,
+    getAllStore: c,
+    getByFieldId: m,
+    getByFieldName: F
+  };
+});
+function Xe(e) {
+  return k(be, e);
+}
+function Fe() {
+  if (X())
+    return crypto.randomUUID();
+  const e = Date.now().toString(36), t = Math.random().toString(36).substring(2, 15), a = Math.random().toString(36).substring(2, 15), l = Math.random().toString(36).substring(2, 15);
+  return `${e}-${t}-${a}-${l}`;
+}
+const xe = () => ({
+  id: Fe()
+}), Ie = D("session", "global"), Ee = () => {
+  if (!W()) return null;
+  const e = j.get(Ie);
+  let t = e.isSet() ? e.json() : null;
+  return t || (t = xe(), e.set(t)), t;
+}, Ze = () => Ee();
+export {
+  Ne as a,
+  Me as b,
+  Ye as c,
+  Le as d,
+  He as e,
+  ze as f,
+  Xe as g,
+  Je as h,
+  Qe as i,
+  Ze as j,
+  Ce as k,
+  Ge as l,
+  qe as m,
+  Ke as n,
+  We as o,
+  Ue as p,
+  Pe as q,
+  ge as r,
+  _e as s,
+  re as t,
+  Te as u
+};