@picked/client 0.0.1-dev.1773807602703 → 0.0.1-dev.1774224866171

package/dist/esm/plugins/responses-indexeddb/index.js

@@ -1,86 +1,83 @@
-import { createEffect as u, sample as d } from "effector";
-const x = "picked";
-async function p(r) {
-  const { storeName: o, version: c = 1, keyPath: n = "id" } = r;
-  return new Promise((a, t) => {
-    const e = indexedDB.open(x, c);
-    e.onupgradeneeded = () => {
-      const s = e.result;
-      s.objectStoreNames.contains(o) || s.createObjectStore(o, n ? { keyPath: n } : void 0);
-    }, e.onsuccess = () => a(e.result), e.onerror = () => t(new Error(e.error?.message));
-  });
+import { createEffect as e, sample as t } from "effector";
+//#region src/utils/indexed-db.ts
+var n = "picked";
+async function r(e) {
+	let { storeName: t, version: r = 1, keyPath: i = "id" } = e;
+	return new Promise((e, a) => {
+		let o = indexedDB.open(n, r);
+		o.onupgradeneeded = () => {
+			let e = o.result;
+			e.objectStoreNames.contains(t) || e.createObjectStore(t, i ? { keyPath: i } : void 0);
+		}, o.onsuccess = () => e(o.result), o.onerror = () => a(Error(o.error?.message));
+	});
 }
-async function g(r, o) {
-  return new Promise((c, n) => {
-    const e = r.transaction(o, "readonly").objectStore(o).getAll();
-    e.onsuccess = () => c(e.result), e.onerror = () => n(new Error(e.error?.message));
-  });
+async function i(e, t) {
+	return new Promise((n, r) => {
+		let i = e.transaction(t, "readonly").objectStore(t).getAll();
+		i.onsuccess = () => n(i.result), i.onerror = () => r(Error(i.error?.message));
+	});
 }
-async function y(r, o, c) {
-  return new Promise((n, a) => {
-    const s = r.transaction(o, "readwrite").objectStore(o).put(c);
-    s.onsuccess = () => n(), s.onerror = () => a(new Error(s.error?.message));
-  });
+async function a(e, t, n) {
+	return new Promise((r, i) => {
+		let a = e.transaction(t, "readwrite").objectStore(t).put(n);
+		a.onsuccess = () => r(), a.onerror = () => i(Error(a.error?.message));
+	});
 }
-async function b(r, o, c) {
-  return new Promise((n, a) => {
-    const s = r.transaction(o, "readwrite").objectStore(o).delete(c);
-    s.onsuccess = () => n(), s.onerror = () => a(new Error(s.error?.message));
-  });
+async function o(e, t, n) {
+	return new Promise((r, i) => {
+		let a = e.transaction(t, "readwrite").objectStore(t).delete(n);
+		a.onsuccess = () => r(), a.onerror = () => i(Error(a.error?.message));
+	});
 }
-async function S(r, o) {
-  return new Promise((c, n) => {
-    const e = r.transaction(o, "readwrite").objectStore(o).clear();
-    e.onsuccess = () => c(), e.onerror = () => n(new Error(e.error?.message));
-  });
+async function s(e, t) {
+	return new Promise((n, r) => {
+		let i = e.transaction(t, "readwrite").objectStore(t).clear();
+		i.onsuccess = () => n(), i.onerror = () => r(Error(i.error?.message));
+	});
 }
-const l = "responses", m = { storeName: l, keyPath: "fieldId" }, I = () => ({
-  name: "responses-indexdb-plugin",
-  setup: (r) => {
-    const o = u(async () => {
-      const t = await p(m), s = (await g(t, l)).reduce(
-        (i, { fieldId: w, value: f }) => (i[w] = f, i),
-        {}
-      );
-      await r.responses.commit(s);
-    }), c = u(
-      async (t) => {
-        t.forEach((e) => {
-          p(m).then((s) => {
-            y(s, l, e);
-          }).catch((s) => {
-            console.error("Failed to store response in IndexedDB:", s);
-          });
-        });
-      }
-    ), n = u(async () => {
-      const t = await p(m);
-      await S(t, l);
-    }), a = u(async (t) => {
-      const e = await p(m);
-      await b(e, l, t);
-    });
-    d({
-      source: r.eventBus,
-      filter: (t) => t.type === "load",
-      target: o
-    }), d({
-      clock: r.responses.listStore,
-      source: { responses: r.responses.listStore, fields: r.fields.listStore },
-      fn: ({ responses: t, fields: e }) => {
-        const s = e.filter((i) => !i.policies?.doNotStoreValue);
-        return t.filter((i) => s.some((w) => w.id === i.fieldId));
-      },
-      target: c
-    }), d({
-      clock: r.responses.clearAll,
-      target: n
-    }), d({
-      clock: r.responses.clear,
-      target: a
-    });
-  }
+//#endregion
+//#region src/plugins/responses-indexeddb/plugin.ts
+var c = "responses", l = {
+	storeName: c,
+	keyPath: "fieldId"
+}, u = () => ({
+	name: "responses-indexdb-plugin",
+	setup: (n) => {
+		let u = e(async () => {
+			let e = (await i(await r(l), c)).reduce((e, { fieldId: t, value: n }) => (e[t] = n, e), {});
+			await n.responses.commit(e);
+		}), d = e(async (e) => {
+			await Promise.allSettled(e.map(async (e) => {
+				await a(await r(l), c, e);
+			}));
+		}), f = e(async () => {
+			await s(await r(l), c);
+		}), p = e(async (e) => {
+			await o(await r(l), c, e);
+		});
+		t({
+			source: n.eventBus,
+			filter: (e) => e.type === "load",
+			target: u
+		}), t({
+			clock: n.responses.listStore,
+			source: {
+				responses: n.responses.listStore,
+				fields: n.fields.listStore
+			},
+			fn: ({ responses: e, fields: t }) => {
+				let n = new Set(t.filter((e) => !e.policies?.doNotStoreValue).map((e) => e.id));
+				return e.filter((e) => n.has(e.fieldId));
+			},
+			target: d
+		}), t({
+			clock: n.responses.clearAll,
+			target: f
+		}), t({
+			clock: n.responses.clear,
+			target: p
+		});
+	}
 });
-export {
-  I as responsesIndexedDBPlugin
-};
+//#endregion
+export { u as responsesIndexedDBPlugin };

package/dist/esm/plugins/single-page-app/index.js

@@ -1,37 +1,33 @@
-import { a as f, G as c, f as m } from "../../../supports-8YT4QKI7.js";
-import { p as a } from "../../../object-JwZ58NOH.js";
-const o = c;
-let s;
-const d = (r) => ({
-  name: "single-page-app",
-  setup: (n) => {
-    r.instrumentHistory && f() && h(() => {
-      requestAnimationFrame(() => {
-        n.start();
-      });
-    });
-  }
+import { n as e } from "../../../object-C82v79xc.js";
+import { d as t, f as n, i as r } from "../../../supports-0XIfd4-R.js";
+//#region src/plugins/single-page-app/plugin.ts
+var i = n, a, o = (e) => ({
+	name: "single-page-app",
+	setup: (e) => {
+		t() && s(() => {
+			requestAnimationFrame(() => {
+				e.start();
+			});
+		});
+	}
 });
-function h(r) {
-  if (o.addEventListener("popstate", () => {
-    const e = o.location.href, t = s;
-    s = e, t !== e && r();
-  }), !m())
-    return;
-  function n(e) {
-    return function(...t) {
-      const i = t.length > 2 ? t[2] : void 0;
-      if (i) {
-        const u = s, p = String(i);
-        if (s = p, u === p)
-          return e.apply(this, t);
-        r();
-      }
-      return e.apply(this, t);
-    };
-  }
-  a(o.history, "pushState", n), a(o.history, "replaceState", n);
+function s(t) {
+	if (i.addEventListener("popstate", () => {
+		let e = i.location.href, n = a;
+		a = e, n !== e && t();
+	}), !r()) return;
+	function n(e) {
+		return function(...n) {
+			let r = n.length > 2 ? n[2] : void 0;
+			if (r) {
+				let i = a, o = String(r);
+				if (a = o, i === o) return e.apply(this, n);
+				t();
+			}
+			return e.apply(this, n);
+		};
+	}
+	e(i.history, "pushState", n), e(i.history, "replaceState", n);
 }
-export {
-  d as singlePageAppPlugin
-};
+//#endregion
+export { o as singlePageAppPlugin };

package/dist/esm/plugins/web-components/index.js

@@ -1,21 +1,19 @@
-import { a as o, k as i } from "../../../supports-8YT4QKI7.js";
-const p = () => ({
-  name: "web-components",
-  setup: (e) => {
-    if (!o() || !i())
-      return;
-    const n = "picked-root";
-    if (window.customElements.get(n))
-      return;
-    class s extends HTMLElement {
-      connectedCallback() {
-        const t = this.getAttribute("experience-id");
-        e.isReady && t && e.experiences.launch({ id: t });
-      }
-    }
-    window.customElements.define(n, s);
-  }
+import { d as e, u as t } from "../../../supports-0XIfd4-R.js";
+//#region src/plugins/web-components/plugin.ts
+var n = () => ({
+	name: "web-components",
+	setup: (n) => {
+		if (!e() || !t()) return;
+		let r = "picked-root";
+		if (window.customElements.get(r)) return;
+		class i extends HTMLElement {
+			connectedCallback() {
+				let e = this.getAttribute("experience-id");
+				n.isReady && e && n.experiences.launch({ id: e });
+			}
+		}
+		window.customElements.define(r, i);
+	}
 });
-export {
-  p as webComponentsPlugin
-};
+//#endregion
+export { n as webComponentsPlugin };

package/dist/esm/plugins/window-object/index.js

@@ -1,10 +1,10 @@
-import { a as i } from "../../../supports-8YT4QKI7.js";
-const t = () => ({
-  name: "window",
-  setup: (o) => {
-    i() && (window.Picked = o);
-  }
+import { d as e } from "../../../supports-0XIfd4-R.js";
+//#region src/plugins/window-object/plugin.ts
+var t = () => ({
+	name: "window",
+	setup: (t) => {
+		e() && (window.Picked = t);
+	}
 });
-export {
-  t as windowObjectPlugin
-};
+//#endregion
+export { t as windowObjectPlugin };

package/dist/esm/server/index.js

@@ -1,91 +1,97 @@
-import { createEvent as i, createStore as C, createEffect as S, sample as n, attach as h } from "effector";
-import { f as F } from "../../experience-instance-DCknHRkX.js";
-function R() {
-  let c, p;
-  return {
-    promise: new Promise((t, o) => {
-      c = t, p = o;
-    }),
-    resolve: (t) => c(t),
-    reject: (t) => p(t)
-  };
+import { t as e } from "../../experience-instance-DZiAwXph.js";
+import { attach as t, createEffect as n, createEvent as r, createStore as i, sample as a } from "effector";
+//#region src/server/index.ts
+function o() {
+	let e, t;
+	return {
+		promise: new Promise((n, r) => {
+			e = n, t = r;
+		}),
+		resolve: (t) => e(t),
+		reject: (e) => t(e)
+	};
 }
-function w(c, p) {
-  const { promise: E, resolve: t } = R(), o = i(), s = i(), l = i(), u = i(), d = i(), g = c.experiences.listStore.map((e) => e.map((r) => F({ client: c, experience: r }))), x = C({
-    currentExperienceIndex: 0,
-    renderedExperiences: [],
-    isComplete: !1
-  }), m = S(
-    async ({
-      experience: e,
-      availableRenderers: r,
-      startRendererIndex: v = 0
-    }) => {
-      if (!e)
-        return null;
-      for (let a = v; a < r.length; a++) {
-        const I = r[a], f = e.componentStore.getState();
-        if (f && I?.isValidComponent(f.component))
-          return { rendered: await I.render(f.component, c, e), rendererIndex: a };
-      }
-      return null;
-    }
-  );
-  x.on(l, (e, r) => ({
-    ...e,
-    renderedExperiences: [...e.renderedExperiences, r],
-    currentExperienceIndex: e.currentExperienceIndex + 1
-  })).on(d, (e) => ({
-    ...e,
-    currentExperienceIndex: e.currentExperienceIndex + 1
-  })).on(u, (e) => ({
-    ...e,
-    isComplete: !0
-  })).reset(o), n({
-    clock: o,
-    target: s
-  }), n({
-    clock: s,
-    source: { experiences: g, state: x },
-    filter: ({ experiences: e, state: r }) => r.currentExperienceIndex < e.length && !r.isComplete,
-    fn: ({ experiences: e, state: r }) => ({
-      experience: e[r.currentExperienceIndex],
-      availableRenderers: p,
-      startRendererIndex: 0
-    }),
-    target: m
-  }), n({
-    clock: m.doneData,
-    filter: (e) => e !== null,
-    fn: (e) => e.rendered.body,
-    target: l
-  }), n({
-    clock: l,
-    target: s
-  }), n({
-    clock: m.doneData,
-    filter: (e) => e === null,
-    target: d
-  }), n({
-    clock: d,
-    target: s
-  }), n({
-    clock: [s, d, l],
-    source: { experiences: g, state: x },
-    filter: ({ experiences: e, state: r }) => r.currentExperienceIndex >= e.length,
-    target: u
-  });
-  const k = h({
-    source: x,
-    effect: (e) => {
-      e.isComplete && t(e.renderedExperiences);
-    }
-  });
-  return n({
-    clock: u,
-    target: k
-  }), o(), E;
+function s(s, c) {
+	let { promise: l, resolve: u } = o(), d = r(), f = r(), p = r(), m = r(), h = r(), g = s.experiences.listStore.map((t) => t.map((t) => e({
+		client: s,
+		experience: t
+	}))), _ = i({
+		currentExperienceIndex: 0,
+		renderedExperiences: [],
+		isComplete: !1
+	}), v = n(async ({ experience: e, availableRenderers: t, startRendererIndex: n = 0 }) => {
+		if (!e) return null;
+		for (let r = n; r < t.length; r++) {
+			let n = t[r], i = e.componentStore.getState();
+			if (i && n?.isValidComponent(i.component)) return {
+				rendered: await n.render(i.component, s, e),
+				rendererIndex: r
+			};
+		}
+		return null;
+	});
+	return _.on(p, (e, t) => ({
+		...e,
+		renderedExperiences: [...e.renderedExperiences, t],
+		currentExperienceIndex: e.currentExperienceIndex + 1
+	})).on(h, (e) => ({
+		...e,
+		currentExperienceIndex: e.currentExperienceIndex + 1
+	})).on(m, (e) => ({
+		...e,
+		isComplete: !0
+	})).reset(d), a({
+		clock: d,
+		target: f
+	}), a({
+		clock: f,
+		source: {
+			experiences: g,
+			state: _
+		},
+		filter: ({ experiences: e, state: t }) => t.currentExperienceIndex < e.length && !t.isComplete,
+		fn: ({ experiences: e, state: t }) => ({
+			experience: e[t.currentExperienceIndex],
+			availableRenderers: c,
+			startRendererIndex: 0
+		}),
+		target: v
+	}), a({
+		clock: v.doneData,
+		filter: (e) => e !== null,
+		fn: (e) => e.rendered.body,
+		target: p
+	}), a({
+		clock: p,
+		target: f
+	}), a({
+		clock: v.doneData,
+		filter: (e) => e === null,
+		target: h
+	}), a({
+		clock: h,
+		target: f
+	}), a({
+		clock: [
+			f,
+			h,
+			p
+		],
+		source: {
+			experiences: g,
+			state: _
+		},
+		filter: ({ experiences: e, state: t }) => t.currentExperienceIndex >= e.length,
+		target: m
+	}), a({
+		clock: m,
+		target: t({
+			source: _,
+			effect: (e) => {
+				e.isComplete && u(e.renderedExperiences);
+			}
+		})
+	}), d(), l;
 }
-export {
-  w as render
-};
+//#endregion
+export { s as render };