@picked/client 0.0.1-dev.1770759602712 → 0.0.1-dev.1770787109735

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

@@ -1,112 +1,113 @@
-import { g as p } from "../../../id-BW-g3y32.js";
-const r = {
-  serialize(i) {
-    return JSON.stringify(i);
+import { g as N } from "../../../id-BW-g3y32.js";
+const a = {
+  serialize(e) {
+    return JSON.stringify(e);
   },
-  deserialize(i) {
-    return JSON.parse(i);
+  deserialize(e) {
+    return JSON.parse(e);
   }
-}, w = (i) => ({
+}, v = (e) => ({
   name: "create-experience",
-  setup: (d) => {
+  setup: (n) => {
     Promise.all(
-      i.experiences.map(async (a) => {
-        const n = a.serialize(), l = r.deserialize(n);
-        l.component = a.component, d.registerExperience(l), l.fields.forEach((f) => {
-          d.registerField(f);
+      e.experiences.map(async (d) => {
+        const s = d.serialize(), r = a.deserialize(s);
+        r.component = d.component, n.registerExperience(r), r.fields.forEach((h) => {
+          const p = d.fields.find((t) => t.id === h.id);
+          p && typeof p.options == "function" && (h.options = p.options), n.registerField(h);
         });
       })
-    ).catch((a) => {
-      throw new Error(`Failed to create experiences: ${a}`);
+    ).catch((d) => {
+      throw new Error(`Failed to create experiences: ${d}`);
     });
   }
-}), v = (i, d) => ({
-  id: p("node"),
+}), z = (e, n) => ({
+  id: N("node"),
   position: [0, 0],
-  experience: d,
+  experience: n,
   type: "action",
-  action: i.action,
-  addNext(n) {
-    if (!n.node) throw new Error("Cannot connect to node");
-    const l = u(
-      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: null },
-      d
+  action: e.action,
+  addNext(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const r = u(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: null },
+      n
     );
-    d.edges.push(l);
+    n.edges.push(r);
   },
-  onSuccess(n) {
-    if (!n.node) throw new Error("Cannot connect to node");
-    const l = u(
-      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "true" },
-      d
+  onSuccess(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const r = u(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: "true" },
+      n
     );
-    d.edges.push(l);
+    n.edges.push(r);
   },
-  onFail(n) {
-    if (!n.node) throw new Error("Cannot connect to node");
-    const l = u(
-      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "false" },
-      d
+  onFail(s) {
+    if (!s.node) throw new Error("Cannot connect to node");
+    const r = u(
+      { sourceNode: this, destinationNode: s.node, sourceNodeHandle: "false" },
+      n
     );
-    d.edges.push(l);
+    n.edges.push(r);
   },
   serialize() {
-    return r.serialize({
+    return a.serialize({
       id: this.id,
       type: this.type,
       action: this.action,
       position: this.position
     });
   }
-}), x = (i) => ({
-  id: i.id ?? p("step"),
-  label: i.label,
-  fields: i.fields ?? [],
-  addField(d) {
-    const a = "serialize" in d ? d : y(d);
-    return this.fields?.includes(a) || this.fields?.push(a), a;
+}), E = (e) => ({
+  id: e.id ?? N("step"),
+  label: e.label,
+  fields: e.fields ?? [],
+  addField(n) {
+    const d = "serialize" in n ? n : m(n);
+    return this.fields?.includes(d) || this.fields?.push(d), d;
   }
-}), b = (i, d) => {
-  const a = {
-    id: i.id ?? p("step"),
-    label: i.label,
-    experience: d,
-    fields: i.fields ?? [],
+}), g = (e, n) => {
+  const d = {
+    id: e.id ?? N("step"),
+    label: e.label,
+    experience: n,
+    fields: e.fields ?? [],
     node: null,
-    nextStep(n) {
-      return this.experience.addStep(n, this);
+    nextStep(s) {
+      return this.experience.addStep(s, this);
     },
-    nextConditional(n) {
-      return this.experience.addConditional(n, this);
+    nextConditional(s) {
+      return this.experience.addConditional(s, this);
     },
-    addNextExperience(n) {
-      return this.experience.addExperience(n, this);
+    addNextExperience(s) {
+      return this.experience.addExperience(s, this);
     },
-    addField(n) {
-      return this.experience.addField(n, this);
+    addField(s) {
+      return this.experience.addField(s, this);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         label: this.label,
-        fieldIds: this.fields.map((n) => n.id)
+        fieldIds: this.fields.map((s) => s.id)
       });
     }
   };
-  return h({ step: a, type: "step" }, d), a;
-}, N = () => [0, 0], h = (i, d) => {
-  const a = {
-    id: p("node"),
-    position: N(),
-    experience: d
+  return f({ step: d, type: "step" }, n), d;
+}, b = () => [0, 0], f = (e, n) => {
+  const d = {
+    id: N("node"),
+    position: b(),
+    experience: n
   };
-  if (i.type === "step") {
-    const l = {
-      ...a,
+  if (e.type === "step") {
+    const r = {
+      ...d,
       type: "step",
-      connectedStep: i.step,
+      connectedStep: e.step,
       serialize() {
-        return r.serialize({
+        return a.serialize({
           id: this.id,
           type: this.type,
           stepId: this.connectedStep.id,
@@ -115,15 +116,15 @@ const r = {
         });
       }
     };
-    return l.connectedStep.node = l, l;
+    return r.connectedStep.node = r, r;
   }
-  if (i.type === "conditional") {
-    const l = {
-      ...a,
+  if (e.type === "conditional") {
+    const r = {
+      ...d,
       type: "conditional",
-      connectedConditional: i.conditional,
+      connectedConditional: e.conditional,
       serialize() {
-        return r.serialize({
+        return a.serialize({
           id: this.id,
           type: this.type,
           conditionalId: this.connectedConditional.id,
@@ -131,14 +132,14 @@ const r = {
         });
       }
     };
-    return l.connectedConditional.node = l, l;
+    return r.connectedConditional.node = r, r;
   }
-  return i.type === "experience" ? {
-    ...a,
+  return e.type === "experience" ? {
+    ...d,
     type: "experience",
-    connectedExperience: i.experience,
+    connectedExperience: e.experience,
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         type: this.type,
         experienceId: this.connectedExperience.id,
@@ -146,83 +147,92 @@ const r = {
       });
     }
   } : {
-    ...a,
+    ...d,
     type: "origin",
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         type: this.type,
         position: this.position
       });
     }
   };
-}, u = (i, d) => ({
-  id: p("edge"),
-  sourceNode: i.sourceNode,
-  sourceNodeHandle: i.sourceNodeHandle,
-  destinationNode: i.destinationNode,
-  experience: d,
+}, u = (e, n) => ({
+  id: N("edge"),
+  sourceNode: e.sourceNode,
+  sourceNodeHandle: e.sourceNodeHandle,
+  destinationNode: e.destinationNode,
+  experience: n,
   serialize() {
-    return r.serialize({
+    return a.serialize({
       id: this.id,
       sourceNodeHandle: this.sourceNodeHandle ?? void 0,
       sourceNodeId: this.sourceNode.id,
       destinationNodeId: this.destinationNode.id
     });
   }
-}), z = (i, d) => {
-  const a = {
-    id: p("conditional"),
-    condition: i.condition,
+}), x = (e, n) => {
+  const d = {
+    id: N("conditional"),
+    condition: e.condition,
     node: null,
-    experience: d,
-    addTrue(n) {
-      if (!this.node || !n.node)
+    experience: n,
+    addTrue(s) {
+      if (!this.node || !s.node)
         throw new Error("todo no node");
-      const l = u(
-        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "true" },
+      const r = u(
+        { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "true" },
         this.experience
       );
-      this.experience.edges.push(l);
+      this.experience.edges.push(r);
     },
-    addFalse(n) {
-      if (!this.node || !n.node)
+    addFalse(s) {
+      if (!this.node || !s.node)
         throw new Error("todo no node");
-      const l = u(
-        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "false" },
+      const r = u(
+        { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "false" },
         this.experience
       );
-      this.experience.edges.push(l);
+      this.experience.edges.push(r);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         condition: this.condition
       });
     }
   };
-  return h({ conditional: a, type: "conditional" }, d), a;
-}, y = (i) => {
-  const d = typeof i.options == "function";
+  return f({ conditional: d, type: "conditional" }, n), d;
+};
+function y(e, n) {
+  if (e === null) return null;
+  if (typeof e == "function") {
+    const d = e;
+    return async () => (await Promise.resolve(d())).map(n);
+  }
+  return e.map(n);
+}
+const m = (e) => {
+  const n = typeof e.options == "function";
   return {
-    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: d ? i.options : i.options ? i.options.map((n) => ({
-      ...n
+    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: n ? e.options : e.options ? e.options.map((s) => ({
+      ...s
     })) : null,
-    policies: i.policies,
+    policies: e.policies,
     serialize() {
-      const n = {
+      const s = {
         id: this.id,
         name: this.name,
         label: this.label,
@@ -233,289 +243,210 @@ const r = {
         validation: this.validation,
         condition: this.condition,
         policies: this.policies
-      }, l = typeof this.defaultValue == "string" ? this.defaultValue : void 0, f = typeof this.defaultValue == "number" ? this.defaultValue : void 0, m = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
+      }, r = typeof this.defaultValue == "string" ? this.defaultValue : void 0, h = typeof this.defaultValue == "number" ? this.defaultValue : void 0, p = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
       switch (this.type) {
-        case "text":
+        case "text": {
+          const t = y(this.options, (i) => ({
+            id: i.id,
+            label: i.label,
+            value: `${i.value}`,
+            condition: i.condition
+          }));
           if (this.multiple) {
-            let e;
+            let i;
             if (Array.isArray(this.defaultValue)) {
-              e = [];
-              for (const s of this.defaultValue)
-                typeof s == "string" && e.push(s);
-              e.length === 0 && (e = void 0);
+              i = [];
+              for (const o of this.defaultValue)
+                typeof o == "string" && i.push(o);
+              i.length === 0 && (i = void 0);
             }
-            return r.serialize({
-              ...n,
+            return a.serialize({
+              ...s,
               type: "text",
               multiple: !0,
-              defaultValue: e,
-              options: this.options ? typeof this.options == "function" ? (() => {
-                const s = this.options;
-                return async () => (await Promise.resolve(s())).map((o) => ({
-                  id: o.id,
-                  label: o.label,
-                  value: `${o.value}`,
-                  condition: o.condition
-                }));
-              })() : this.options.map((s) => ({
-                id: s.id,
-                label: s.label,
-                value: `${s.value}`,
-                condition: s.condition
-              })) : null
+              defaultValue: i,
+              options: t
             });
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...s,
             type: "text",
             multiple: !1,
-            defaultValue: l,
-            options: this.options ? typeof this.options == "function" ? (() => {
-              const e = this.options;
-              return async () => (await Promise.resolve(e())).map((t) => ({
-                id: t.id,
-                label: t.label,
-                value: `${t.value}`,
-                condition: t.condition
-              }));
-            })() : this.options.map((e) => ({
-              id: e.id,
-              label: e.label,
-              value: `${e.value}`,
-              condition: e.condition
-            })) : null
+            defaultValue: r,
+            options: t
           });
-        case "number":
+        }
+        case "number": {
+          const t = y(this.options, (i) => ({
+            id: i.id,
+            label: i.label,
+            value: Number(i.value),
+            condition: i.condition
+          }));
           if (this.multiple) {
-            let e;
+            let i;
             if (Array.isArray(this.defaultValue)) {
-              e = [];
-              for (const s of this.defaultValue)
-                typeof s == "number" && e.push(s);
-              e.length === 0 && (e = void 0);
+              i = [];
+              for (const o of this.defaultValue)
+                typeof o == "number" && i.push(o);
+              i.length === 0 && (i = void 0);
             }
-            return r.serialize({
-              ...n,
+            return a.serialize({
+              ...s,
               type: "number",
               multiple: !0,
-              defaultValue: e,
-              options: this.options ? typeof this.options == "function" ? (() => {
-                const s = this.options;
-                return async () => (await Promise.resolve(s())).map((o) => ({
-                  id: o.id,
-                  label: o.label,
-                  value: Number(o.value),
-                  condition: o.condition
-                }));
-              })() : this.options.map((s) => ({
-                id: s.id,
-                label: s.label,
-                value: Number(s.value),
-                condition: s.condition
-              })) : null
+              defaultValue: i,
+              options: t
             });
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...s,
             type: "number",
             multiple: !1,
-            defaultValue: f,
-            options: this.options ? typeof this.options == "function" ? (() => {
-              const e = this.options;
-              return async () => (await Promise.resolve(e())).map((t) => ({
-                id: t.id,
-                label: t.label,
-                value: Number(t.value),
-                condition: t.condition
-              }));
-            })() : this.options.map((e) => ({
-              id: e.id,
-              label: e.label,
-              value: Number(e.value),
-              condition: e.condition
-            })) : null
+            defaultValue: h,
+            options: t
           });
-        case "boolean":
+        }
+        case "boolean": {
+          const t = y(this.options, (i) => ({
+            id: i.id,
+            label: i.label,
+            value: !!i.value,
+            condition: i.condition
+          }));
           if (this.multiple) {
-            let e;
+            let i;
             if (Array.isArray(this.defaultValue)) {
-              e = [];
-              for (const s of this.defaultValue)
-                typeof s == "boolean" && e.push(s);
-              e.length === 0 && (e = void 0);
+              i = [];
+              for (const o of this.defaultValue)
+                typeof o == "boolean" && i.push(o);
+              i.length === 0 && (i = void 0);
             }
-            return r.serialize({
-              ...n,
+            return a.serialize({
+              ...s,
               type: "boolean",
               multiple: !0,
-              defaultValue: e,
-              options: this.options ? typeof this.options == "function" ? (() => {
-                const s = this.options;
-                return async () => (await Promise.resolve(s())).map((o) => ({
-                  id: o.id,
-                  label: o.label,
-                  value: !!o.value,
-                  condition: o.condition
-                }));
-              })() : this.options.map((s) => ({
-                id: s.id,
-                label: s.label,
-                value: !!s.value,
-                condition: s.condition
-              })) : null
+              defaultValue: i,
+              options: t
             });
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...s,
             type: "boolean",
             multiple: !1,
-            defaultValue: m,
-            options: this.options ? typeof this.options == "function" ? (() => {
-              const e = this.options;
-              return async () => (await Promise.resolve(e())).map((t) => ({
-                id: t.id,
-                label: t.label,
-                value: !!t.value,
-                condition: t.condition
-              }));
-            })() : this.options.map((e) => ({
-              id: e.id,
-              label: e.label,
-              value: !!e.value,
-              condition: e.condition
-            })) : null
+            defaultValue: p,
+            options: t
           });
-        case "object":
-          return this.multiple ? r.serialize({
-            ...n,
+        }
+        case "object": {
+          const t = y(this.options, (i) => ({
+            id: i.id,
+            label: i.label,
+            description: i.description,
+            value: i.value,
+            condition: i.condition
+          }));
+          return this.multiple ? a.serialize({
+            ...s,
             type: "object",
             multiple: !0,
             defaultValue: this.defaultValue,
-            options: this.options ? typeof this.options == "function" ? (() => {
-              const e = this.options;
-              return async () => (await Promise.resolve(e())).map((t) => ({
-                id: t.id,
-                label: t.label,
-                description: t.description,
-                value: t.value,
-                condition: t.condition
-              }));
-            })() : this.options.map((e) => ({
-              id: e.id,
-              label: e.label,
-              description: e.description,
-              value: e.value,
-              condition: e.condition
-            })) : null
-          }) : r.serialize({
-            ...n,
+            options: t
+          }) : a.serialize({
+            ...s,
             type: "object",
             multiple: !1,
             defaultValue: this.defaultValue,
-            options: this.options ? typeof this.options == "function" ? (() => {
-              const e = this.options;
-              return async () => (await Promise.resolve(e())).map((t) => ({
-                id: t.id,
-                label: t.label,
-                description: t.description,
-                value: t.value,
-                condition: t.condition
-              }));
-            })() : this.options.map((e) => ({
-              id: e.id,
-              label: e.label,
-              description: e.description,
-              value: e.value,
-              condition: e.condition
-            })) : null
+            options: t
           });
+        }
         default:
           throw new Error("Unsupported field type");
       }
     }
   };
-}, V = (i) => {
-  const d = [], a = [], n = [], l = [], f = [], m = i.condition ?? i.decide;
+}, w = (e) => {
+  const n = [], d = [], s = [], r = [], h = [], p = e.condition ?? e.decide;
   return {
-    id: i.id,
-    component: i.component,
-    name: i.name,
-    initializeOpen: i.initializeOpen,
-    condition: m,
-    decide: i.decide,
-    targets: i.targets,
-    steps: d,
-    nodes: a,
-    edges: n,
-    fields: f,
-    conditionals: l,
-    addStep(e, s) {
-      let t = s?.node;
-      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
-      const o = "serialize" in e ? e : b(e, this);
-      if (t) {
-        if (!o.node)
+    id: e.id,
+    component: e.component,
+    name: e.name,
+    initializeOpen: e.initializeOpen,
+    condition: p,
+    decide: e.decide,
+    targets: e.targets,
+    steps: n,
+    nodes: d,
+    edges: s,
+    fields: h,
+    conditionals: r,
+    addStep(t, i) {
+      let o = i?.node;
+      this.nodes.length === 0 && (o = f({ type: "origin" }, this), this.nodes.push(o));
+      const l = "serialize" in t ? t : g(t, this);
+      if (o) {
+        if (!l.node)
           throw new Error("todo no node");
         const c = u(
-          { sourceNode: t, destinationNode: o.node, sourceNodeHandle: null },
+          { sourceNode: o, destinationNode: l.node, sourceNodeHandle: null },
           this
         );
         this.edges.push(c);
       }
-      return o.fields.length > 0 && o.fields.forEach((c) => {
+      return l.fields.length > 0 && l.fields.forEach((c) => {
         this.fields.includes(c) || this.fields.push(c);
-      }), this.steps.includes(o) || (this.steps.push(o), o.node && this.nodes.push(o.node)), o;
+      }), this.steps.includes(l) || (this.steps.push(l), l.node && this.nodes.push(l.node)), l;
     },
-    addAction(e, s) {
-      let t = s?.node;
-      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
-      const o = "serialize" in e ? e : v(e, this);
-      if (t) {
+    addAction(t, i) {
+      let o = i?.node;
+      this.nodes.length === 0 && (o = f({ type: "origin" }, this), this.nodes.push(o));
+      const l = "serialize" in t ? t : z(t, this);
+      if (o) {
         const c = u(
-          { sourceNode: t, destinationNode: o, sourceNodeHandle: null },
+          { sourceNode: o, destinationNode: l, sourceNodeHandle: null },
           this
         );
         this.edges.push(c);
       }
-      return this.nodes.push(o), o;
+      return this.nodes.push(l), l;
     },
-    addConditional(e, s) {
-      let t = s?.node;
-      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
-      const o = "serialize" in e ? e : z(e, this);
-      if (t) {
-        if (!o.node)
+    addConditional(t, i) {
+      let o = i?.node;
+      this.nodes.length === 0 && (o = f({ type: "origin" }, this), this.nodes.push(o));
+      const l = "serialize" in t ? t : x(t, this);
+      if (o) {
+        if (!l.node)
           throw new Error("todo no node");
         const c = u(
-          { sourceNode: t, destinationNode: o.node, sourceNodeHandle: null },
+          { sourceNode: o, destinationNode: l.node, sourceNodeHandle: null },
           this
         );
         this.edges.push(c);
       }
-      return this.conditionals.includes(o) || (this.conditionals.push(o), o.node && this.nodes.push(o.node)), o;
+      return this.conditionals.includes(l) || (this.conditionals.push(l), l.node && this.nodes.push(l.node)), l;
     },
-    addExperience(e, s) {
-      let t = s?.node;
-      this.nodes.length === 0 && (t = h({ type: "origin" }, this), this.nodes.push(t));
-      const o = h(
-        { type: "experience", experience: e },
+    addExperience(t, i) {
+      let o = i?.node;
+      this.nodes.length === 0 && (o = f({ type: "origin" }, this), this.nodes.push(o));
+      const l = f(
+        { type: "experience", experience: t },
         this
       );
-      if (this.nodes.push(o), t) {
+      if (this.nodes.push(l), o) {
         const c = u(
-          { sourceNode: t, destinationNode: o, sourceNodeHandle: null },
+          { sourceNode: o, destinationNode: l, sourceNodeHandle: null },
           this
         );
         this.edges.push(c);
       }
-      return e;
+      return t;
     },
-    addField(e, s) {
-      const t = "serialize" in e ? e : y(e);
-      return s && s.fields.push(t), this.fields.includes(t) || this.fields.push(t), t;
+    addField(t, i) {
+      const o = "serialize" in t ? t : m(t);
+      return i && i.fields.push(o), this.fields.includes(o) || this.fields.push(o), o;
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         component: this.component,
         name: this.name,
@@ -523,24 +454,24 @@ const r = {
         condition: this.condition ?? this.decide,
         decide: this.decide,
         targets: this.targets,
-        steps: this.steps.map((e) => r.deserialize(e.serialize())),
-        nodes: this.nodes.map((e) => r.deserialize(e.serialize())),
-        edges: this.edges.map((e) => r.deserialize(e.serialize())),
+        steps: this.steps.map((t) => a.deserialize(t.serialize())),
+        nodes: this.nodes.map((t) => a.deserialize(t.serialize())),
+        edges: this.edges.map((t) => a.deserialize(t.serialize())),
         conditionals: this.conditionals.map(
-          (e) => r.deserialize(e.serialize())
+          (t) => a.deserialize(t.serialize())
         ),
-        fields: this.fields.map((e) => r.deserialize(e.serialize()))
+        fields: this.fields.map((t) => a.deserialize(t.serialize()))
       });
     }
   };
 };
 export {
-  z as createConditional,
+  x as createConditional,
   u as createEdge,
-  V as createExperience,
-  w as createExperiencePlugin,
-  y as createField,
-  h as createNode,
-  x as createStep,
-  r as serialization
+  w as createExperience,
+  v as createExperiencePlugin,
+  m as createField,
+  f as createNode,
+  E as createStep,
+  a as serialization
 };