@picked/client 0.0.1-dev.1770849584797 → 0.0.1-dev.1771901344537

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

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