@picked/client 0.0.12-next.13 → 0.0.12-next.2

package/dist/experience-instance-BBz99AXU.js

@@ -0,0 +1,766 @@
+import { createDomain as pt, createEvent as _, attach as F, combine as C, createApi as et, sample as y, createEffect as O, split as gt } from "effector";
+import { createFactory as nt, invoke as rt } from "@withease/factories";
+import { i as mt, s as ot, a as St } from "./supports-BjhuLJ8z.js";
+import { l as x } from "./logger-C9a75KZn.js";
+import { i as ht } from "./object-JwZ58NOH.js";
+function yt(t) {
+  return typeof t == "number" && !isNaN(t);
+}
+function H(t) {
+  return typeof t == "string";
+}
+function I(t) {
+  return Array.isArray(t);
+}
+function it(t) {
+  return t instanceof Promise;
+}
+function Y(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t) && Object.keys(t).length === 1;
+}
+function g(t) {
+  if (yt(t)) return t;
+  const e = parseFloat(`${t}`);
+  return isNaN(e) ? 0 : e;
+}
+function D(t) {
+  return `${t}`;
+}
+const wt = {
+  // eslint-disable-next-line eqeqeq
+  "==": (t, e) => t == e,
+  "===": (t, e) => t === e,
+  // eslint-disable-next-line eqeqeq
+  "!=": (t, e) => t != e,
+  "!==": (t, e) => t !== e,
+  ">": (t, e) => g(t) > g(e),
+  ">=": (t, e) => g(t) >= g(e),
+  "<": (t, e, r) => {
+    const n = g(t), s = g(e);
+    if (r === void 0) return n < s;
+    const c = g(r);
+    return n < s && s < c;
+  },
+  "<=": (t, e, r) => {
+    const n = g(t), s = g(e);
+    if (r === void 0) return n <= s;
+    const c = g(r);
+    return n <= s && s <= c;
+  },
+  "!!": async (t) => await $(t),
+  "!": async (t) => !await $(t),
+  "%": (t, e) => g(t) % g(e),
+  // eslint-disable-next-line sonarjs/function-return-type
+  log: (t) => (console.log(t), t),
+  in: (t, e) => e ? H(e) ? e.indexOf(D(t)) !== -1 : I(e) ? e.includes(t) : !1 : !1,
+  cat: (...t) => t.map(D).join(""),
+  /* eslint-disable sonarjs/deprecation */
+  substr: (t, e, r) => {
+    const n = D(t), s = g(e);
+    if (r === void 0) return n.substr(s);
+    const c = g(r);
+    if (c < 0) {
+      const o = n.substr(s);
+      return o.substr(0, o.length + c);
+    }
+    return n.substr(s, c);
+  },
+  /* eslint-enable sonarjs/deprecation */
+  "+": (...t) => t.reduce((e, r) => g(e) + g(r), 0),
+  "*": (...t) => t.reduce((e, r) => g(e) * g(r), 1),
+  "-": (t, e) => {
+    const r = g(t);
+    return e === void 0 ? -r : r - g(e);
+  },
+  "/": (t, e) => g(t) / g(e),
+  min: (...t) => Math.min(...t.map(g)),
+  max: (...t) => Math.max(...t.map(g)),
+  merge: (...t) => t.reduce((e, r) => I(r) ? e.concat(r) : e.concat([r]), []),
+  var(t, e) {
+    const r = arguments.length > 1 ? e : null;
+    if (t === "" || t === "." || t === null || t === void 0)
+      return this;
+    if (typeof t == "number" && Array.isArray(this))
+      return t >= 0 && t < this.length ? this[t] : r;
+    const n = D(t);
+    if (n === "" || n === ".")
+      return this;
+    const s = n.split(".");
+    let c = this;
+    for (const o of s) {
+      if (c == null)
+        return r;
+      if (Array.isArray(c)) {
+        const a = parseInt(o, 10);
+        isNaN(a) ? c = c[o] : c = c[a];
+      } else
+        c = c[o];
+    }
+    return c !== void 0 ? c : r;
+  },
+  async missing(...t) {
+    const e = I(t[0]) ? t[0] : t, r = [];
+    for (const n of e) {
+      const s = await p({ var: n }, this);
+      (s === null || s === "") && r.push(`${n}`);
+    }
+    return r;
+  },
+  async missing_some(t, e) {
+    const r = await p({ missing: e }, this);
+    if (!I(r) || !I(e)) return [];
+    const n = r.filter(H);
+    return e.filter(H).length - n.length >= g(t) ? [] : n;
+  },
+  // eslint-disable-next-line sonarjs/function-return-type
+  invoke(t) {
+    return typeof t != "function" ? null : t();
+  },
+  regexp_matches(t, e) {
+    let r = t, n = "";
+    if (I(t)) {
+      const [c, o] = t;
+      r = c, n = o;
+    }
+    return !H(r) || !H(n) ? !1 : new RegExp(r, n).test(D(e));
+  },
+  throw(t) {
+    throw new Error(D(t));
+  }
+};
+async function p(t, e) {
+  if (!t) return t;
+  if (it(t))
+    return p(await t, e);
+  if (I(t))
+    return Promise.all(t.map((o) => p(o, e)));
+  if (!Y(t)) return t;
+  const r = Nt(t);
+  let n = r ? t[r] ?? [] : [];
+  switch (I(n) || (n = [n]), r) {
+    case "if":
+    case "?:":
+      for (let o = 0; o < n.length - 1; o += 2)
+        if (await $(await p(n[o], e)))
+          return p(n[o + 1], e);
+      return n.length % 2 === 1 ? p(n[n.length - 1], e) : null;
+    case "and": {
+      let o = null;
+      for (const a of n)
+        if (o = await p(a, e), !await $(o))
+          return o;
+      return o;
+    }
+    case "or": {
+      let o = null;
+      for (const a of n)
+        if (o = await p(a, e), await $(o)) return o;
+      return o;
+    }
+    case "map": {
+      const o = await p(n[0], e);
+      return I(o) ? await Promise.all(o.map((a) => p(n[1], a))) : [];
+    }
+    case "filter": {
+      const o = await p(n[0], e);
+      return I(o) ? (await Promise.all(
+        o.map(async (l) => {
+          const h = await $(await p(n[1], l));
+          return { item: l, shouldInclude: h };
+        })
+      )).filter(({ shouldInclude: l }) => l).map(({ item: l }) => l) : [];
+    }
+    case "reduce": {
+      const o = await p(n[0], e);
+      if (!I(o))
+        return n.length > 2 ? await p(n[2], e) : null;
+      const a = n[1];
+      let h = n.length > 2 ? await p(n[2], e) : null;
+      for (const A of o)
+        h = await p(a, { current: A, accumulator: h });
+      return h;
+    }
+    case "all": {
+      const o = await p(n[0], e);
+      if (!I(o) || o.length === 0) return !1;
+      for (const a of o)
+        if (!await $(await p(n[1], a))) return !1;
+      return !0;
+    }
+    case "some": {
+      const o = await p(n[0], e);
+      if (!I(o)) return !1;
+      for (const a of o)
+        if (await $(await p(n[1], a))) return !0;
+      return !1;
+    }
+    case "none": {
+      const o = await p(n[0], e);
+      if (!I(o)) return !0;
+      for (const a of o)
+        if (await $(await p(n[1], a))) return !1;
+      return !0;
+    }
+    case "catch":
+      try {
+        return await p(n[0], e);
+      } catch (o) {
+        return Y(o) ? await p(o, e) : n[1] ? await p(n[1], o) : o instanceof Error ? o.message : o;
+      }
+  }
+  const s = await Promise.all(n.map((o) => p(o, e))), c = r ? wt[r] : void 0;
+  if (!c) throw new Error(`Unrecognized operation ${r}`);
+  return c.apply(e, s);
+}
+async function $(t) {
+  return it(t) ? $(await t) : !(Array.isArray(t) && t.length === 0) && !!t;
+}
+function Nt(t) {
+  return Object.keys(t)[0];
+}
+function Ut(t) {
+  return !ht(t);
+}
+async function It(t, e, r) {
+  const n = t.getStateSnapshot(), s = t.predicates.listStore.getState().reduce((a, l) => ({
+    ...a,
+    [l.name]: () => l.predicate(n)
+  }), {}), c = t.features.listStore.getState().reduce((a, l) => ({
+    ...a,
+    [l.id]: async () => {
+      const { bucket: h } = await l.getBucket();
+      return h;
+    }
+  }), {}), o = {
+    ...r,
+    responses: t.responses.getAllStore.getState(),
+    location: typeof n.location == "object" ? {
+      hash: n.location.hash,
+      host: n.location.host,
+      hostname: n.location.hostname,
+      href: n.location.href,
+      origin: n.location.origin,
+      pathname: n.location.pathname,
+      port: n.location.port,
+      protocol: n.location.protocol,
+      search: n.location.search
+    } : void 0,
+    predicates: s,
+    features: c
+  };
+  return await p(e, o);
+}
+function xt(t) {
+  return !St() || !ot() ? [] : Array.from(window.document.querySelectorAll(t)).filter(
+    (e) => e instanceof HTMLElement
+  );
+}
+function Et(t) {
+  if (!mt())
+    throw new Error("Shadow DOM is not supported in this environment");
+  return t.attachShadow({ mode: "closed" });
+}
+function Vt() {
+  return new Promise((t, e) => {
+    if (!ot()) {
+      e();
+      return;
+    }
+    document.readyState !== "loading" ? t() : document.addEventListener("readystatechange", () => t(), { once: !0 });
+  });
+}
+function kt(t, e) {
+  const r = new MutationObserver((n) => {
+    document.contains(t) || (r.disconnect(), e());
+  });
+  r.observe(document.body, { childList: !0, subtree: !0 });
+}
+const K = "picked-root", U = "picked-target", At = "picked-root";
+function Wt(t, e) {
+  return [
+    ...t,
+    // Target and replace picked-root web components
+    {
+      selector: `${At}[experience-id="${e}"]`,
+      placement: "replace"
+    }
+  ].flatMap((n) => {
+    const s = xt(n.selector).filter(
+      (c) => !bt(c, e) && !$t(c, e)
+    );
+    return {
+      ...n,
+      elements: s
+    };
+  });
+}
+function qt(t, e) {
+  return t.flatMap((r) => r.elements.map((n) => Bt(n, r.placement, e)));
+}
+function zt(t, e) {
+  t.classList.add(U), t.classList.add(`${U}-${e}`);
+}
+function bt(t, e) {
+  return e ? t.classList.contains(`${U}-${e}`) : t.classList.contains(`${U}`);
+}
+function $t(t, e) {
+  return e ? t.classList.contains(`${K}-${e}`) : t.classList.contains(K);
+}
+function vt(t) {
+  const e = document.createElement("div");
+  return e.style.display = "block", e.classList.add(K), e.classList.add(`${K}-${t}`), e;
+}
+function Bt(t, e, r) {
+  let n;
+  const s = vt(r);
+  if (t instanceof Document)
+    n = t.body.appendChild(s);
+  else {
+    switch (e) {
+      case "replace":
+        t.replaceWith(s);
+        break;
+      case "before":
+        t.before(s);
+        break;
+      case "after":
+        t.after(s);
+        break;
+      case "prepend":
+        t.prepend(s);
+        break;
+      default:
+        t.append(s);
+        break;
+    }
+    n = s;
+  }
+  return n;
+}
+function Ft(t) {
+  return t.type === "conditional";
+}
+function j(t) {
+  return t.type === "step";
+}
+function _t(t) {
+  return t.type === "experience";
+}
+function Z(t) {
+  return t.type === "origin";
+}
+function tt(t) {
+  return t.type === "action";
+}
+const st = (t, e, r, n, s = /* @__PURE__ */ new Set()) => s.has(r.id) ? [] : (s.add(r.id), j(r) && !n ? [r] : e.filter((o) => o.sourceNodeId === r.id).flatMap((o) => {
+  const a = t.find((l) => l.id === o.destinationNodeId);
+  return a ? st(t, e, a, !1, s) : [];
+})), Ot = (t, e, r) => st(t, e, r, !0, /* @__PURE__ */ new Set()), ct = (t, e, r, n, s = /* @__PURE__ */ new Set()) => {
+  if (s.has(r.id)) return [-1, -1];
+  s.add(r.id);
+  const c = e.filter((l) => l.sourceNodeId === r.id);
+  if (c.length === 0) return [0, 0];
+  let o = 1 / 0, a = -1 / 0;
+  for (const l of c) {
+    const h = t.find((L) => L.id === l.destinationNodeId);
+    if (!h) continue;
+    const [A, w] = ct(
+      t,
+      e,
+      h,
+      !1,
+      new Set(s)
+    );
+    A !== -1 && (o = Math.min(o, A + 1), a = Math.max(a, w + 1));
+  }
+  return o === 1 / 0 ? [-1, -1] : [o, a];
+}, Mt = (t, e, r) => ct(t, e, r, !0, /* @__PURE__ */ new Set()), at = (t, e, r, n = /* @__PURE__ */ new Set()) => {
+  if (n.has(r.id)) return [-1, -1];
+  if (n.add(r.id), r.type === "origin") return [0, 0];
+  const s = e.filter((a) => a.destinationNodeId === r.id);
+  if (s.length === 0) return [-1, -1];
+  let c = 1 / 0, o = -1 / 0;
+  for (const a of s) {
+    const l = t.find((w) => w.id === a.sourceNodeId);
+    if (!l) continue;
+    const [h, A] = at(
+      t,
+      e,
+      l,
+      new Set(n)
+    );
+    h !== -1 && (c = Math.min(c, h + 1), o = Math.max(o, A + 1));
+  }
+  return c === 1 / 0 ? [-1, -1] : [c, o];
+}, Lt = (t, e, r) => at(t, e, r, /* @__PURE__ */ new Set()), ut = (t) => t.find((r) => r.type === "origin") || null, z = (t, e, r) => {
+  if (!t)
+    return ut(e);
+  const n = r.find((c) => c.sourceNodeId === t.id);
+  if (!n)
+    return null;
+  const s = e.find((c) => c.id === n.destinationNodeId);
+  return s || null;
+};
+async function Tt(t, e, r, n) {
+  const s = t ? "true" : "false", c = n.find(
+    (o) => o.sourceNodeHandle === s && o.sourceNodeId === e
+  );
+  return r.find((o) => o.id === (c == null ? void 0 : c.destinationNodeId));
+}
+const X = pt("experience-instance"), Dt = nt(
+  ({
+    client: t,
+    experience: e,
+    target: r
+  }) => {
+    const n = _(), s = _(), c = _(), o = _(), a = e.componentStore, l = X.store("transitioning"), h = t.history.entriesStore.map((i) => i.filter((u) => u.experienceId === e.id)), A = h.map((i) => i.filter((u) => j(u.node))), w = h.map((i) => {
+      var u;
+      return ((u = i[i.length - 1]) == null ? void 0 : u.node) || null;
+    }), L = F({
+      source: e.treeStore,
+      effect: async ({ nodes: i, edges: u }, f) => {
+        if (!f || !tt(f))
+          return;
+        const N = f.action;
+        if (!N) {
+          x("warn", `Action node ${f.id} has no action name`);
+          return;
+        }
+        const T = t.actions.getByName(N).getState();
+        if (!T) {
+          x("warn", `Action '${N}' not registered on client`);
+          const E = u.find(
+            (S) => S.sourceNodeId === f.id && S.sourceNodeHandle === "false"
+          );
+          return E ? i.find((S) => S.id === E.destinationNodeId) : null;
+        }
+        if (typeof T.action != "function") {
+          x("warn", `Action '${N}' is not a function`);
+          const E = u.find(
+            (S) => S.sourceNodeId === f.id && S.sourceNodeHandle === "false"
+          );
+          return E ? i.find((S) => S.id === E.destinationNodeId) : null;
+        }
+        try {
+          x("info", `Executing action: ${N}`), await T.action();
+          const E = u.find(
+            (k) => k.sourceNodeId === f.id && k.sourceNodeHandle === "true"
+          );
+          if (!E)
+            return x("warn", `No 'true' edge found for action node ${f.id}`), null;
+          const S = i.find((k) => k.id === E.destinationNodeId);
+          return x("info", `Action '${N}' succeeded, moving to node ${S == null ? void 0 : S.id}`), S || null;
+        } catch (E) {
+          x("warn", `Action '${N}' failed:`, E);
+          const S = u.find(
+            (G) => G.sourceNodeId === f.id && G.sourceNodeHandle === "false"
+          );
+          if (!S)
+            return x("warn", `No 'false' edge found for action node ${f.id}`), null;
+          const k = i.find((G) => G.id === S.destinationNodeId);
+          return x("info", `Action '${N}' failed, moving to node ${k == null ? void 0 : k.id}`), k || null;
+        }
+      }
+    }), M = C(
+      e.treeStore,
+      w,
+      ({ steps: i }, u) => i.find((f) => u && j(u) && f.id === u.stepId) || null
+    ), d = C(
+      e.treeStore,
+      w,
+      ({ nodes: i, edges: u }, f) => f ? Ot(i, u, f) : []
+    ), m = C(
+      e.treeStore,
+      w,
+      ({ nodes: i, edges: u }, f) => f ? Lt(i, u, f) : [-1, -1]
+    ), b = C(
+      e.treeStore,
+      w,
+      ({ nodes: i, edges: u }, f) => f ? Mt(i, u, f) : [-1, -1]
+    ), v = X.store(!0), B = et(v, {
+      open: () => !0,
+      close: () => !1,
+      toggle: (i) => !i,
+      set: (i, u) => u
+    });
+    y({
+      source: v,
+      filter: Boolean,
+      target: t.eventBus.prepend(() => ({
+        type: "experience_open",
+        experience: e
+      }))
+    }), y({
+      source: v,
+      filter: (i) => !i,
+      target: t.eventBus.prepend(() => ({
+        type: "experience_close",
+        experience: e
+      }))
+    });
+    const P = O(async () => {
+      t.history.back({ experienceId: e.id });
+    }), ft = F({
+      source: e.treeStore,
+      effect: async (i, u) => {
+        const f = i.nodes.find((N) => j(N) && N.stepId === u);
+        f && t.history.push({ experienceId: e.id, node: f });
+      }
+    }), J = F({
+      source: w,
+      effect: (i) => {
+      }
+    }), V = F({
+      source: e.treeStore,
+      effect: async ({ nodes: i }) => ut(i)
+    }), W = F({
+      source: e.treeStore,
+      effect: async ({ nodes: i, edges: u }, f) => z(f, i, u)
+    }), q = F({
+      source: e.treeStore,
+      effect: async ({ nodes: i, edges: u, conditionals: f }, N) => {
+        if (!N)
+          return;
+        const T = f.find((k) => k.id === N.conditionalId);
+        if (!T)
+          return;
+        const E = N.id, S = await It(t, T.condition);
+        return Tt(!!S, E, i, u);
+      }
+    }), lt = O((i) => {
+      if (i)
+        return t.launchExperienceById(i.experienceId);
+    }), Q = F({
+      source: [w, e.treeStore],
+      effect: async ([i, { nodes: u, edges: f }]) => z(i, u, f)
+    }), R = F({
+      source: [w, e.treeStore],
+      effect: async ([i, { nodes: u, edges: f }]) => z(i, u, f)
+    }), dt = O((i) => {
+      t.history.push({ experienceId: e.id, node: i });
+    });
+    return gt({
+      source: w,
+      match: (i) => i ? Ft(i) ? "condition" : j(i) ? "step" : _t(i) ? "launchExperience" : Z(i) ? "origin" : tt(i) ? "action" : "other" : "none",
+      cases: {
+        none: V,
+        origin: W,
+        condition: q,
+        step: J,
+        launchExperience: lt,
+        action: L,
+        __: _()
+      }
+    }), y({
+      clock: [
+        q.doneData,
+        W.doneData,
+        V.doneData,
+        R.doneData,
+        Q.doneData,
+        L.doneData
+      ],
+      filter: Boolean,
+      target: dt
+    }), y({
+      clock: s,
+      target: R
+    }), y({
+      clock: s,
+      source: M,
+      filter: Boolean,
+      target: t.eventBus.prepend((i) => ({
+        type: "step_submit",
+        step: i,
+        experience: e
+      }))
+    }), y({
+      clock: R.done,
+      source: M,
+      filter: Boolean,
+      target: t.eventBus.prepend((i) => ({
+        type: "step_submit_success",
+        step: i,
+        experience: e
+      }))
+    }), y({
+      clock: R.fail,
+      source: M,
+      filter: Boolean,
+      target: t.eventBus.prepend((i) => ({
+        type: "step_submit_error",
+        step: i,
+        experience: e
+      }))
+    }), y({
+      clock: c,
+      target: P
+    }), y({ clock: o, target: ft }), y({
+      source: C([
+        q.pending,
+        W.pending,
+        V.pending,
+        R.pending
+      ]),
+      fn: (i) => i.some(Boolean) ? "transitioning" : "ready",
+      target: l
+    }), y({
+      clock: J.doneData,
+      source: M,
+      filter: Boolean,
+      target: t.eventBus.prepend((i) => ({
+        type: "step_enter",
+        step: i,
+        experience: e
+      }))
+    }), y({
+      source: w,
+      clock: n,
+      filter: (i) => i ? Z(i) : !0,
+      target: Q
+    }), n(), {
+      id: Math.random().toString(36).substring(7),
+      // config
+      experienceId: e.id,
+      configStore: e.configStore,
+      target: r,
+      componentStore: a,
+      // state
+      stateStore: l,
+      // open close
+      isOpenStore: v,
+      open: B.open,
+      close: B.close,
+      toggleOpen: B.toggle,
+      setOpen: B.set,
+      // nodes
+      treeStore: e.treeStore,
+      currentNodeStore: w,
+      currentStepStore: M,
+      nextReachableStepNodesStore: d,
+      stepsToOriginStore: m,
+      stepsToLeafStore: b,
+      // history
+      goToNextStep: s,
+      goToPreviousStep: c,
+      goToStepById: o,
+      stepsHistoryStore: A
+    };
+  }
+);
+function Pt(t) {
+  return rt(Dt, t);
+}
+const Rt = nt(({ client: t }) => {
+  const e = X.store({}), r = _(), n = _(), s = _(), c = et(e, {
+    register(d, m) {
+      const b = [
+        ...d[m.experienceId] ?? []
+      ];
+      return b.push(m), {
+        ...d,
+        [m.experienceId]: b
+      };
+    },
+    unregister(d, m) {
+      var B;
+      const b = m.experienceId, v = (B = d[b]) == null ? void 0 : B.filter(
+        (P) => P !== m
+      );
+      return {
+        ...d,
+        [b]: v ?? []
+      };
+    }
+  }), o = O(
+    ({ experience: d, target: m }) => Pt({ client: t, experience: d, target: m })
+  ), a = O((d) => {
+    c.register(d);
+  }), l = O(
+    (d) => {
+      d.target && kt(d.target, () => {
+        s(d);
+      });
+    }
+  ), h = O((d) => {
+    c.unregister(d);
+  }), A = O((d) => {
+    const m = d.componentStore.getState();
+    if (!m) {
+      x("warn", "No app component registered. Skipping init.");
+      return;
+    }
+    const b = m.frameworkStore.getState();
+    if (!b) {
+      x(
+        "error",
+        `No framework registered for component '${m.name}'. Skipping rendering.`
+      );
+      return;
+    }
+    const v = d.target;
+    if (!v) {
+      x(
+        "error",
+        `No target element registered for experience '${d.experienceId}'. Skipping rendering.`
+      );
+      return;
+    }
+    const B = Et(v);
+    try {
+      b.render(B, m.component, t, d);
+    } catch (P) {
+      x("error", P);
+    }
+  });
+  y({
+    clock: r,
+    target: o
+  }), y({
+    clock: s,
+    target: h
+  }), y({
+    clock: o.doneData,
+    target: [
+      a,
+      l,
+      n
+    ]
+  }), y({
+    clock: o.doneData,
+    target: t.eventBus.prepend((d) => ({
+      type: "experience_initialized",
+      experienceInstance: d
+    }))
+  }), y({
+    clock: n,
+    target: A
+  });
+  function w(d, m) {
+    r({ experience: d, target: m });
+  }
+  const L = e.map((d) => Object.values(d).flat());
+  function M(d) {
+    return e.map((m) => m[d] || [], { skipVoid: !1 });
+  }
+  return {
+    spawn: w,
+    getByExperienceId: M,
+    listStore: L
+  };
+});
+function Xt(t) {
+  return rt(Rt, t);
+}
+export {
+  j as a,
+  Xt as b,
+  qt as c,
+  Vt as d,
+  It as e,
+  $t as f,
+  Wt as g,
+  Pt as h,
+  Ut as i,
+  zt as t
+};