@8wave/ai-elements 0.104.0-beta.1 → 0.105.0-beta.1

package/dist/_chunks/index.es-CnpsLhp_.js

@@ -0,0 +1,1006 @@
+import { C as e, E as t, F as n, G as r, O as i, P as a, R as o, S as s, V as c, X as l, at as u, bt as d, ft as f, gt as p, it as m, k as h, m as g, pt as _, r as v, u as y, vt as b, w as x, yt as S } from "./vue.runtime.esm-bundler-D6KKITU0.js";
+import { r as C } from "./vue-i18n-C3J36GV4.js";
+import { t as w } from "./src-Co0-iQeD.js";
+import { _ as T, g as E, u as D } from "./dist-vbhhaYbZ.js";
+import { n as O, t as k } from "./dot-prop-BEIkPL0b.js";
+import { D as A, E as j, O as M, k as N } from "./schemas-U769m8P5.js";
+//#region ../../packages/composable/src/useSafeLocalStorage.ts
+m();
+function P(e, t) {
+	try {
+		return window.localStorage.getItem(""), D(e, t);
+	} catch (e) {
+		return w.warn("[useSafeLocalStorage] localStorage blocked, falling back to in-memory ref", e), _(t);
+	}
+}
+//#endregion
+//#region ../../packages/composable/src/useLocalizedString.ts
+i(), m();
+function F(e, t) {
+	let { locale: n, t: r, te: i } = C({ useScope: "global" });
+	return g(() => {
+		let a = S(e), o = t !== void 0 && i(t) ? r(t) : void 0;
+		return a && a[n.value] || o;
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v3/helpers/util.js
+var I;
+(function(e) {
+	e.assertEqual = (e) => {};
+	function t(e) {}
+	e.assertIs = t;
+	function n(e) {
+		throw Error();
+	}
+	e.assertNever = n, e.arrayToEnum = (e) => {
+		let t = {};
+		for (let n of e) t[n] = n;
+		return t;
+	}, e.getValidEnumValues = (t) => {
+		let n = e.objectKeys(t).filter((e) => typeof t[t[e]] != "number"), r = {};
+		for (let e of n) r[e] = t[e];
+		return e.objectValues(r);
+	}, e.objectValues = (t) => e.objectKeys(t).map(function(e) {
+		return t[e];
+	}), e.objectKeys = typeof Object.keys == "function" ? (e) => Object.keys(e) : (e) => {
+		let t = [];
+		for (let n in e) Object.prototype.hasOwnProperty.call(e, n) && t.push(n);
+		return t;
+	}, e.find = (e, t) => {
+		for (let n of e) if (t(n)) return n;
+	}, e.isInteger = typeof Number.isInteger == "function" ? (e) => Number.isInteger(e) : (e) => typeof e == "number" && Number.isFinite(e) && Math.floor(e) === e;
+	function r(e, t = " | ") {
+		return e.map((e) => typeof e == "string" ? `'${e}'` : e).join(t);
+	}
+	e.joinValues = r, e.jsonStringifyReplacer = (e, t) => typeof t == "bigint" ? t.toString() : t;
+})(I ||= {});
+var L;
+(function(e) {
+	e.mergeShapes = (e, t) => ({
+		...e,
+		...t
+	});
+})(L ||= {}), I.arrayToEnum([
+	"string",
+	"nan",
+	"number",
+	"integer",
+	"float",
+	"boolean",
+	"date",
+	"bigint",
+	"symbol",
+	"function",
+	"undefined",
+	"null",
+	"array",
+	"object",
+	"unknown",
+	"promise",
+	"void",
+	"never",
+	"map",
+	"set"
+]), I.arrayToEnum([
+	"invalid_type",
+	"invalid_literal",
+	"custom",
+	"invalid_union",
+	"invalid_union_discriminator",
+	"invalid_enum_value",
+	"unrecognized_keys",
+	"invalid_arguments",
+	"invalid_return_type",
+	"invalid_date",
+	"invalid_string",
+	"too_small",
+	"too_big",
+	"invalid_intersection_types",
+	"not_multiple_of",
+	"not_finite"
+]);
+var R = class e extends Error {
+	get errors() {
+		return this.issues;
+	}
+	constructor(e) {
+		super(), this.issues = [], this.addIssue = (e) => {
+			this.issues = [...this.issues, e];
+		}, this.addIssues = (e = []) => {
+			this.issues = [...this.issues, ...e];
+		};
+		let t = new.target.prototype;
+		Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+	}
+	format(e) {
+		let t = e || function(e) {
+			return e.message;
+		}, n = { _errors: [] }, r = (e) => {
+			for (let i of e.issues) if (i.code === "invalid_union") i.unionErrors.map(r);
+			else if (i.code === "invalid_return_type") r(i.returnTypeError);
+			else if (i.code === "invalid_arguments") r(i.argumentsError);
+			else if (i.path.length === 0) n._errors.push(t(i));
+			else {
+				let e = n, r = 0;
+				for (; r < i.path.length;) {
+					let n = i.path[r], a = r === i.path.length - 1;
+					if (n === "_errors") {
+						a && e._errors.push(t(i)), r++;
+						continue;
+					}
+					Object.prototype.hasOwnProperty.call(e, n) || (n === "__proto__" ? Object.defineProperty(e, n, {
+						value: { _errors: [] },
+						writable: !0,
+						enumerable: !0,
+						configurable: !0
+					}) : e[n] = { _errors: [] }), e = e[n], a && e._errors.push(t(i)), r++;
+				}
+			}
+		};
+		return r(this), n;
+	}
+	static assert(t) {
+		if (!(t instanceof e)) throw Error(`Not a ZodError: ${t}`);
+	}
+	toString() {
+		return this.message;
+	}
+	get message() {
+		return JSON.stringify(this.issues, I.jsonStringifyReplacer, 2);
+	}
+	get isEmpty() {
+		return this.issues.length === 0;
+	}
+	flatten(e = (e) => e.message) {
+		let t = Object.create(null), n = [];
+		for (let r of this.issues) if (r.path.length > 0) {
+			let n = r.path[0];
+			t[n] = t[n] || [], t[n].push(e(r));
+		} else n.push(e(r));
+		return {
+			formErrors: n,
+			fieldErrors: t
+		};
+	}
+	get formErrors() {
+		return this.flatten();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@volverjs+form-vue@1.1.5_@volverjs+ui-vue@0.0.18_@json-render+core@0.19.0_zod@4.5.4__@v_edf01ce1f50ea1c1fdfa716abcb63f61/node_modules/@volverjs/form-vue/dist/index.es.js
+R.create = (e) => new R(e), i(), m(), v();
+var z = /* @__PURE__ */ function(e) {
+	return e.text = "text", e.number = "number", e.email = "email", e.password = "password", e.tel = "tel", e.url = "url", e.search = "search", e.date = "date", e.time = "time", e.datetimeLocal = "datetime-local", e.month = "month", e.week = "week", e.color = "color", e.select = "select", e.checkbox = "checkbox", e.radio = "radio", e.textarea = "textarea", e.radioGroup = "radioGroup", e.checkboxGroup = "checkboxGroup", e.combobox = "combobox", e.custom = "custom", e;
+}({}), B = /* @__PURE__ */ function(e) {
+	return e.invalid = "invalid", e.valid = "valid", e.submitting = "submitting", e.reset = "reset", e.updated = "updated", e.unknown = "unknown", e;
+}({}), V = (e) => e._def.typeName === "ZodObject", H = (e) => e._zod.def.type === "object", ee = (e) => e._def.typeName === "ZodDefault", te = (e) => e._zod.def.type === "default", ne = (e) => e._def.typeName === "ZodNullable", re = (e) => e._zod.def.type === "nullable", ie = (e) => e._def.typeName === "ZodRecord", ae = (e) => e._zod.def.type === "record", oe = (e) => e._def.typeName === "ZodArray", U = (e) => e._zod.def.type === "array", W = (e) => e._def.typeName === "ZodEffects", G = (e) => e._def.typeName === "ZodOptional", K = (e) => e._zod.def.type === "optional", se = (e) => e._zod.def.type === "pipe", ce = (e) => e._zod.def.type === "transform";
+function q(e) {
+	let t = e;
+	for (; W(t);) t = t.innerType();
+	return t;
+}
+function J(e) {
+	let t = e;
+	for (; se(t);) t = ce(t._zod.def.out) ? t._zod.def.in : t._zod.def.out;
+	return t;
+}
+var le = (e) => {
+	let t = q(e);
+	return G(t) && (t = t._def.innerType), t;
+}, ue = (e) => {
+	let t = J(e);
+	return K(t) && (t = t._zod.def.innerType), t;
+}, de = (e) => !!G(q(e)), fe = (e) => !!K(J(e)), Y = (e) => "_zod" in e, pe = {
+	getInnerType: le,
+	isObject: V,
+	hasUnknownKeys: (e) => e._def.unknownKeys === "passthrough",
+	getShapeEntries: (e) => "shape" in e ? Object.entries(e.shape) : [],
+	isOptional: de,
+	isDefault: ee,
+	getDefaultValue: (e) => e._def.defaultValue(),
+	getDefaultInnerType: (e) => e._def.innerType,
+	isNullable: ne,
+	safeParse: (e, t) => e.safeParse(t),
+	isArray: oe,
+	getArrayElement: (e) => e._def.type,
+	isRecord: ie,
+	getRecordValue: (e) => e._def.valueType
+}, me = {
+	getInnerType: ue,
+	isObject: H,
+	hasUnknownKeys: (e) => !!(e._zod.def.catchall && e._zod.def.catchall._zod.def.type !== "never"),
+	getShapeEntries: (e) => "shape" in e._zod.def ? Object.entries(e._zod.def.shape) : [],
+	isOptional: fe,
+	isDefault: te,
+	getDefaultValue: (e) => e._zod.def.defaultValue,
+	getDefaultInnerType: (e) => e._zod.def.innerType,
+	isNullable: re,
+	safeParse: (e, t) => j(e, t),
+	isArray: U,
+	getArrayElement: (e) => e._zod.def.element,
+	isRecord: ae,
+	getRecordValue: (e) => e._zod.def.valueType
+};
+function he(e, t, n) {
+	let r = e.getInnerType(e.getArrayElement(t));
+	return e.isObject(r) ? n.map((t) => X(e, r, t)) : n;
+}
+function ge(e, t, n) {
+	let r = e.getInnerType(e.getRecordValue(t));
+	return e.isObject(r) ? Object.keys(n).reduce((t, i) => (t[i] = X(e, r, n[i]), t), {}) : n;
+}
+function _e(e, t, n, r) {
+	let i = e.isOptional(n), a = e.getInnerType(n), o;
+	if (e.isDefault(a) && (o = e.getDefaultValue(a), a = e.getDefaultInnerType(a)), r === null && e.isNullable(a)) return [t, r];
+	if (r == null && i) return [t, o];
+	if (a && r !== void 0) {
+		let i = e.safeParse(n, r);
+		if (i.success) return [t, i.data ?? o];
+	}
+	return e.isArray(a) && Array.isArray(r) ? [t, he(e, a, r)] : e.isRecord(a) && r ? [t, ge(e, a, r)] : e.isObject(a) ? [t, X(e, a, r && typeof r == "object" ? r : o)] : [t, o];
+}
+function X(e, t, n) {
+	let r = n && typeof n == "object" && !Array.isArray(n) ? n : {};
+	return {
+		...e.hasUnknownKeys(t) ? r : {},
+		...Object.fromEntries(e.getShapeEntries(t).map(([t, n]) => _e(e, t, n, r[t])))
+	};
+}
+function ve(e, t = {}) {
+	let n = Y(e) ? me : pe, r = n.getInnerType(e);
+	return n.isObject(r) ? X(n, r, t) : t;
+}
+var ye = (e, t) => Y(e) ? A(e, t) : e.safeParseAsync(t), be = (e, t) => Y(e) ? N(t) : t.format(), xe = (e, t) => Y(e) ? N(new M(t)) : new R(t).format();
+function Se(r, i, a, s, c) {
+	let d = _(), m = _(), h = g(() => m.value === B.invalid), v = _(), b = _(!1), x, S = (e) => {
+		let t = ve(r, e);
+		if (a?.class) {
+			let e = a.class;
+			return new e(t);
+		}
+		return t;
+	}, C = async (e = v.value, t) => {
+		if (x = t?.fields, b.value) return !0;
+		let n = await ye(r, e);
+		if (!n.success) {
+			if (m.value = B.invalid, !x?.size) return d.value = be(r, n.error), !1;
+			let e = n.error.issues.filter((e) => x?.has(e.path.join(".")));
+			return e.length ? (d.value = xe(r, e), !1) : (d.value = void 0, !0);
+		}
+		return d.value = void 0, m.value = B.valid, v.value = S(n.data), !0;
+	}, w = () => {
+		d.value = void 0, m.value = void 0, x = void 0;
+	}, { ignoreUpdates: D, stop: O } = T(v, () => {
+		m.value = B.updated;
+	}, {
+		deep: !0,
+		eventFilter: E(a?.updateThrottle ?? 500)
+	}), k = () => {
+		D(() => {
+			v.value = S();
+		}), w(), m.value = B.reset;
+	}, A = async (e) => b.value || !await C(void 0, e) ? !1 : (m.value = B.submitting, !0), j = f(d), M = f(m);
+	return {
+		clear: w,
+		errors: d,
+		formData: v,
+		ignoreUpdates: D,
+		invalid: h,
+		readonly: b,
+		reset: k,
+		status: m,
+		wrappers: c,
+		stopUpdatesWatch: O,
+		submit: A,
+		validate: C,
+		VvForm: e({
+			name: "VvForm",
+			props: {
+				continuousValidation: {
+					type: Boolean,
+					default: !1
+				},
+				modelValue: {
+					type: Object,
+					default: () => ({})
+				},
+				readonly: {
+					type: Boolean,
+					default: a?.readonly
+				},
+				tag: {
+					type: String,
+					default: "form"
+				},
+				template: {
+					type: [Array, Function],
+					default: void 0
+				},
+				superRefine: {
+					type: Function,
+					default: void 0
+				},
+				validateFields: {
+					type: Array,
+					default: void 0
+				}
+			},
+			emits: [
+				"invalid",
+				"submit",
+				"update:modelValue",
+				"update:readonly",
+				"valid",
+				"reset"
+			],
+			expose: [
+				"errors",
+				"invalid",
+				"readonly",
+				"status",
+				"submit",
+				"tag",
+				"template",
+				"valid",
+				"validate",
+				"clear",
+				"reset"
+			],
+			slots: Object,
+			setup(e, { emit: t }) {
+				return v.value = S(p(e.modelValue)), l(() => e.modelValue, (e) => {
+					if (e) {
+						let t = u(e) ? p(e) : e;
+						if (JSON.stringify(t) === JSON.stringify(p(v.value))) return;
+						v.value = S(t);
+					}
+				}, { deep: !0 }), l(m, async (n) => {
+					if (n === B.invalid) {
+						let e = p(d.value);
+						t("invalid", e), a?.onInvalid?.(e);
+						return;
+					}
+					if (n === B.valid) {
+						let e = p(v.value);
+						t("valid", e), a?.onValid?.(e), t("update:modelValue", e), a?.onUpdate?.(e);
+						return;
+					}
+					if (n === B.submitting) {
+						let e = p(v.value);
+						t("submit", e), a?.onSubmit?.(e);
+						return;
+					}
+					if (n === B.reset) {
+						let e = p(v.value);
+						t("reset", e), a?.onReset?.(e);
+						return;
+					}
+					if (n === B.updated) {
+						if ((d.value || a?.continuousValidation || e.continuousValidation) && await C(void 0, {
+							superRefine: e.superRefine,
+							fields: x ?? new Set(e.validateFields)
+						}), !v.value || !e.modelValue || JSON.stringify(v.value) !== JSON.stringify(e.modelValue)) {
+							let e = p(v.value);
+							t("update:modelValue", e), a?.onUpdate?.(e);
+						}
+						m.value === B.updated && (m.value = B.unknown);
+					}
+				}), n(() => {
+					e.readonly !== void 0 && (b.value = e.readonly);
+				}), l(() => e.readonly, (e) => {
+					b.value = e;
+				}), l(b, (n) => {
+					n !== e.readonly && t("update:readonly", b.value);
+				}), o(i, {
+					clear: w,
+					errors: j,
+					formData: v,
+					ignoreUpdates: D,
+					invalid: h,
+					readonly: b,
+					reset: k,
+					status: M,
+					stopUpdatesWatch: O,
+					submit: A,
+					validate: C,
+					wrappers: c
+				}), {
+					clear: w,
+					errors: j,
+					formData: v,
+					ignoreUpdates: D,
+					invalid: h,
+					isReadonly: b,
+					reset: k,
+					status: M,
+					stopUpdatesWatch: O,
+					submit: () => A({
+						superRefine: e.superRefine,
+						fields: new Set(e.validateFields)
+					}),
+					validate: C,
+					wrappers: c
+				};
+			},
+			render() {
+				let e = () => this.$slots?.default?.({
+					errors: j.value,
+					formData: v.value,
+					invalid: h.value,
+					readonly: b.value,
+					status: M.value,
+					wrappers: c,
+					clear: w,
+					ignoreUpdates: D,
+					reset: k,
+					stopUpdatesWatch: O,
+					submit: A,
+					validate: C
+				}) ?? this.$slots.default;
+				return t(this.tag, {
+					onSubmit: y(this.submit, ["prevent"]),
+					onReset: y(this.reset, ["prevent"])
+				}, (this.template ?? a?.template) && s ? [t(s, { schema: this.template ?? a?.template }, { default: e })] : { default: e });
+			}
+		})
+	};
+}
+function Z(i, u, p, m) {
+	return e({
+		name: "VvFormField",
+		props: {
+			type: {
+				type: String,
+				validator: (e) => Object.values(z).includes(e),
+				default: z.custom
+			},
+			is: {
+				type: [Object, String],
+				default: void 0
+			},
+			name: {
+				type: [
+					String,
+					Number,
+					Boolean,
+					Symbol
+				],
+				required: !0
+			},
+			props: {
+				type: [Object, Function],
+				default: () => ({})
+			},
+			showValid: {
+				type: Boolean,
+				default: !1
+			},
+			defaultValue: {
+				type: [
+					String,
+					Number,
+					Boolean,
+					Array,
+					Object
+				],
+				default: void 0
+			},
+			lazyLoad: {
+				type: Boolean,
+				default: !1
+			},
+			readonly: {
+				type: Boolean,
+				default: void 0
+			}
+		},
+		emits: [
+			"invalid",
+			"update:formData",
+			"update:modelValue",
+			"valid"
+		],
+		expose: [
+			"component",
+			"errors",
+			"hasProps",
+			"invalid",
+			"invalidLabel",
+			"is",
+			"type"
+		],
+		slots: Object,
+		setup(e, { slots: t, emit: _ }) {
+			let { props: v, name: y } = b(e), x = r(), S = h(u, void 0);
+			S && S.fields.value.set(x, e.name);
+			let C = h(i), w = g({
+				get() {
+					if (C?.formData) return k(new Object(C.formData.value), String(e.name));
+				},
+				set(t) {
+					C?.formData && (O(new Object(C.formData.value), String(e.name), t), _("update:modelValue", {
+						newValue: w.value,
+						formData: C?.formData
+					}));
+				}
+			});
+			n(() => {
+				w.value === void 0 && e.defaultValue !== void 0 && (w.value = e.defaultValue);
+			}), a(() => {
+				S && S.fields.value.delete(x);
+			});
+			let T = g(() => {
+				if (C?.errors.value) return k(C.errors.value, String(e.name));
+			}), E = g(() => T.value?._errors), D = g(() => T.value !== void 0), A = l(D, (t) => {
+				if (t) {
+					_("invalid", T.value), S && S.errors.value.set(String(e.name), T.value);
+					return;
+				}
+				_("valid", w.value), S && S.errors.value.delete(e.name);
+			}), j = l(() => C?.formData, () => {
+				_("update:formData", C?.formData);
+			}, { deep: !0 });
+			a(() => {
+				A(), j();
+			});
+			let M = (e) => {
+				e instanceof InputEvent && (e = e.target.value), w.value = e;
+			}, N = g(() => {
+				let e = v.value;
+				return typeof e == "function" && (e = e(C?.formData)), Object.keys(e).reduce((t, n) => (t[n] = d(e[n]), t), {});
+			}), P = g(() => C?.readonly.value || S?.readonly.value ? !0 : N.value.readonly ?? e.readonly), F = g(() => ({
+				...N.value,
+				name: N.value.name ?? e.name,
+				invalid: D.value,
+				valid: e.showValid ? !!(!D.value && w.value) : void 0,
+				type: ((e) => {
+					if ([
+						z.color,
+						z.date,
+						z.datetimeLocal,
+						z.email,
+						z.month,
+						z.number,
+						z.password,
+						z.search,
+						z.tel,
+						z.text,
+						z.time,
+						z.url,
+						z.week
+					].includes(e)) return e;
+				})(e.type),
+				invalidLabel: E.value,
+				modelValue: w.value,
+				readonly: P.value,
+				"onUpdate:modelValue": M
+			}));
+			return o(p, {
+				name: f(y),
+				errors: f(T)
+			}), {
+				component: g(() => {
+					if (e.type === z.custom) return { render() {
+						return t.default?.({
+							errors: f(T).value,
+							formData: C?.formData.value,
+							formErrors: C?.errors.value,
+							invalid: D.value,
+							invalidLabel: E.value,
+							modelValue: w.value,
+							readonly: P.value,
+							onUpdate: M,
+							submit: C?.submit,
+							validate: C?.validate
+						}) ?? t.default;
+					} };
+					if (!(m?.lazyLoad ?? e.lazyLoad)) {
+						let t;
+						switch (e.type) {
+							case z.select:
+								t = c("VvSelect");
+								break;
+							case z.checkbox:
+								t = c("VvCheckbox");
+								break;
+							case z.radio:
+								t = c("VvRadio");
+								break;
+							case z.textarea:
+								t = c("VvTextarea");
+								break;
+							case z.radioGroup:
+								t = c("VvRadioGroup");
+								break;
+							case z.checkboxGroup:
+								t = c("VvCheckboxGroup");
+								break;
+							case z.combobox:
+								t = c("VvCombobox");
+								break;
+							default: t = c("VvInputText");
+						}
+						if (typeof t != "string") return t;
+						console.warn(`[@volverjs/form-vue]: ${t} not found, the component will be loaded asynchronously. To avoid this warning, please set "lazyLoad" option.`);
+					}
+					return s(async () => {
+						switch (m?.sideEffects && await Promise.resolve(m.sideEffects(e.type)), e.type) {
+							case z.textarea: return import("./VvTextarea.es-DBXLtc0A.js");
+							case z.radio: return import("./VvRadio.es-DlQppq3w.js");
+							case z.radioGroup: return import("./VvRadioGroup.es-CQgfwKsS.js");
+							case z.checkbox: return import("./VvCheckbox.es-BifV6dIp.js");
+							case z.checkboxGroup: return import("./VvCheckboxGroup.es-BPTV2McU.js");
+							case z.select: return import("./VvSelect.es-D-U8Eya6.js");
+							case z.combobox: return import("./VvCombobox.es-DCOcQU3R.js");
+						}
+						return import("./VvInputText.es-D-hc8C2_.js");
+					});
+				}),
+				hasProps: F,
+				invalid: D
+			};
+		},
+		render() {
+			return this.is ? t(this.is, this.hasProps, this.$slots) : this.type === z.custom ? t(this.component, null, this.$slots) : t(this.component, this.hasProps, this.$slots);
+		}
+	});
+}
+function Ce(i, s, c) {
+	return e({
+		name: "VvFormFieldsGroup",
+		props: {
+			is: {
+				type: [Object, String],
+				default: void 0
+			},
+			names: {
+				type: [Array, Object],
+				required: !0
+			},
+			props: {
+				type: [Object, Function],
+				default: () => ({})
+			},
+			showValid: {
+				type: Boolean,
+				default: !1
+			},
+			defaultValues: {
+				type: [Object],
+				default: void 0
+			},
+			readonly: {
+				type: Boolean,
+				default: void 0
+			}
+		},
+		emits: [
+			"invalid",
+			"update:formData",
+			"update:modelValue",
+			"valid"
+		],
+		expose: [
+			"component",
+			"errors",
+			"hasProps",
+			"invalid",
+			"invalidLabels",
+			"is"
+		],
+		slots: Object,
+		setup(e, { slots: t, emit: u }) {
+			let { props: p, names: m, defaultValues: _ } = b(e), v = r(), y = g(() => Array.isArray(m.value) ? m.value : Object.values(m.value)), x = g(() => Array.isArray(m.value) ? m.value : Object.keys(m.value)), S = g(() => Array.isArray(m.value) ? m.value.reduce((e, t) => (e[String(t)] = t, e), {}) : m.value), C = g(() => Object.keys(S.value).reduce((e, t) => (e[String(S.value[t])] = t, e), {})), w = h(s, void 0);
+			w && y.value.forEach((e) => {
+				w.fields.value.set(`${v}-${e}`, e);
+			});
+			let T = h(i), E = g({
+				get() {
+					return T?.formData ? x.value.reduce((e, t) => (e[t] = k(new Object(T.formData.value), S.value[t]), e), {}) : {};
+				},
+				set(e) {
+					T?.formData && (x.value.forEach((t) => {
+						O(new Object(T.formData.value), S.value[t], e?.[t]);
+					}), u("update:modelValue", {
+						newValue: E.value,
+						formData: T?.formData
+					}));
+				}
+			});
+			n(() => {
+				_.value && y.value.forEach((e) => {
+					_.value?.[e] !== void 0 && E.value[e] === void 0 && (E.value = {
+						...E.value,
+						[e]: _.value?.[e]
+					});
+				});
+			}), a(() => {
+				w && y.value.forEach((e) => {
+					w.fields.value.delete(`${v}-${e}`);
+				});
+			});
+			let D = g(() => {
+				if (!T?.errors.value) return;
+				let e = y.value.reduce((e, t) => {
+					if (!T.errors.value) return e;
+					let n = k(T.errors.value, String(t));
+					return n === void 0 || (e[String(t)] = n), e;
+				}, {});
+				if (Object.keys(e).length !== 0) return e;
+			}), A = g(() => {
+				if (!D.value) return;
+				let e = Object.keys(D.value).reduce((e, t) => (D.value?.[t] && (e[C.value[t]] = D.value[t]._errors), e), {});
+				if (Object.keys(e).length !== 0) return e;
+			}), j = g(() => D.value !== void 0), M = g(() => x.value.reduce((e, t) => (e[t] = !!D.value?.[S.value[t]], e), {})), N = l(j, () => {
+				if (j.value) {
+					u("invalid", D.value), w && y.value.forEach((e) => {
+						if (!D.value?.[e]) {
+							w.errors.value.delete(e);
+							return;
+						}
+						w.errors.value.set(e, D.value?.[e]);
+					});
+					return;
+				}
+				u("valid", E.value), w && y.value.forEach((e) => {
+					w.errors.value.delete(e);
+				});
+			}), P = l(() => T?.formData, () => {
+				u("update:formData", T?.formData);
+			}, { deep: !0 });
+			a(() => {
+				N(), P();
+			});
+			let F = (e) => {
+				E.value = e;
+			}, I = (e, t) => {
+				t instanceof InputEvent && (t = t.target.value), x.value.includes(e) && (E.value = {
+					...E.value,
+					[e]: t
+				});
+			}, L = g(() => {
+				let e = p.value;
+				return typeof e == "function" && (e = e(T?.formData)), Object.keys(e).reduce((t, n) => (t[n] = d(e[n]), t), {});
+			}), R = g(() => T?.readonly.value ? !0 : L.value.readonly ?? e.readonly), z = g(() => x.value.reduce((e, t) => (e[`onUpdate:${t}`] = (e) => {
+				I(t, e);
+			}, e), { "onUpdate:modelValue": F })), B = g(() => ({
+				...z.value,
+				...L.value,
+				...E.value,
+				modelValue: E.value,
+				names: L.value.name ?? y.value,
+				invalid: j.value,
+				invalids: M.value,
+				valid: e.showValid ? !!(!j.value && E.value) : void 0,
+				invalidLabels: A.value,
+				readonly: R.value
+			}));
+			return o(c, {
+				names: f(m),
+				errors: f(D)
+			}), {
+				component: g(() => ({ render() {
+					return t.default?.({
+						errors: D.value,
+						formData: T?.formData.value,
+						formErrors: T?.errors.value,
+						invalid: j.value,
+						invalids: M.value,
+						invalidLabels: A.value,
+						modelValue: E.value,
+						onUpdate: F,
+						onUpdateField: I,
+						readonly: R.value,
+						submit: T?.submit,
+						validate: T?.validate
+					}) ?? t.default;
+				} })),
+				hasProps: B,
+				invalid: j
+			};
+		},
+		render() {
+			return this.is ? t(this.is, this.hasProps, this.$slots) : t(this.component, null, this.$slots);
+		}
+	});
+}
+function we(r, i) {
+	return e({
+		name: "VvFormWrapper",
+		props: {
+			name: {
+				type: String,
+				required: !0
+			},
+			tag: {
+				type: String,
+				default: void 0
+			},
+			readonly: {
+				type: Boolean,
+				default: !1
+			}
+		},
+		emits: ["invalid", "valid"],
+		expose: [
+			"clear",
+			"errors",
+			"fields",
+			"fieldsErrors",
+			"formData",
+			"invalid",
+			"readonly",
+			"reset",
+			"submit",
+			"tag",
+			"validate",
+			"validateWrapper"
+		],
+		slots: Object,
+		setup(e, { emit: t }) {
+			let s = h(r), c = h(i, void 0), u = _(/* @__PURE__ */ new Map()), d = _(/* @__PURE__ */ new Map()), { name: p } = b(e), m = g(() => s?.invalid.value ? d.value.size > 0 : !1);
+			l(m, (e) => {
+				if (e) {
+					t("invalid");
+					return;
+				}
+				t("valid");
+			});
+			let v = g(() => s?.readonly.value || e.readonly), y = {
+				name: f(p),
+				errors: d,
+				invalid: f(m),
+				readonly: f(v),
+				fields: u
+			};
+			return o(i, y), l(g(() => new Map(u.value)), (e, t) => {
+				c?.fields && (t.forEach((t, n) => {
+					e.has(n) || c?.fields.value.delete(n);
+				}), e.forEach((e, t) => {
+					c?.fields.value.has(t) || c?.fields.value.set(t, e);
+				}));
+			}, { deep: !0 }), l(d, (e) => {
+				c?.errors && u.value.forEach((t) => {
+					if (e.has(t) || c.errors.value.delete(t), e.has(t)) {
+						let n = e.get(t);
+						n && c.errors.value.set(t, n);
+					}
+				});
+			}, { deep: !0 }), n(() => {
+				if (!s?.wrappers || !p.value) {
+					console.warn("[@volverjs/form-vue]: Invalid wrapper registration state");
+					return;
+				}
+				if (s.wrappers.has(p.value)) {
+					console.warn(`[@volverjs/form-vue]: wrapper name "${p.value}" is already used`);
+					return;
+				}
+				s.wrappers.set(p.value, y);
+			}), a(() => {
+				s?.wrappers && p.value && s.wrappers.delete(p.value);
+			}), {
+				errors: s?.errors,
+				fields: u,
+				fieldsErrors: d,
+				formData: s?.formData,
+				invalid: m,
+				readonly: v,
+				clear: s?.clear,
+				reset: s?.reset,
+				submit: s?.submit,
+				validate: s?.validate,
+				validateWrapper: () => s?.validate(void 0, { fields: new Set(u.value.values()) }) ?? Promise.resolve(!0)
+			};
+		},
+		render() {
+			let e = () => this.$slots.default?.({
+				errors: this.errors,
+				fieldsErrors: this.fieldsErrors,
+				formData: this.formData,
+				invalid: this.invalid,
+				readonly: this.readonly,
+				clear: this.clear,
+				reset: this.reset,
+				submit: this.submit,
+				validate: this.validate,
+				validateWrapper: this.validateWrapper
+			});
+			return this.tag ? t(this.tag, null, { default: e }) : e();
+		}
+	});
+}
+function Te(n, r) {
+	let i = e({
+		name: "VvFormTemplate",
+		props: {
+			schema: {
+				type: [Array, Function],
+				required: !0
+			},
+			scope: {
+				type: Object,
+				default: () => ({})
+			}
+		},
+		slots: Object,
+		setup(e, { slots: a }) {
+			let o = h(n);
+			if (o?.formData) return () => {
+				let n = typeof e.schema == "function" ? e.schema(o, e.scope) : e.schema, s, c = n.reduce((n, a) => {
+					let { vvIs: c, vvName: l, vvSlots: u, vvChildren: f, vvIf: p, vvElseIf: m, vvType: h, vvDefaultValue: g, vvShowValid: _, vvContent: v, ...y } = typeof a == "function" ? a(o, e.scope) : a;
+					if (p !== void 0) {
+						if (s = typeof p == "string" ? !!k(new Object(o.formData.value), p) : d(typeof p == "function" ? p(o) : p), !s) return n;
+					} else if (m !== void 0 && s !== void 0) {
+						if (s || (s = typeof m == "string" ? !!k(new Object(o.formData.value), m) : d(typeof m == "function" ? m(o) : m), !s)) return n;
+					} else s = void 0;
+					let b;
+					return f && (b = typeof c == "string" ? t(i, { schema: f }) : { default: (e) => t(i, {
+						schema: f,
+						scope: e
+					}) }), l ? (n.push(t(r, {
+						name: l,
+						is: c,
+						type: h,
+						defaultValue: g,
+						showValid: _,
+						props: y
+					}, u ?? b ?? v)), n) : c ? (n.push(t(c, y, u ?? b ?? v)), n) : (b && ("default" in b ? n.push(b.default(e.scope)) : n.push(b)), n);
+				}, []);
+				return c.push(a?.default?.({
+					errors: o?.errors.value,
+					formData: o?.formData.value,
+					invalid: o?.invalid.value,
+					status: o?.status.value,
+					submit: o?.submit,
+					validate: o?.validate,
+					clear: o?.clear,
+					reset: o?.reset
+				})), c;
+			};
+		}
+	});
+	return i;
+}
+function Q(e, t = {}) {
+	let n = Symbol("formInjectionKey"), r = Symbol("formWrapperInjectionKey"), i = Symbol("formFieldInjectionKey"), a = Symbol("formFieldsGroupInjectionKey"), o = we(n, r), s = Z(n, r, i, t), c = Ce(n, r, a), l = Te(n, s), u = /* @__PURE__ */ new Map(), { clear: d, errors: f, formData: p, ignoreUpdates: m, invalid: h, readonly: g, reset: _, status: v, stopUpdatesWatch: y, submit: b, validate: x, VvForm: S } = Se(e, n, t, l, u);
+	return {
+		clear: d,
+		errors: f,
+		formData: p,
+		formFieldInjectionKey: i,
+		formInjectionKey: n,
+		formWrapperInjectionKey: r,
+		ignoreUpdates: m,
+		invalid: h,
+		readonly: g,
+		reset: _,
+		status: v,
+		stopUpdatesWatch: y,
+		submit: b,
+		validate: x,
+		wrappers: u,
+		VvForm: S,
+		VvFormField: s,
+		VvFormFieldsGroup: c,
+		VvFormTemplate: l,
+		VvFormWrapper: o
+	};
+}
+var Ee = Symbol("pluginInjectionKey"), $ = /* @__PURE__ */ new Map();
+function De(e, t = {}) {
+	if (t.scope && $.has(t.scope)) return $.get(t.scope);
+	if (!x()) {
+		let n = Q(e, t);
+		return t.scope && $.set(t.scope, n), n;
+	}
+	let n = Q(e, {
+		...h(Ee, {}),
+		...t
+	});
+	return t.scope && $.set(t.scope, n), n;
+}
+//#endregion
+export { F as n, P as r, De as t };
+
+//# sourceMappingURL=index.es-CnpsLhp_.js.map