@picked/client 0.0.11 → 0.0.12-next.10

package/dist/esm/plugins/create-experience/index.js

@@ -1,36 +1,74 @@
-import { g as f } from "../../../id-BW-g3y32.js";
-const r = {
-  serialize(e) {
-    return JSON.stringify(e);
+import { g as p } from "../../../id-BW-g3y32.js";
+const a = {
+  serialize(i) {
+    return JSON.stringify(i);
   },
-  deserialize(e) {
-    return JSON.parse(e);
+  deserialize(i) {
+    return JSON.parse(i);
   }
-}, b = (e) => ({
+}, x = (i) => ({
   name: "create-experience",
-  setup: (a) => {
-    e.experiences.forEach((o) => {
-      const s = o.serialize(), d = r.deserialize(s);
-      d.component = o.component, a.registerExperience(d), d.fields.forEach((h) => {
-        a.registerField(h);
+  setup: (d) => {
+    i.experiences.forEach((l) => {
+      const s = l.serialize(), o = a.deserialize(s);
+      o.component = l.component, d.registerExperience(o), o.fields.forEach((f) => {
+        d.registerField(f);
       });
     });
   }
-}), x = (e) => ({
-  id: e.id ?? f("step"),
-  label: e.label,
-  fields: e.fields ?? [],
-  addField(a) {
-    var s, d;
-    const o = "serialize" in a ? a : m(a);
-    return (s = this.fields) != null && s.includes(o) || (d = this.fields) == null || d.push(o), o;
+}), m = (i, d) => ({
+  id: p("node"),
+  position: [0, 0],
+  experience: d,
+  type: "action",
+  action: i.action,
+  addNext(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const o = c(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: null },
+      d
+    );
+    d.edges.push(o);
+  },
+  onSuccess(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const o = c(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: "true" },
+      d
+    );
+    d.edges.push(o);
+  },
+  onFail(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const o = c(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: "false" },
+      d
+    );
+    d.edges.push(o);
+  },
+  serialize() {
+    return a.serialize({
+      id: this.id,
+      type: this.type,
+      action: this.action,
+      position: this.position
+    });
+  }
+}), v = (i) => ({
+  id: i.id ?? p("step"),
+  label: i.label,
+  fields: i.fields ?? [],
+  addField(d) {
+    var s, o;
+    const l = "serialize" in d ? d : N(d);
+    return (s = this.fields) != null && s.includes(l) || (o = this.fields) == null || o.push(l), l;
   }
-}), y = (e, a) => {
-  const o = {
-    id: e.id ?? f("step"),
-    label: e.label,
-    experience: a,
-    fields: e.fields ?? [],
+}), g = (i, d) => {
+  const l = {
+    id: i.id ?? p("step"),
+    label: i.label,
+    experience: d,
+    fields: i.fields ?? [],
     node: null,
     nextStep(s) {
       return this.experience.addStep(s, this);
@@ -45,27 +83,27 @@ const r = {
       return this.experience.addField(s, this);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         label: this.label,
         fieldIds: this.fields.map((s) => s.id)
       });
     }
   };
-  return c({ step: o, type: "step" }, a), o;
-}, z = () => [0, 0], c = (e, a) => {
-  const o = {
-    id: f("node"),
-    position: z(),
-    experience: a
+  return h({ step: l, type: "step" }, d), l;
+}, y = () => [0, 0], h = (i, d) => {
+  const l = {
+    id: p("node"),
+    position: y(),
+    experience: d
   };
-  if (e.type === "step") {
-    const d = {
-      ...o,
+  if (i.type === "step") {
+    const o = {
+      ...l,
       type: "step",
-      connectedStep: e.step,
+      connectedStep: i.step,
       serialize() {
-        return r.serialize({
+        return a.serialize({
           id: this.id,
           type: this.type,
           stepId: this.connectedStep.id,
@@ -74,15 +112,15 @@ const r = {
         });
       }
     };
-    return d.connectedStep.node = d, d;
+    return o.connectedStep.node = o, o;
   }
-  if (e.type === "conditional") {
-    const d = {
-      ...o,
+  if (i.type === "conditional") {
+    const o = {
+      ...l,
       type: "conditional",
-      connectedConditional: e.conditional,
+      connectedConditional: i.conditional,
       serialize() {
-        return r.serialize({
+        return a.serialize({
           id: this.id,
           type: this.type,
           conditionalId: this.connectedConditional.id,
@@ -90,14 +128,14 @@ const r = {
         });
       }
     };
-    return d.connectedConditional.node = d, d;
+    return o.connectedConditional.node = o, o;
   }
-  return e.type === "experience" ? {
-    ...o,
+  return i.type === "experience" ? {
+    ...l,
     type: "experience",
-    connectedExperience: e.experience,
+    connectedExperience: i.experience,
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         type: this.type,
         experienceId: this.connectedExperience.id,
@@ -105,81 +143,81 @@ const r = {
       });
     }
   } : {
-    ...o,
+    ...l,
     type: "origin",
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         type: this.type,
         position: this.position
       });
     }
   };
-}, p = (e, a) => ({
-  id: f("edge"),
-  sourceNode: e.sourceNode,
-  sourceNodeHandle: e.sourceNodeHandle,
-  destinationNode: e.destinationNode,
-  experience: a,
+}, c = (i, d) => ({
+  id: p("edge"),
+  sourceNode: i.sourceNode,
+  sourceNodeHandle: i.sourceNodeHandle,
+  destinationNode: i.destinationNode,
+  experience: d,
   serialize() {
-    return r.serialize({
+    return a.serialize({
       id: this.id,
       sourceNodeHandle: this.sourceNodeHandle ?? void 0,
       sourceNodeId: this.sourceNode.id,
       destinationNodeId: this.destinationNode.id
     });
   }
-}), N = (e, a) => {
-  const o = {
-    id: f("conditional"),
-    condition: e.condition,
+}), z = (i, d) => {
+  const l = {
+    id: p("conditional"),
+    condition: i.condition,
     node: null,
-    experience: a,
+    experience: d,
     addTrue(s) {
       if (!this.node || !s.node)
         throw new Error("todo no node");
-      const d = p(
+      const o = c(
         { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "true" },
         this.experience
       );
-      this.experience.edges.push(d);
+      this.experience.edges.push(o);
     },
     addFalse(s) {
       if (!this.node || !s.node)
         throw new Error("todo no node");
-      const d = p(
+      const o = c(
         { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "false" },
         this.experience
       );
-      this.experience.edges.push(d);
+      this.experience.edges.push(o);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         condition: this.condition
       });
     }
   };
-  return c({ conditional: o, type: "conditional" }, a), o;
-}, m = (e) => {
-  var o;
+  return h({ conditional: l, type: "conditional" }, d), l;
+}, N = (i) => {
+  var l;
   return {
-    id: e.id,
-    name: e.name,
-    type: e.type,
-    label: e.label,
-    placeholder: e.placeholder,
-    description: e.description,
-    helpText: e.helpText,
-    defaultValue: e.defaultValue ?? null,
-    multiple: e.multiple,
-    validation: e.validation ?? {},
-    condition: e.condition,
-    required: e.required,
-    options: ((o = e.options) == null ? void 0 : o.map((s) => ({
+    id: i.id,
+    name: i.name,
+    type: i.type,
+    label: i.label,
+    placeholder: i.placeholder,
+    description: i.description,
+    helpText: i.helpText,
+    defaultValue: i.defaultValue ?? null,
+    multiple: i.multiple,
+    validation: i.validation ?? {},
+    condition: i.condition,
+    required: i.required,
+    options: ((l = i.options) == null ? void 0 : l.map((s) => ({
       ...s
     }))) ?? null,
-    policies: e.policies,
+    policies: i.policies,
     serialize() {
       const s = {
         id: this.id,
@@ -192,22 +230,22 @@ const r = {
         validation: this.validation,
         condition: this.condition,
         policies: this.policies
-      }, d = typeof this.defaultValue == "string" ? this.defaultValue : void 0, h = typeof this.defaultValue == "number" ? this.defaultValue : void 0, n = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
+      }, o = typeof this.defaultValue == "string" ? this.defaultValue : void 0, f = typeof this.defaultValue == "number" ? this.defaultValue : void 0, n = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
       switch (this.type) {
         case "text":
           if (this.multiple) {
-            let i;
+            let e;
             if (Array.isArray(this.defaultValue)) {
-              i = [];
+              e = [];
               for (const t of this.defaultValue)
-                typeof t == "string" && i.push(t);
-              i.length === 0 && (i = void 0);
+                typeof t == "string" && e.push(t);
+              e.length === 0 && (e = void 0);
             }
-            return r.serialize({
+            return a.serialize({
               ...s,
               type: "text",
               multiple: !0,
-              defaultValue: i,
+              defaultValue: e,
               options: this.options ? this.options.map((t) => ({
                 id: t.id,
                 label: t.label,
@@ -216,32 +254,32 @@ const r = {
               })) : null
             });
           }
-          return r.serialize({
+          return a.serialize({
             ...s,
             type: "text",
             multiple: !1,
-            defaultValue: d,
-            options: this.options ? this.options.map((i) => ({
-              id: i.id,
-              label: i.label,
-              value: `${i.value}`,
-              condition: i.condition
+            defaultValue: o,
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: `${e.value}`,
+              condition: e.condition
             })) : null
           });
         case "number":
           if (this.multiple) {
-            let i;
+            let e;
             if (Array.isArray(this.defaultValue)) {
-              i = [];
+              e = [];
               for (const t of this.defaultValue)
-                typeof t == "number" && i.push(t);
-              i.length === 0 && (i = void 0);
+                typeof t == "number" && e.push(t);
+              e.length === 0 && (e = void 0);
             }
-            return r.serialize({
+            return a.serialize({
               ...s,
               type: "number",
               multiple: !0,
-              defaultValue: i,
+              defaultValue: e,
               options: this.options ? this.options.map((t) => ({
                 id: t.id,
                 label: t.label,
@@ -250,32 +288,32 @@ const r = {
               })) : null
             });
           }
-          return r.serialize({
+          return a.serialize({
             ...s,
             type: "number",
             multiple: !1,
-            defaultValue: h,
-            options: this.options ? this.options.map((i) => ({
-              id: i.id,
-              label: i.label,
-              value: Number(i.value),
-              condition: i.condition
+            defaultValue: f,
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: Number(e.value),
+              condition: e.condition
             })) : null
           });
         case "boolean":
           if (this.multiple) {
-            let i;
+            let e;
             if (Array.isArray(this.defaultValue)) {
-              i = [];
+              e = [];
               for (const t of this.defaultValue)
-                typeof t == "boolean" && i.push(t);
-              i.length === 0 && (i = void 0);
+                typeof t == "boolean" && e.push(t);
+              e.length === 0 && (e = void 0);
             }
-            return r.serialize({
+            return a.serialize({
               ...s,
               type: "boolean",
               multiple: !0,
-              defaultValue: i,
+              defaultValue: e,
               options: this.options ? this.options.map((t) => ({
                 id: t.id,
                 label: t.label,
@@ -284,16 +322,16 @@ const r = {
               })) : null
             });
           }
-          return r.serialize({
+          return a.serialize({
             ...s,
             type: "boolean",
             multiple: !1,
             defaultValue: n,
-            options: this.options ? this.options.map((i) => ({
-              id: i.id,
-              label: i.label,
-              value: !!i.value,
-              condition: i.condition
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: !!e.value,
+              condition: e.condition
             })) : null
           });
         //  todo: support for object type fields
@@ -319,98 +357,111 @@ const r = {
       }
     }
   };
-}, v = (e) => {
-  const a = [], o = [], s = [], d = [], h = [];
+}, E = (i) => {
+  const d = [], l = [], s = [], o = [], f = [];
   return {
-    id: e.id,
-    component: e.component,
-    type: e.type,
-    name: e.name,
-    decide: e.decide,
-    targets: e.targets,
-    steps: a,
-    nodes: o,
+    id: i.id,
+    component: i.component,
+    name: i.name,
+    initializeOpen: i.initializeOpen,
+    decide: i.decide,
+    targets: i.targets,
+    steps: d,
+    nodes: l,
     edges: s,
-    fields: h,
-    conditionals: d,
-    addStep(n, i) {
-      let t = i == null ? void 0 : i.node;
-      this.nodes.length === 0 && (t = c({ type: "origin" }, this), this.nodes.push(t));
-      const l = "serialize" in n ? n : y(n, this);
+    fields: f,
+    conditionals: o,
+    addStep(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
+      const r = "serialize" in n ? n : g(n, this);
       if (t) {
-        if (!l.node)
+        if (!r.node)
           throw new Error("todo no node");
-        const u = p(
-          { sourceNode: t, destinationNode: l.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: t, destinationNode: r.node, sourceNodeHandle: null },
           this
         );
         this.edges.push(u);
       }
-      return l.fields.length > 0 && l.fields.forEach((u) => {
+      return r.fields.length > 0 && r.fields.forEach((u) => {
         this.fields.includes(u) || this.fields.push(u);
-      }), this.steps.includes(l) || (this.steps.push(l), l.node && this.nodes.push(l.node)), l;
+      }), this.steps.includes(r) || (this.steps.push(r), r.node && this.nodes.push(r.node)), r;
     },
-    addConditional(n, i) {
-      let t = i == null ? void 0 : i.node;
-      this.nodes.length === 0 && (t = c({ type: "origin" }, this), this.nodes.push(t));
-      const l = "serialize" in n ? n : N(n, this);
+    addAction(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
+      const r = "serialize" in n ? n : m(n, this);
       if (t) {
-        if (!l.node)
+        const u = c(
+          { sourceNode: t, destinationNode: r, sourceNodeHandle: null },
+          this
+        );
+        this.edges.push(u);
+      }
+      return this.nodes.push(r), r;
+    },
+    addConditional(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
+      const r = "serialize" in n ? n : z(n, this);
+      if (t) {
+        if (!r.node)
           throw new Error("todo no node");
-        const u = p(
-          { sourceNode: t, destinationNode: l.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: t, destinationNode: r.node, sourceNodeHandle: null },
           this
         );
         this.edges.push(u);
       }
-      return this.conditionals.includes(l) || (this.conditionals.push(l), l.node && this.nodes.push(l.node)), l;
+      return this.conditionals.includes(r) || (this.conditionals.push(r), r.node && this.nodes.push(r.node)), r;
     },
-    addExperience(n, i) {
-      let t = i == null ? void 0 : i.node;
-      this.nodes.length === 0 && (t = c({ type: "origin" }, this), this.nodes.push(t));
-      const l = c(
+    addExperience(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
+      const r = h(
         { type: "experience", experience: n },
         this
       );
-      if (this.nodes.push(l), t) {
-        const u = p(
-          { sourceNode: t, destinationNode: l, sourceNodeHandle: null },
+      if (this.nodes.push(r), t) {
+        const u = c(
+          { sourceNode: t, destinationNode: r, sourceNodeHandle: null },
           this
         );
         this.edges.push(u);
       }
       return n;
     },
-    addField(n, i) {
-      const t = "serialize" in n ? n : m(n);
-      return i && i.fields.push(t), this.fields.includes(t) || this.fields.push(t), t;
+    addField(n, e) {
+      const t = "serialize" in n ? n : N(n);
+      return e && e.fields.push(t), this.fields.includes(t) || this.fields.push(t), t;
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
-        type: this.type,
         component: this.component,
         name: this.name,
+        initializeOpen: this.initializeOpen,
         decide: this.decide,
         targets: this.targets,
-        steps: this.steps.map((n) => r.deserialize(n.serialize())),
-        nodes: this.nodes.map((n) => r.deserialize(n.serialize())),
-        edges: this.edges.map((n) => r.deserialize(n.serialize())),
+        steps: this.steps.map((n) => a.deserialize(n.serialize())),
+        nodes: this.nodes.map((n) => a.deserialize(n.serialize())),
+        edges: this.edges.map((n) => a.deserialize(n.serialize())),
         conditionals: this.conditionals.map(
-          (n) => r.deserialize(n.serialize())
+          (n) => a.deserialize(n.serialize())
         ),
-        fields: this.fields.map((n) => r.deserialize(n.serialize()))
+        fields: this.fields.map((n) => a.deserialize(n.serialize()))
       });
     }
   };
 };
 export {
-  N as createConditional,
-  p as createEdge,
-  v as createExperience,
-  b as createExperiencePlugin,
-  m as createField,
-  c as createNode,
-  x as createStep,
-  r as serialization
+  z as createConditional,
+  c as createEdge,
+  E as createExperience,
+  x as createExperiencePlugin,
+  N as createField,
+  h as createNode,
+  v as createStep,
+  a as serialization
 };

package/dist/esm/plugins/experience-browser-storage/index.js

@@ -1,5 +1,5 @@
 import { createEffect as r, sample as i } from "effector";
-import { c, l as g, s as S } from "../../../storage-BxBBl9Bw.js";
+import { c, l as g, s as S } from "../../../storage-Cb_71y48.js";
 import { l as f } from "../../../logger-C9a75KZn.js";
 const y = ({
   storage: a = "local"

package/dist/esm/plugins/history-browser-storage/index.js

@@ -1,5 +1,5 @@
 import { createEffect as s, sample as r } from "effector";
-import { c as l, l as y, s as g } from "../../../storage-BxBBl9Bw.js";
+import { c as l, l as y, s as g } from "../../../storage-Cb_71y48.js";
 const a = l("history", "global"), f = ({
   storage: i = "local"
 } = {}) => ({

package/dist/esm/plugins/responses-browser-storage/index.js

@@ -1,5 +1,5 @@
 import { createEffect as d, attach as m, sample as l } from "effector";
-import { c as b, l as h, s as E } from "../../../storage-BxBBl9Bw.js";
+import { c as b, l as h, s as E } from "../../../storage-Cb_71y48.js";
 const p = b("responses", "global"), y = ({
   storage: i = "local"
 } = {}) => ({

package/dist/esm/server/index.js

@@ -1,5 +1,5 @@
 import { createEvent as i, createStore as v, createEffect as C, sample as n, attach as S } from "effector";
-import { h as F } from "../../experience-instance-XlIuqLrL.js";
+import { h as F } from "../../experience-instance-CKru5var.js";
 function R() {
   let c, p;
   return {