@picked/client 0.0.1-dev.1773807602703 → 0.0.1-dev.1774224866171

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

@@ -1,510 +1,425 @@
-import { g as p } from "../../../id-BW-g3y32.js";
-import { l as g } from "../../../logger-C9a75KZn.js";
-const a = {
-  serialize(i) {
-    return JSON.stringify(i);
-  },
-  deserialize(i) {
-    return JSON.parse(i);
-  }
-}, V = (i) => ({
-  name: "create-experience",
-  setup: (s) => {
-    i.experiences.forEach((l) => {
-      l.fields.forEach((r) => {
-        s.registerField(a.deserialize(r.serialize()));
-      }), l.steps.forEach((r) => {
-        s.registerStep(a.deserialize(r.serialize()));
-      });
-      const d = l.serialize(), n = a.deserialize(d);
-      n.component = l.component, s.registerExperience(n);
-    });
-  }
+import { t as e } from "../../../id-CRqy981z.js";
+//#region src/plugins/create-experience/serialization.ts
+var t = {
+	serialize(e) {
+		return JSON.stringify(e);
+	},
+	deserialize(e) {
+		return JSON.parse(e);
+	}
+}, n = (e) => ({
+	name: "create-experience",
+	setup: (n) => {
+		e.experiences.forEach((e) => {
+			let r = e.serialize(), i = t.deserialize(r);
+			i.component = e.component, n.registerExperience(i), i.fields.forEach((e) => {
+				n.registerField(e);
+			});
+		});
+	}
+}), r = (n, r) => ({
+	id: e("node"),
+	experience: r,
+	type: "action",
+	action: n.action,
+	addNext(e) {
+		if (!e.node) throw Error("Cannot connect to node");
+		let t = s({
+			sourceNode: this,
+			destinationNode: e.node,
+			sourceNodeHandle: null
+		}, r);
+		r.edges.push(t);
+	},
+	onSuccess(e) {
+		if (!e.node) throw Error("Cannot connect to node");
+		let t = s({
+			sourceNode: this,
+			destinationNode: e.node,
+			sourceNodeHandle: "true"
+		}, r);
+		r.edges.push(t);
+	},
+	onFail(e) {
+		if (!e.node) throw Error("Cannot connect to node");
+		let t = s({
+			sourceNode: this,
+			destinationNode: e.node,
+			sourceNodeHandle: "false"
+		}, r);
+		r.edges.push(t);
+	},
+	serialize() {
+		return t.serialize({
+			id: this.id,
+			type: this.type,
+			action: this.action
+		});
+	}
+}), i = (t) => ({
+	id: t.id ?? e("step"),
+	label: t.label,
+	fields: t.fields ?? [],
+	addField(e) {
+		let t = "serialize" in e ? e : l(e);
+		return this.fields.includes(t) || this.fields.push(t), t;
+	}
+}), a = (n, r) => {
+	let i = {
+		id: n.id ?? e("step"),
+		label: n.label,
+		experience: r,
+		fields: n.fields ?? [],
+		node: null,
+		nextStep(e) {
+			return this.experience.addStep(e, this);
+		},
+		nextConditional(e) {
+			return this.experience.addConditional(e, this);
+		},
+		addNextExperience(e) {
+			return this.experience.addExperience(e, this);
+		},
+		addField(e) {
+			return this.experience.addField(e, this);
+		},
+		serialize() {
+			return t.serialize({
+				id: this.id,
+				label: this.label,
+				fieldIds: this.fields.map((e) => e.id)
+			});
+		}
+	};
+	return o({
+		step: i,
+		type: "step"
+	}, r), i;
+}, o = (n, r) => {
+	let i = {
+		id: e("node"),
+		experience: r
+	};
+	if (n.type === "step") {
+		let e = {
+			...i,
+			type: "step",
+			connectedStep: n.step,
+			serialize() {
+				return t.serialize({
+					id: this.id,
+					type: this.type,
+					stepId: this.connectedStep.id,
+					label: this.connectedStep.label
+				});
+			}
+		};
+		return e.connectedStep.node = e, e;
+	}
+	if (n.type === "conditional") {
+		let e = {
+			...i,
+			type: "conditional",
+			connectedConditional: n.conditional,
+			serialize() {
+				return t.serialize({
+					id: this.id,
+					type: this.type,
+					conditionalId: this.connectedConditional.id
+				});
+			}
+		};
+		return e.connectedConditional.node = e, e;
+	}
+	return n.type === "experience" ? {
+		...i,
+		type: "experience",
+		connectedExperience: n.experience,
+		serialize() {
+			return t.serialize({
+				id: this.id,
+				type: this.type,
+				experienceId: this.connectedExperience.id
+			});
+		}
+	} : {
+		...i,
+		type: "origin",
+		serialize() {
+			return t.serialize({
+				id: this.id,
+				type: this.type
+			});
+		}
+	};
+}, s = (n, r) => ({
+	id: e("edge"),
+	sourceNode: n.sourceNode,
+	sourceNodeHandle: n.sourceNodeHandle,
+	destinationNode: n.destinationNode,
+	experience: r,
+	serialize() {
+		return t.serialize({
+			id: this.id,
+			sourceNodeHandle: this.sourceNodeHandle ?? void 0,
+			sourceNodeId: this.sourceNode.id,
+			destinationNodeId: this.destinationNode.id
+		});
+	}
+}), c = (n, r) => {
+	let i = {
+		id: e("conditional"),
+		label: n.label,
+		condition: n.condition,
+		node: null,
+		experience: r,
+		addTrue(e) {
+			if (!this.node || !e.node) throw Error("todo no node");
+			let t = s({
+				sourceNode: this.node,
+				destinationNode: e.node,
+				sourceNodeHandle: "true"
+			}, this.experience);
+			this.experience.edges.push(t);
+		},
+		addFalse(e) {
+			if (!this.node || !e.node) throw Error("todo no node");
+			let t = s({
+				sourceNode: this.node,
+				destinationNode: e.node,
+				sourceNodeHandle: "false"
+			}, this.experience);
+			this.experience.edges.push(t);
+		},
+		serialize() {
+			return t.serialize({
+				id: this.id,
+				label: this.label,
+				condition: this.condition
+			});
+		}
+	};
+	return o({
+		conditional: i,
+		type: "conditional"
+	}, r), i;
+}, l = (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: e, ...t }) => ({
+		id: e,
+		...t
+	})) : null,
+	policies: e.policies,
+	serialize() {
+		let e = {
+			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, r = typeof this.defaultValue == "number" ? this.defaultValue : void 0, i = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0, a = (e) => this.options ? this.options.map((t) => ({
+			id: t.id,
+			label: t.label,
+			description: t.description,
+			value: e(t.value),
+			condition: t.condition
+		})) : null;
+		switch (this.type) {
+			case "text":
+				if (this.multiple) {
+					let n;
+					if (Array.isArray(this.defaultValue)) {
+						n = [];
+						for (let e of this.defaultValue) typeof e == "string" && n.push(e);
+						n.length === 0 && (n = void 0);
+					}
+					return t.serialize({
+						...e,
+						type: "text",
+						multiple: !0,
+						defaultValue: n,
+						options: a((e) => `${e}`)
+					});
+				}
+				return t.serialize({
+					...e,
+					type: "text",
+					multiple: !1,
+					defaultValue: n,
+					options: a((e) => `${e}`)
+				});
+			case "number":
+				if (this.multiple) {
+					let n;
+					if (Array.isArray(this.defaultValue)) {
+						n = [];
+						for (let e of this.defaultValue) typeof e == "number" && n.push(e);
+						n.length === 0 && (n = void 0);
+					}
+					return t.serialize({
+						...e,
+						type: "number",
+						multiple: !0,
+						defaultValue: n,
+						options: a((e) => Number(e))
+					});
+				}
+				return t.serialize({
+					...e,
+					type: "number",
+					multiple: !1,
+					defaultValue: r,
+					options: a((e) => Number(e))
+				});
+			case "boolean":
+				if (this.multiple) {
+					let n;
+					if (Array.isArray(this.defaultValue)) {
+						n = [];
+						for (let e of this.defaultValue) typeof e == "boolean" && n.push(e);
+						n.length === 0 && (n = void 0);
+					}
+					return t.serialize({
+						...e,
+						type: "boolean",
+						multiple: !0,
+						defaultValue: n,
+						options: a((e) => !!e)
+					});
+				}
+				return t.serialize({
+					...e,
+					type: "boolean",
+					multiple: !1,
+					defaultValue: i,
+					options: a((e) => !!e)
+				});
+			case "object": return this.multiple ? t.serialize({
+				...e,
+				type: "object",
+				multiple: !0,
+				defaultValue: this.defaultValue,
+				options: a((e) => e)
+			}) : t.serialize({
+				...e,
+				type: "object",
+				multiple: !1,
+				defaultValue: this.defaultValue,
+				options: a((e) => e)
+			});
+			default: throw Error("Unsupported field type");
+		}
+	}
+}), u = (e) => ({
+	id: e.id,
+	component: e.component,
+	name: e.name,
+	initializeOpen: e.initializeOpen,
+	condition: e.condition,
+	targets: e.targets,
+	steps: [],
+	nodes: [],
+	edges: [],
+	fields: [],
+	conditionals: [],
+	addStep(e, t) {
+		let n = t?.node;
+		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
+		let r = "serialize" in e ? e : a(e, this);
+		if (n) {
+			if (!r.node) throw Error("todo no node");
+			let e = s({
+				sourceNode: n,
+				destinationNode: r.node,
+				sourceNodeHandle: null
+			}, this);
+			this.edges.push(e);
+		}
+		return r.fields.length > 0 && r.fields.forEach((e) => {
+			this.fields.includes(e) || this.fields.push(e);
+		}), this.steps.includes(r) || (this.steps.push(r), r.node && this.nodes.push(r.node)), r;
+	},
+	addAction(e, t) {
+		let n = t?.node;
+		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
+		let i = "serialize" in e ? e : r(e, this);
+		if (n) {
+			let e = s({
+				sourceNode: n,
+				destinationNode: i,
+				sourceNodeHandle: null
+			}, this);
+			this.edges.push(e);
+		}
+		return this.nodes.push(i), i;
+	},
+	addConditional(e, t) {
+		let n = t?.node;
+		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
+		let r = "serialize" in e ? e : c(e, this);
+		if (n) {
+			if (!r.node) throw Error("todo no node");
+			let e = s({
+				sourceNode: n,
+				destinationNode: r.node,
+				sourceNodeHandle: null
+			}, this);
+			this.edges.push(e);
+		}
+		return this.conditionals.includes(r) || (this.conditionals.push(r), r.node && this.nodes.push(r.node)), r;
+	},
+	addExperience(e, t) {
+		let n = t?.node;
+		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
+		let r = o({
+			type: "experience",
+			experience: e
+		}, this);
+		if (this.nodes.push(r), n) {
+			let e = s({
+				sourceNode: n,
+				destinationNode: r,
+				sourceNodeHandle: null
+			}, this);
+			this.edges.push(e);
+		}
+		return e;
+	},
+	addField(e, t) {
+		let n = "serialize" in e ? e : l(e);
+		return t && t.fields.push(n), this.fields.includes(n) || this.fields.push(n), n;
+	},
+	serialize() {
+		return t.serialize({
+			id: this.id,
+			component: this.component,
+			name: this.name,
+			initializeOpen: this.initializeOpen,
+			condition: this.condition,
+			targets: this.targets,
+			steps: this.steps.map((e) => t.deserialize(e.serialize())),
+			nodes: this.nodes.map((e) => t.deserialize(e.serialize())),
+			edges: this.edges.map((e) => t.deserialize(e.serialize())),
+			conditionals: this.conditionals.map((e) => t.deserialize(e.serialize())),
+			fields: this.fields.map((e) => t.deserialize(e.serialize()))
+		});
+	}
 });
-function m(i) {
-  return i.toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").trim().replaceAll(/\s+/g, "-");
-}
-const z = (i, s) => ({
-  id: p("node"),
-  experience: s,
-  type: "action",
-  action: i.action,
-  addNext(d) {
-    if (!d.node) throw new Error("Cannot connect to node");
-    const n = h(
-      { sourceNode: this, destinationNode: d.node, sourceNodeHandle: null },
-      s
-    );
-    s.edges.push(n);
-  },
-  onSuccess(d) {
-    if (!d.node) throw new Error("Cannot connect to node");
-    const n = h(
-      { sourceNode: this, destinationNode: d.node, sourceNodeHandle: "true" },
-      s
-    );
-    s.edges.push(n);
-  },
-  onFail(d) {
-    if (!d.node) throw new Error("Cannot connect to node");
-    const n = h(
-      { sourceNode: this, destinationNode: d.node, sourceNodeHandle: "false" },
-      s
-    );
-    s.edges.push(n);
-  },
-  serialize() {
-    return a.serialize({
-      id: this.id,
-      type: this.type,
-      action: this.action
-    });
-  }
-}), E = (i) => {
-  const s = i.name ?? i.label ?? "", l = i.key ?? i.id ?? m(s);
-  return {
-    id: i.id ?? p("step"),
-    name: s,
-    key: l,
-    label: s,
-    fields: i.fields ?? [],
-    addField(d) {
-      const n = "serialize" in d ? d : N(d);
-      return this.fields.includes(n) || this.fields.push(n), n;
-    }
-  };
-}, b = (i, s) => {
-  const l = i.name ?? i.label ?? "", d = i.key ?? i.id ?? m(l), n = {
-    id: i.id ?? p("step"),
-    name: l,
-    key: d,
-    label: l,
-    experience: s,
-    fields: i.fields ?? [],
-    node: null,
-    nextStep(r) {
-      return this.experience.addStep(r, this);
-    },
-    nextCondition(r) {
-      return this.experience.addCondition(r, this);
-    },
-    nextConditional(r) {
-      return this.experience.addCondition(r, this);
-    },
-    addNextExperience(r) {
-      return this.experience.addExperience(r, this);
-    },
-    addField(r) {
-      return this.experience.addField(r, this);
-    },
-    serialize() {
-      return a.serialize({
-        id: this.id,
-        name: this.name,
-        key: this.key,
-        label: this.name,
-        fieldKeys: this.fields.map((r) => r.key),
-        fieldIds: this.fields.map((r) => r.id)
-      });
-    }
-  };
-  return f({ step: n, type: "step" }, s), n;
-}, f = (i, s) => {
-  const l = {
-    id: p("node"),
-    experience: s
-  };
-  if (i.type === "step") {
-    const n = {
-      ...l,
-      type: "step",
-      connectedStep: i.step,
-      serialize() {
-        return a.serialize({
-          id: this.id,
-          type: this.type,
-          stepKey: this.connectedStep.key,
-          stepId: this.connectedStep.key,
-          name: this.connectedStep.name,
-          label: this.connectedStep.name
-        });
-      }
-    };
-    return n.connectedStep.node = n, n;
-  }
-  if (i.type === "conditional") {
-    const n = {
-      ...l,
-      type: "conditional",
-      connectedCondition: i.conditional,
-      serialize() {
-        return a.serialize({
-          id: this.id,
-          type: this.type,
-          conditionId: this.connectedCondition.id
-        });
-      }
-    };
-    return n.connectedCondition.node = n, n;
-  }
-  return i.type === "experience" ? {
-    ...l,
-    type: "experience",
-    connectedExperience: i.experience,
-    serialize() {
-      return a.serialize({
-        id: this.id,
-        type: this.type,
-        experienceId: this.connectedExperience.id
-      });
-    }
-  } : {
-    ...l,
-    type: "origin",
-    serialize() {
-      return a.serialize({
-        id: this.id,
-        type: this.type
-      });
-    }
-  };
-}, h = (i, s) => ({
-  id: p("edge"),
-  sourceNode: i.sourceNode,
-  sourceNodeHandle: i.sourceNodeHandle,
-  destinationNode: i.destinationNode,
-  experience: s,
-  serialize() {
-    return a.serialize({
-      id: this.id,
-      sourceNodeHandle: this.sourceNodeHandle ?? void 0,
-      sourceNodeId: this.sourceNode.id,
-      destinationNodeId: this.destinationNode.id
-    });
-  }
-}), y = (i, s) => {
-  const l = {
-    id: p("conditional"),
-    label: i.label,
-    condition: i.condition,
-    node: null,
-    experience: s,
-    addTrue(d) {
-      if (!this.node || !d.node)
-        throw new Error("todo no node");
-      const n = h(
-        { sourceNode: this.node, destinationNode: d.node, sourceNodeHandle: "true" },
-        this.experience
-      );
-      this.experience.edges.push(n);
-    },
-    addFalse(d) {
-      if (!this.node || !d.node)
-        throw new Error("todo no node");
-      const n = h(
-        { sourceNode: this.node, destinationNode: d.node, sourceNodeHandle: "false" },
-        this.experience
-      );
-      this.experience.edges.push(n);
-    },
-    serialize() {
-      return a.serialize({
-        id: this.id,
-        label: this.label,
-        condition: this.condition
-      });
-    }
-  };
-  return f({ conditional: l, type: "conditional" }, s), l;
-};
-function w(...i) {
-  return y(...i);
-}
-const N = (i) => {
-  const s = i.key ?? i.id ?? m(i.name);
-  return i.id !== void 0 && g(
-    "warn",
-    // eslint-disable-next-line sonarjs/deprecation -- reading deprecated id to build deprecation message
-    `createField: 'id' is deprecated. Use 'key' instead of id="${i.id}". The field key "${s}" will be used for lookups.`
-  ), {
-    id: i.id ?? p("field"),
-    key: s,
-    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"),
-      ...n
-    })) ?? null,
-    policies: i.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 = {
-        id: this.id,
-        key: this.key,
-        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, o = typeof this.defaultValue == "number" ? this.defaultValue : void 0, u = 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 t of this.defaultValue)
-                typeof t == "string" && e.push(t);
-              e.length === 0 && (e = void 0);
-            }
-            return a.serialize({
-              ...n,
-              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
-            });
-          }
-          return a.serialize({
-            ...n,
-            type: "text",
-            multiple: !1,
-            defaultValue: r,
-            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 t of this.defaultValue)
-                typeof t == "number" && e.push(t);
-              e.length === 0 && (e = void 0);
-            }
-            return a.serialize({
-              ...n,
-              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
-            });
-          }
-          return a.serialize({
-            ...n,
-            type: "number",
-            multiple: !1,
-            defaultValue: o,
-            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 t of this.defaultValue)
-                typeof t == "boolean" && e.push(t);
-              e.length === 0 && (e = void 0);
-            }
-            return a.serialize({
-              ...n,
-              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
-            });
-          }
-          return a.serialize({
-            ...n,
-            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
-          });
-        case "object":
-          return this.multiple ? a.serialize({
-            ...n,
-            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
-          }) : a.serialize({
-            ...n,
-            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
-          });
-        default:
-          throw new Error("Unsupported field type");
-      }
-    }
-  };
-}, k = (i) => {
-  const s = [], l = [], d = [], n = [], r = [];
-  return {
-    id: i.id,
-    component: i.component,
-    name: i.name,
-    initializeOpen: i.initializeOpen,
-    condition: i.condition,
-    targets: i.targets,
-    steps: s,
-    nodes: l,
-    edges: d,
-    fields: r,
-    conditions: n,
-    get conditionals() {
-      return this.conditions;
-    },
-    addStep(o, u) {
-      let e = u?.node;
-      this.nodes.length === 0 && (e = f({ type: "origin" }, this), this.nodes.push(e));
-      const t = "serialize" in o ? o : b(o, this);
-      if (e) {
-        if (!t.node)
-          throw new Error("todo no node");
-        const c = h(
-          { sourceNode: e, destinationNode: t.node, sourceNodeHandle: null },
-          this
-        );
-        this.edges.push(c);
-      }
-      return t.fields.length > 0 && t.fields.forEach((c) => {
-        this.fields.includes(c) || this.fields.push(c);
-      }), this.steps.includes(t) || (this.steps.push(t), t.node && this.nodes.push(t.node)), t;
-    },
-    addAction(o, u) {
-      let e = u?.node;
-      this.nodes.length === 0 && (e = f({ type: "origin" }, this), this.nodes.push(e));
-      const t = "serialize" in o ? o : z(o, this);
-      if (e) {
-        const c = h(
-          { sourceNode: e, destinationNode: t, sourceNodeHandle: null },
-          this
-        );
-        this.edges.push(c);
-      }
-      return this.nodes.push(t), t;
-    },
-    addCondition(o, u) {
-      let e = u?.node;
-      this.nodes.length === 0 && (e = f({ type: "origin" }, this), this.nodes.push(e));
-      const t = "serialize" in o ? o : y(o, this);
-      if (e) {
-        if (!t.node)
-          throw new Error("todo no node");
-        const c = h(
-          { sourceNode: e, destinationNode: t.node, sourceNodeHandle: null },
-          this
-        );
-        this.edges.push(c);
-      }
-      return this.conditions.includes(t) || (this.conditions.push(t), t.node && this.nodes.push(t.node)), t;
-    },
-    addConditional(o, u) {
-      return this.addCondition(o, u);
-    },
-    addExperience(o, u) {
-      let e = u?.node;
-      this.nodes.length === 0 && (e = f({ type: "origin" }, this), this.nodes.push(e));
-      const t = f(
-        { type: "experience", experience: o },
-        this
-      );
-      if (this.nodes.push(t), e) {
-        const c = h(
-          { sourceNode: e, destinationNode: t, sourceNodeHandle: null },
-          this
-        );
-        this.edges.push(c);
-      }
-      return o;
-    },
-    addField(o, u) {
-      const e = "serialize" in o ? o : N(o);
-      return u && u.fields.push(e), this.fields.includes(e) || this.fields.push(e), e;
-    },
-    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((o) => o.id),
-        nodes: this.nodes.map((o) => a.deserialize(o.serialize())),
-        edges: this.edges.map((o) => a.deserialize(o.serialize())),
-        conditions: this.conditions.map(
-          (o) => a.deserialize(o.serialize())
-        )
-      });
-    }
-  };
-};
-export {
-  y as createCondition,
-  w as createConditional,
-  h as createEdge,
-  k as createExperience,
-  V as createExperiencePlugin,
-  N as createField,
-  f as createNode,
-  E as createStep,
-  a as serialization
-};
+//#endregion
+export { c as createConditional, s as createEdge, u as createExperience, n as createExperiencePlugin, l as createField, o as createNode, i as createStep, t as serialization };