@picked/client 0.0.1-dev.1772412203098 → 0.0.1-dev.1773363643396

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

@@ -1,113 +1,111 @@
-import { g as f } from "../../../id-BW-g3y32.js";
-const a = {
+import { g as h } from "../../../id-BW-g3y32.js";
+import { t as m } from "../../../to-kebab-case-BPnCZjhB.js";
+const r = {
   serialize(i) {
     return JSON.stringify(i);
   },
   deserialize(i) {
     return JSON.parse(i);
   }
-}, V = (i) => ({
+}, x = (i) => ({
   name: "create-experience",
-  setup: (n) => {
-    i.experiences.forEach((s) => {
-      const t = s.serialize(), d = a.deserialize(t);
-      d.component = s.component, n.registerExperience(d), d.fields.forEach((N) => {
-        n.registerField(N);
+  setup: (o) => {
+    i.experiences.forEach((t) => {
+      const n = t.serialize(), d = r.deserialize(n);
+      d.component = t.component, o.registerExperience(d), d.fields.forEach((f) => {
+        o.registerField(f);
       });
     });
   }
-}), z = (i, n) => ({
-  id: f("node"),
-  position: [0, 0],
-  experience: n,
+}), y = (i, o) => ({
+  id: h("node"),
+  experience: o,
   type: "action",
   action: i.action,
-  addNext(t) {
-    if (!t.node) throw new Error("Cannot connect to node");
-    const d = h(
-      { sourceNode: this, destinationNode: t.node, sourceNodeHandle: null },
-      n
+  addNext(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const d = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: null },
+      o
     );
-    n.edges.push(d);
+    o.edges.push(d);
   },
-  onSuccess(t) {
-    if (!t.node) throw new Error("Cannot connect to node");
-    const d = h(
-      { sourceNode: this, destinationNode: t.node, sourceNodeHandle: "true" },
-      n
+  onSuccess(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const d = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "true" },
+      o
     );
-    n.edges.push(d);
+    o.edges.push(d);
   },
-  onFail(t) {
-    if (!t.node) throw new Error("Cannot connect to node");
-    const d = h(
-      { sourceNode: this, destinationNode: t.node, sourceNodeHandle: "false" },
-      n
+  onFail(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const d = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "false" },
+      o
     );
-    n.edges.push(d);
+    o.edges.push(d);
   },
   serialize() {
-    return a.serialize({
+    return r.serialize({
       id: this.id,
       type: this.type,
-      action: this.action,
-      position: this.position
+      action: this.action
     });
   }
-}), E = (i) => ({
-  id: i.id ?? f("step"),
-  label: i.label,
+}), V = (i) => ({
+  id: i.id ?? h("step"),
+  name: i.name,
   fields: i.fields ?? [],
-  addField(n) {
-    const s = "serialize" in n ? n : y(n);
-    return this.fields.includes(s) || this.fields.push(s), s;
+  addField(o) {
+    const t = "serialize" in o ? o : N(o);
+    return this.fields.includes(t) || this.fields.push(t), t;
   }
-}), g = (i, n) => {
-  const s = {
-    id: i.id ?? f("step"),
-    label: i.label,
-    experience: n,
+}), z = (i, o) => {
+  const t = {
+    id: i.id ?? h("step"),
+    name: i.name,
+    experience: o,
     fields: i.fields ?? [],
     node: null,
-    nextStep(t) {
-      return this.experience.addStep(t, this);
+    nextStep(n) {
+      return this.experience.addStep(n, this);
     },
-    nextConditional(t) {
-      return this.experience.addConditional(t, this);
+    nextConditional(n) {
+      return this.experience.addConditional(n, this);
     },
-    addNextExperience(t) {
-      return this.experience.addExperience(t, this);
+    addNextExperience(n) {
+      return this.experience.addExperience(n, this);
     },
-    addField(t) {
-      return this.experience.addField(t, 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((t) => t.id)
+        key: m(this.name),
+        name: this.name,
+        fieldIds: this.fields.map((n) => n.id)
       });
     }
   };
-  return p({ step: s, type: "step" }, n), s;
-}, m = () => [0, 0], p = (i, n) => {
-  const s = {
-    id: f("node"),
-    position: m(),
-    experience: n
+  return p({ step: t, type: "step" }, o), t;
+}, p = (i, o) => {
+  const t = {
+    id: h("node"),
+    experience: o
   };
   if (i.type === "step") {
     const d = {
-      ...s,
+      ...t,
       type: "step",
       connectedStep: i.step,
       serialize() {
-        return a.serialize({
+        return r.serialize({
           id: this.id,
           type: this.type,
           stepId: this.connectedStep.id,
-          position: this.position,
-          label: this.connectedStep.label
+          name: this.connectedStep.name
         });
       }
     };
@@ -115,93 +113,91 @@ const a = {
   }
   if (i.type === "conditional") {
     const d = {
-      ...s,
+      ...t,
       type: "conditional",
       connectedConditional: i.conditional,
       serialize() {
-        return a.serialize({
+        return r.serialize({
           id: this.id,
           type: this.type,
-          conditionalId: this.connectedConditional.id,
-          position: this.position
+          conditionalId: this.connectedConditional.id
         });
       }
     };
     return d.connectedConditional.node = d, d;
   }
   return i.type === "experience" ? {
-    ...s,
+    ...t,
     type: "experience",
     connectedExperience: i.experience,
     serialize() {
-      return a.serialize({
+      return r.serialize({
         id: this.id,
         type: this.type,
-        experienceId: this.connectedExperience.id,
-        position: this.position
+        experienceId: this.connectedExperience.id
       });
     }
   } : {
-    ...s,
+    ...t,
     type: "origin",
     serialize() {
-      return a.serialize({
+      return r.serialize({
         id: this.id,
-        type: this.type,
-        position: this.position
+        type: this.type
       });
     }
   };
-}, h = (i, n) => ({
-  id: f("edge"),
+}, c = (i, o) => ({
+  id: h("edge"),
   sourceNode: i.sourceNode,
   sourceNodeHandle: i.sourceNodeHandle,
   destinationNode: i.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
     });
   }
-}), b = (i, n) => {
-  const s = {
-    id: f("conditional"),
+}), g = (i, o) => {
+  const t = {
+    id: h("conditional"),
     label: i.label,
     condition: i.condition,
     node: null,
-    experience: n,
-    addTrue(t) {
-      if (!this.node || !t.node)
+    experience: o,
+    addTrue(n) {
+      if (!this.node || !n.node)
         throw new Error("todo no node");
-      const d = h(
-        { sourceNode: this.node, destinationNode: t.node, sourceNodeHandle: "true" },
+      const d = c(
+        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "true" },
         this.experience
       );
       this.experience.edges.push(d);
     },
-    addFalse(t) {
-      if (!this.node || !t.node)
+    addFalse(n) {
+      if (!this.node || !n.node)
         throw new Error("todo no node");
-      const d = h(
-        { sourceNode: this.node, destinationNode: t.node, sourceNodeHandle: "false" },
+      const d = c(
+        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "false" },
         this.experience
       );
       this.experience.edges.push(d);
     },
     serialize() {
-      return a.serialize({
+      return r.serialize({
         id: this.id,
         label: this.label,
         condition: this.condition
       });
     }
   };
-  return p({ conditional: s, type: "conditional" }, n), s;
-}, y = (i) => ({
-  id: i.id,
+  return p({ conditional: t, type: "conditional" }, o), t;
+}, N = (i) => ({
+  id: i.id ?? h("field"),
+  key: i.key ?? m(i.name),
   name: i.name,
   type: i.type,
   label: i.label,
@@ -213,17 +209,16 @@ const a = {
   validation: i.validation ?? {},
   condition: i.condition,
   required: i.required,
-  options: Array.isArray(i.options) ? i.options.map(({ id: s, ...t }) => ({
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive fallback in case option id is omitted at runtime
-    id: s ?? f("option"),
+  options: i.options?.map((t) => ({
+    id: "id" in t ? t.id : h("option"),
     ...t
-  })) : i.options ?? null,
-  dependsOn: i.dependsOn,
+  })) ?? null,
   policies: i.policies,
-  // eslint-disable-next-line sonarjs/cognitive-complexity -- field type serialization logic requires branching per type/multiple combination
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- this function handles all field types and subtypes; splitting it would increase indirection without improving clarity. Addressed in PR #1372
   serialize() {
-    const s = {
+    const t = {
       id: this.id,
+      key: this.key,
       name: this.name,
       label: this.label,
       placeholder: this.placeholder,
@@ -232,217 +227,246 @@ const a = {
       helpText: this.helpText,
       validation: this.validation,
       condition: this.condition,
-      dependsOn: this.dependsOn,
       policies: this.policies
-    }, t = 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, u = (e) => this.options ? Array.isArray(this.options) ? this.options.map((o) => ({
-      id: o.id,
-      label: o.label,
-      description: o.description,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- option.value may be wider than JsonValue at this point; cast is safe before passing to castValue
-      value: e(o.value),
-      condition: o.condition
-    })) : this.options : null;
+    }, n = typeof this.defaultValue == "string" ? this.defaultValue : void 0, d = typeof this.defaultValue == "number" ? this.defaultValue : void 0, f = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
     switch (this.type) {
       case "text":
         if (this.multiple) {
           let e;
           if (Array.isArray(this.defaultValue)) {
             e = [];
-            for (const o of this.defaultValue)
-              typeof o == "string" && e.push(o);
+            for (const s of this.defaultValue)
+              typeof s == "string" && e.push(s);
             e.length === 0 && (e = void 0);
           }
-          return a.serialize({
-            ...s,
+          return r.serialize({
+            ...t,
             type: "text",
             multiple: !0,
             defaultValue: e,
-            options: u((o) => `${o}`)
+            options: this.options ? this.options.map((s) => ({
+              id: s.id,
+              label: s.label,
+              value: `${s.value}`,
+              condition: s.condition
+            })) : null
           });
         }
-        return a.serialize({
-          ...s,
+        return r.serialize({
+          ...t,
           type: "text",
           multiple: !1,
-          defaultValue: t,
-          options: u((e) => `${e}`)
+          defaultValue: n,
+          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 e;
           if (Array.isArray(this.defaultValue)) {
             e = [];
-            for (const o of this.defaultValue)
-              typeof o == "number" && e.push(o);
+            for (const s of this.defaultValue)
+              typeof s == "number" && e.push(s);
             e.length === 0 && (e = void 0);
           }
-          return a.serialize({
-            ...s,
+          return r.serialize({
+            ...t,
             type: "number",
             multiple: !0,
             defaultValue: e,
-            options: u((o) => Number(o))
+            options: this.options ? this.options.map((s) => ({
+              id: s.id,
+              label: s.label,
+              value: Number(s.value),
+              condition: s.condition
+            })) : null
           });
         }
-        return a.serialize({
-          ...s,
+        return r.serialize({
+          ...t,
           type: "number",
           multiple: !1,
           defaultValue: d,
-          options: u((e) => Number(e))
+          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 e;
           if (Array.isArray(this.defaultValue)) {
             e = [];
-            for (const o of this.defaultValue)
-              typeof o == "boolean" && e.push(o);
+            for (const s of this.defaultValue)
+              typeof s == "boolean" && e.push(s);
             e.length === 0 && (e = void 0);
           }
-          return a.serialize({
-            ...s,
+          return r.serialize({
+            ...t,
             type: "boolean",
             multiple: !0,
             defaultValue: e,
-            options: u((o) => !!o)
+            options: this.options ? this.options.map((s) => ({
+              id: s.id,
+              label: s.label,
+              value: !!s.value,
+              condition: s.condition
+            })) : null
           });
         }
-        return a.serialize({
-          ...s,
+        return r.serialize({
+          ...t,
           type: "boolean",
           multiple: !1,
-          defaultValue: N,
-          options: u((e) => !!e)
+          defaultValue: f,
+          options: this.options ? this.options.map((e) => ({
+            id: e.id,
+            label: e.label,
+            value: !!e.value,
+            condition: e.condition
+          })) : null
         });
       case "object":
-        return this.multiple ? a.serialize({
-          ...s,
+        return this.multiple ? r.serialize({
+          ...t,
           type: "object",
           multiple: !0,
           defaultValue: this.defaultValue,
-          options: u((e) => e)
-        }) : a.serialize({
-          ...s,
+          options: this.options ? this.options.map((e) => ({
+            id: e.id,
+            label: e.label,
+            description: e.description,
+            value: e.value,
+            condition: e.condition
+          })) : null
+        }) : r.serialize({
+          ...t,
           type: "object",
           multiple: !1,
           defaultValue: this.defaultValue,
-          options: u((e) => e)
+          options: this.options ? this.options.map((e) => ({
+            id: e.id,
+            label: e.label,
+            description: e.description,
+            value: e.value,
+            condition: e.condition
+          })) : null
         });
       default:
         throw new Error("Unsupported field type");
     }
   }
-}), w = (i) => {
-  const n = [], s = [], t = [], d = [], N = [], u = i.condition ?? i.decide;
+}), E = (i) => {
+  const o = [], t = [], n = [], d = [], f = [];
   return {
     id: i.id,
     component: i.component,
     name: i.name,
     initializeOpen: i.initializeOpen,
-    condition: u,
-    // eslint-disable-next-line sonarjs/deprecation -- kept for serialization backwards compatibility
-    decide: i.decide,
+    condition: i.condition,
     targets: i.targets,
-    steps: n,
-    nodes: s,
-    edges: t,
-    fields: N,
+    steps: o,
+    nodes: t,
+    edges: n,
+    fields: f,
     conditionals: d,
-    addStep(e, o) {
-      let r = o?.node;
-      this.nodes.length === 0 && (r = p({ type: "origin" }, this), this.nodes.push(r));
-      const l = "serialize" in e ? e : g(e, this);
-      if (r) {
-        if (!l.node)
+    addStep(e, s) {
+      let l = s?.node;
+      this.nodes.length === 0 && (l = p({ type: "origin" }, this), this.nodes.push(l));
+      const a = "serialize" in e ? e : z(e, this);
+      if (l) {
+        if (!a.node)
           throw new Error("todo no node");
-        const c = h(
-          { sourceNode: r, destinationNode: l.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: l, destinationNode: a.node, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return l.fields.length > 0 && l.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;
+      return a.fields.length > 0 && a.fields.forEach((u) => {
+        this.fields.includes(u) || this.fields.push(u);
+      }), this.steps.includes(a) || (this.steps.push(a), a.node && this.nodes.push(a.node)), a;
     },
-    addAction(e, o) {
-      let r = o?.node;
-      this.nodes.length === 0 && (r = p({ type: "origin" }, this), this.nodes.push(r));
-      const l = "serialize" in e ? e : z(e, this);
-      if (r) {
-        const c = h(
-          { sourceNode: r, destinationNode: l, sourceNodeHandle: null },
+    addAction(e, s) {
+      let l = s?.node;
+      this.nodes.length === 0 && (l = p({ type: "origin" }, this), this.nodes.push(l));
+      const a = "serialize" in e ? e : y(e, this);
+      if (l) {
+        const u = c(
+          { sourceNode: l, destinationNode: a, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return this.nodes.push(l), l;
+      return this.nodes.push(a), a;
     },
-    addConditional(e, o) {
-      let r = o?.node;
-      this.nodes.length === 0 && (r = p({ type: "origin" }, this), this.nodes.push(r));
-      const l = "serialize" in e ? e : b(e, this);
-      if (r) {
-        if (!l.node)
+    addConditional(e, s) {
+      let l = s?.node;
+      this.nodes.length === 0 && (l = p({ type: "origin" }, this), this.nodes.push(l));
+      const a = "serialize" in e ? e : g(e, this);
+      if (l) {
+        if (!a.node)
           throw new Error("todo no node");
-        const c = h(
-          { sourceNode: r, destinationNode: l.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: l, destinationNode: a.node, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        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(a) || (this.conditionals.push(a), a.node && this.nodes.push(a.node)), a;
     },
-    addExperience(e, o) {
-      let r = o?.node;
-      this.nodes.length === 0 && (r = p({ type: "origin" }, this), this.nodes.push(r));
-      const l = p(
+    addExperience(e, s) {
+      let l = s?.node;
+      this.nodes.length === 0 && (l = p({ type: "origin" }, this), this.nodes.push(l));
+      const a = p(
         { type: "experience", experience: e },
         this
       );
-      if (this.nodes.push(l), r) {
-        const c = h(
-          { sourceNode: r, destinationNode: l, sourceNodeHandle: null },
+      if (this.nodes.push(a), l) {
+        const u = c(
+          { sourceNode: l, destinationNode: a, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
       return e;
     },
-    addField(e, o) {
-      const r = "serialize" in e ? e : y(e);
-      return o && o.fields.push(r), this.fields.includes(r) || this.fields.push(r), r;
+    addField(e, s) {
+      const l = "serialize" in e ? e : N(e);
+      return s && s.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,
         initializeOpen: this.initializeOpen,
-        // eslint-disable-next-line sonarjs/deprecation -- backwards compatibility: `decide` is deprecated but still supported
-        condition: this.condition ?? this.decide,
-        // eslint-disable-next-line sonarjs/deprecation -- kept for serialization backwards compatibility
-        decide: this.decide,
+        condition: this.condition,
         targets: this.targets,
-        steps: this.steps.map((e) => a.deserialize(e.serialize())),
-        nodes: this.nodes.map((e) => a.deserialize(e.serialize())),
-        edges: this.edges.map((e) => a.deserialize(e.serialize())),
+        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())),
         conditionals: this.conditionals.map(
-          (e) => a.deserialize(e.serialize())
+          (e) => r.deserialize(e.serialize())
         ),
-        fields: this.fields.map((e) => a.deserialize(e.serialize()))
+        fields: this.fields.map((e) => r.deserialize(e.serialize()))
       });
     }
   };
 };
 export {
-  b as createConditional,
-  h as createEdge,
-  w as createExperience,
-  V as createExperiencePlugin,
-  y as createField,
+  g as createConditional,
+  c as createEdge,
+  E as createExperience,
+  x as createExperiencePlugin,
+  N as createField,
   p as createNode,
-  E as createStep,
-  a as serialization
+  V as createStep,
+  r as serialization
 };