@picked/client 0.0.1-dev.1773371977114 → 0.0.1-dev.1773724362573

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

@@ -1,229 +1,222 @@
 import { g as p } from "../../../id-BW-g3y32.js";
-import { t as m } from "../../../to-kebab-case-BPnCZjhB.js";
-const r = {
-  serialize(i) {
-    return JSON.stringify(i);
+const a = {
+  serialize(e) {
+    return JSON.stringify(e);
   },
-  deserialize(i) {
-    return JSON.parse(i);
+  deserialize(e) {
+    return JSON.parse(e);
   }
-}, x = (i) => ({
+}, b = (e) => ({
   name: "create-experience",
   setup: (d) => {
-    i.experiences.forEach((n) => {
-      const o = n.serialize(), s = r.deserialize(o);
-      s.component = n.component, d.registerExperience(s), s.fields.forEach((u) => {
-        d.registerField(u);
+    e.experiences.forEach((o) => {
+      const n = o.serialize(), r = a.deserialize(n);
+      r.component = o.component, d.registerExperience(r), r.fields.forEach((f) => {
+        d.registerField(f);
       });
     });
   }
-}), N = (i, d) => ({
+}), y = (e, d) => ({
   id: p("node"),
   experience: d,
   type: "action",
-  action: i.action,
-  addNext(o) {
-    if (!o.node) throw new Error("Cannot connect to node");
-    const s = h(
-      { sourceNode: this, destinationNode: o.node, sourceNodeHandle: null },
+  action: e.action,
+  addNext(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const r = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: null },
       d
     );
-    d.edges.push(s);
+    d.edges.push(r);
   },
-  onSuccess(o) {
-    if (!o.node) throw new Error("Cannot connect to node");
-    const s = h(
-      { sourceNode: this, destinationNode: o.node, sourceNodeHandle: "true" },
+  onSuccess(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const r = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "true" },
       d
     );
-    d.edges.push(s);
+    d.edges.push(r);
   },
-  onFail(o) {
-    if (!o.node) throw new Error("Cannot connect to node");
-    const s = h(
-      { sourceNode: this, destinationNode: o.node, sourceNodeHandle: "false" },
+  onFail(n) {
+    if (!n.node) throw new Error("Cannot connect to node");
+    const r = c(
+      { sourceNode: this, destinationNode: n.node, sourceNodeHandle: "false" },
       d
     );
-    d.edges.push(s);
+    d.edges.push(r);
   },
   serialize() {
-    return r.serialize({
+    return a.serialize({
       id: this.id,
       type: this.type,
       action: this.action
     });
   }
-}), V = (i) => {
-  const d = i.name ?? i.label ?? "";
-  return {
-    id: i.id ?? p("step"),
-    key: i.key ?? m(d),
-    name: d,
-    fields: i.fields ?? [],
-    addField(n) {
-      const o = "serialize" in n ? n : y(n);
-      return this.fields.includes(o) || this.fields.push(o), o;
-    }
-  };
-}, z = (i, d) => {
-  const n = "label" in i ? i.label : void 0, o = i.name ?? n ?? "", s = {
-    id: i.id ?? p("step"),
-    key: i.key ?? m(o),
-    name: o,
+}), x = (e) => ({
+  id: e.id ?? p("step"),
+  label: e.label,
+  fields: e.fields ?? [],
+  addField(d) {
+    const o = "serialize" in d ? d : N(d);
+    return this.fields.includes(o) || this.fields.push(o), o;
+  }
+}), z = (e, d) => {
+  const o = {
+    id: e.id ?? p("step"),
+    label: e.label,
     experience: d,
-    fields: i.fields ?? [],
+    fields: e.fields ?? [],
     node: null,
-    nextStep(u) {
-      return this.experience.addStep(u, this);
+    nextStep(n) {
+      return this.experience.addStep(n, this);
     },
-    nextConditional(u) {
-      return this.experience.addConditional(u, this);
+    nextConditional(n) {
+      return this.experience.addConditional(n, this);
     },
-    addNextExperience(u) {
-      return this.experience.addExperience(u, this);
+    addNextExperience(n) {
+      return this.experience.addExperience(n, this);
     },
-    addField(u) {
-      return this.experience.addField(u, this);
+    addField(n) {
+      return this.experience.addField(n, this);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
-        key: m(this.name),
-        name: this.name,
-        fieldIds: this.fields.map((u) => u.id)
+        label: this.label,
+        fieldIds: this.fields.map((n) => n.id)
       });
     }
   };
-  return f({ step: s, type: "step" }, d), s;
-}, f = (i, d) => {
-  const n = {
+  return h({ step: o, type: "step" }, d), o;
+}, h = (e, d) => {
+  const o = {
     id: p("node"),
     experience: d
   };
-  if (i.type === "step") {
-    const s = {
-      ...n,
+  if (e.type === "step") {
+    const r = {
+      ...o,
       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,
-          name: this.connectedStep.name
+          label: this.connectedStep.label
         });
       }
     };
-    return s.connectedStep.node = s, s;
+    return r.connectedStep.node = r, r;
   }
-  if (i.type === "conditional") {
-    const s = {
-      ...n,
+  if (e.type === "conditional") {
+    const r = {
+      ...o,
       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
         });
       }
     };
-    return s.connectedConditional.node = s, s;
+    return r.connectedConditional.node = r, r;
   }
-  return i.type === "experience" ? {
-    ...n,
+  return e.type === "experience" ? {
+    ...o,
     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
       });
     }
   } : {
-    ...n,
+    ...o,
     type: "origin",
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         type: this.type
       });
     }
   };
-}, h = (i, d) => ({
+}, c = (e, d) => ({
   id: p("edge"),
-  sourceNode: i.sourceNode,
-  sourceNodeHandle: i.sourceNodeHandle,
-  destinationNode: i.destinationNode,
+  sourceNode: e.sourceNode,
+  sourceNodeHandle: e.sourceNodeHandle,
+  destinationNode: e.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
     });
   }
-}), g = (i, d) => {
-  const n = {
+}), g = (e, d) => {
+  const o = {
     id: p("conditional"),
-    label: i.label,
-    condition: i.condition,
+    label: e.label,
+    condition: e.condition,
     node: null,
     experience: d,
-    addTrue(o) {
-      if (!this.node || !o.node)
+    addTrue(n) {
+      if (!this.node || !n.node)
         throw new Error("todo no node");
-      const s = h(
-        { sourceNode: this.node, destinationNode: o.node, sourceNodeHandle: "true" },
+      const r = c(
+        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "true" },
         this.experience
       );
-      this.experience.edges.push(s);
+      this.experience.edges.push(r);
     },
-    addFalse(o) {
-      if (!this.node || !o.node)
+    addFalse(n) {
+      if (!this.node || !n.node)
         throw new Error("todo no node");
-      const s = h(
-        { sourceNode: this.node, destinationNode: o.node, sourceNodeHandle: "false" },
+      const r = c(
+        { sourceNode: this.node, destinationNode: n.node, sourceNodeHandle: "false" },
         this.experience
       );
-      this.experience.edges.push(s);
+      this.experience.edges.push(r);
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         label: this.label,
         condition: this.condition
       });
     }
   };
-  return f({ conditional: n, type: "conditional" }, d), n;
-}, y = (i) => ({
-  id: i.id ?? p("field"),
-  key: i.key ?? m(i.name),
-  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: i.options?.map((n) => ({
-    id: "id" in n ? n.id : p("option"),
+  return h({ conditional: o, type: "conditional" }, d), o;
+}, N = (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: Array.isArray(e.options) ? e.options.map(({ id: o, ...n }) => ({
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive fallback in case option id is omitted at runtime
+    id: o ?? p("option"),
     ...n
-  })) ?? null,
-  policies: i.policies,
+  })) : e.options ?? null,
+  dependsOn: e.dependsOn,
+  policies: e.policies,
   // 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 n = {
+    const o = {
       id: this.id,
-      key: this.key,
       name: this.name,
       label: this.label,
       placeholder: this.placeholder,
@@ -232,246 +225,212 @@ const r = {
       helpText: this.helpText,
       validation: this.validation,
       condition: this.condition,
+      dependsOn: this.dependsOn,
       policies: this.policies
-    }, o = typeof this.defaultValue == "string" ? this.defaultValue : void 0, s = typeof this.defaultValue == "number" ? this.defaultValue : void 0, u = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
+    }, n = typeof this.defaultValue == "string" ? this.defaultValue : void 0, r = typeof this.defaultValue == "number" ? this.defaultValue : void 0, f = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0, s = (t) => this.options ? Array.isArray(this.options) ? this.options.map((i) => ({
+      id: i.id,
+      label: i.label,
+      description: i.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: t(i.value),
+      condition: i.condition
+    })) : this.options : null;
     switch (this.type) {
       case "text":
         if (this.multiple) {
-          let e;
+          let t;
           if (Array.isArray(this.defaultValue)) {
-            e = [];
-            for (const t of this.defaultValue)
-              typeof t == "string" && e.push(t);
-            e.length === 0 && (e = void 0);
+            t = [];
+            for (const i of this.defaultValue)
+              typeof i == "string" && t.push(i);
+            t.length === 0 && (t = void 0);
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...o,
             type: "text",
             multiple: !0,
-            defaultValue: e,
-            options: this.options ? this.options.map((t) => ({
-              id: t.id,
-              label: t.label,
-              value: `${t.value}`,
-              condition: t.condition
-            })) : null
+            defaultValue: t,
+            options: s((i) => `${i}`)
           });
         }
-        return r.serialize({
-          ...n,
+        return a.serialize({
+          ...o,
           type: "text",
           multiple: !1,
-          defaultValue: o,
-          options: this.options ? this.options.map((e) => ({
-            id: e.id,
-            label: e.label,
-            value: `${e.value}`,
-            condition: e.condition
-          })) : null
+          defaultValue: n,
+          options: s((t) => `${t}`)
         });
       case "number":
         if (this.multiple) {
-          let e;
+          let t;
           if (Array.isArray(this.defaultValue)) {
-            e = [];
-            for (const t of this.defaultValue)
-              typeof t == "number" && e.push(t);
-            e.length === 0 && (e = void 0);
+            t = [];
+            for (const i of this.defaultValue)
+              typeof i == "number" && t.push(i);
+            t.length === 0 && (t = void 0);
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...o,
             type: "number",
             multiple: !0,
-            defaultValue: e,
-            options: this.options ? this.options.map((t) => ({
-              id: t.id,
-              label: t.label,
-              value: Number(t.value),
-              condition: t.condition
-            })) : null
+            defaultValue: t,
+            options: s((i) => Number(i))
           });
         }
-        return r.serialize({
-          ...n,
+        return a.serialize({
+          ...o,
           type: "number",
           multiple: !1,
-          defaultValue: s,
-          options: this.options ? this.options.map((e) => ({
-            id: e.id,
-            label: e.label,
-            value: Number(e.value),
-            condition: e.condition
-          })) : null
+          defaultValue: r,
+          options: s((t) => Number(t))
         });
       case "boolean":
         if (this.multiple) {
-          let e;
+          let t;
           if (Array.isArray(this.defaultValue)) {
-            e = [];
-            for (const t of this.defaultValue)
-              typeof t == "boolean" && e.push(t);
-            e.length === 0 && (e = void 0);
+            t = [];
+            for (const i of this.defaultValue)
+              typeof i == "boolean" && t.push(i);
+            t.length === 0 && (t = void 0);
           }
-          return r.serialize({
-            ...n,
+          return a.serialize({
+            ...o,
             type: "boolean",
             multiple: !0,
-            defaultValue: e,
-            options: this.options ? this.options.map((t) => ({
-              id: t.id,
-              label: t.label,
-              value: !!t.value,
-              condition: t.condition
-            })) : null
+            defaultValue: t,
+            options: s((i) => !!i)
           });
         }
-        return r.serialize({
-          ...n,
+        return a.serialize({
+          ...o,
           type: "boolean",
           multiple: !1,
-          defaultValue: u,
-          options: this.options ? this.options.map((e) => ({
-            id: e.id,
-            label: e.label,
-            value: !!e.value,
-            condition: e.condition
-          })) : null
+          defaultValue: f,
+          options: s((t) => !!t)
         });
       case "object":
-        return this.multiple ? r.serialize({
-          ...n,
+        return this.multiple ? a.serialize({
+          ...o,
           type: "object",
           multiple: !0,
           defaultValue: this.defaultValue,
-          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({
-          ...n,
+          options: s((t) => t)
+        }) : a.serialize({
+          ...o,
           type: "object",
           multiple: !1,
           defaultValue: this.defaultValue,
-          options: this.options ? this.options.map((e) => ({
-            id: e.id,
-            label: e.label,
-            description: e.description,
-            value: e.value,
-            condition: e.condition
-          })) : null
+          options: s((t) => t)
         });
       default:
         throw new Error("Unsupported field type");
     }
   }
-}), E = (i) => {
-  const d = [], n = [], o = [], s = [], u = [];
+}), V = (e) => {
+  const d = [], o = [], n = [], r = [], f = [];
   return {
-    id: i.id,
-    component: i.component,
-    name: i.name,
-    initializeOpen: i.initializeOpen,
-    condition: i.condition,
-    targets: i.targets,
+    id: e.id,
+    component: e.component,
+    name: e.name,
+    initializeOpen: e.initializeOpen,
+    condition: e.condition,
+    targets: e.targets,
     steps: d,
-    nodes: n,
-    edges: o,
-    fields: u,
-    conditionals: s,
-    addStep(e, t) {
-      let l = t?.node;
-      this.nodes.length === 0 && (l = f({ type: "origin" }, this), this.nodes.push(l));
-      const a = "serialize" in e ? e : z(e, this);
-      if (l) {
-        if (!a.node)
+    nodes: o,
+    edges: n,
+    fields: f,
+    conditionals: r,
+    addStep(s, t) {
+      let i = t?.node;
+      this.nodes.length === 0 && (i = h({ type: "origin" }, this), this.nodes.push(i));
+      const l = "serialize" in s ? s : z(s, this);
+      if (i) {
+        if (!l.node)
           throw new Error("todo no node");
-        const c = h(
-          { sourceNode: l, destinationNode: a.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: i, destinationNode: l.node, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return a.fields.length > 0 && a.fields.forEach((c) => {
-        this.fields.includes(c) || this.fields.push(c);
-      }), this.steps.includes(a) || (this.steps.push(a), a.node && this.nodes.push(a.node)), a;
+      return l.fields.length > 0 && l.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;
     },
-    addAction(e, t) {
-      let l = t?.node;
-      this.nodes.length === 0 && (l = f({ type: "origin" }, this), this.nodes.push(l));
-      const a = "serialize" in e ? e : N(e, this);
-      if (l) {
-        const c = h(
-          { sourceNode: l, destinationNode: a, sourceNodeHandle: null },
+    addAction(s, t) {
+      let i = t?.node;
+      this.nodes.length === 0 && (i = h({ type: "origin" }, this), this.nodes.push(i));
+      const l = "serialize" in s ? s : y(s, this);
+      if (i) {
+        const u = c(
+          { sourceNode: i, destinationNode: l, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return this.nodes.push(a), a;
+      return this.nodes.push(l), l;
     },
-    addConditional(e, t) {
-      let l = t?.node;
-      this.nodes.length === 0 && (l = f({ type: "origin" }, this), this.nodes.push(l));
-      const a = "serialize" in e ? e : g(e, this);
-      if (l) {
-        if (!a.node)
+    addConditional(s, t) {
+      let i = t?.node;
+      this.nodes.length === 0 && (i = h({ type: "origin" }, this), this.nodes.push(i));
+      const l = "serialize" in s ? s : g(s, this);
+      if (i) {
+        if (!l.node)
           throw new Error("todo no node");
-        const c = h(
-          { sourceNode: l, destinationNode: a.node, sourceNodeHandle: null },
+        const u = c(
+          { sourceNode: i, destinationNode: l.node, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return this.conditionals.includes(a) || (this.conditionals.push(a), a.node && this.nodes.push(a.node)), a;
+      return this.conditionals.includes(l) || (this.conditionals.push(l), l.node && this.nodes.push(l.node)), l;
     },
-    addExperience(e, t) {
-      let l = t?.node;
-      this.nodes.length === 0 && (l = f({ type: "origin" }, this), this.nodes.push(l));
-      const a = f(
-        { type: "experience", experience: e },
+    addExperience(s, t) {
+      let i = t?.node;
+      this.nodes.length === 0 && (i = h({ type: "origin" }, this), this.nodes.push(i));
+      const l = h(
+        { type: "experience", experience: s },
         this
       );
-      if (this.nodes.push(a), l) {
-        const c = h(
-          { sourceNode: l, destinationNode: a, sourceNodeHandle: null },
+      if (this.nodes.push(l), i) {
+        const u = c(
+          { sourceNode: i, destinationNode: l, sourceNodeHandle: null },
           this
         );
-        this.edges.push(c);
+        this.edges.push(u);
       }
-      return e;
+      return s;
     },
-    addField(e, t) {
-      const l = "serialize" in e ? e : y(e);
-      return t && t.fields.push(l), this.fields.includes(l) || this.fields.push(l), l;
+    addField(s, t) {
+      const i = "serialize" in s ? s : N(s);
+      return t && t.fields.push(i), this.fields.includes(i) || this.fields.push(i), i;
     },
     serialize() {
-      return r.serialize({
+      return a.serialize({
         id: this.id,
         component: this.component,
         name: this.name,
         initializeOpen: this.initializeOpen,
         condition: this.condition,
         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((s) => a.deserialize(s.serialize())),
+        nodes: this.nodes.map((s) => a.deserialize(s.serialize())),
+        edges: this.edges.map((s) => a.deserialize(s.serialize())),
         conditionals: this.conditionals.map(
-          (e) => r.deserialize(e.serialize())
+          (s) => a.deserialize(s.serialize())
         ),
-        fields: this.fields.map((e) => r.deserialize(e.serialize()))
+        fields: this.fields.map((s) => a.deserialize(s.serialize()))
       });
     }
   };
 };
 export {
   g as createConditional,
-  h as createEdge,
-  E as createExperience,
-  x as createExperiencePlugin,
-  y as createField,
-  f as createNode,
-  V as createStep,
-  r as serialization
+  c as createEdge,
+  V as createExperience,
+  b as createExperiencePlugin,
+  N as createField,
+  h as createNode,
+  x as createStep,
+  a as serialization
 };