@effect-app/vue-components 4.0.0-beta.20 → 4.0.0-beta.201

package/dist/vue-components59.es.js

@@ -0,0 +1,128 @@
+import "./vue-components56.es.js";
+import { NonRecordingSpan as e } from "./vue-components57.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+var t = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+function n(e, n) {
+	if (typeof e != "string" || e.length !== n) return !1;
+	let r = 0;
+	for (let n = 0; n < e.length; n += 4) r += (t[e.charCodeAt(n)] | 0) + (t[e.charCodeAt(n + 1)] | 0) + (t[e.charCodeAt(n + 2)] | 0) + (t[e.charCodeAt(n + 3)] | 0);
+	return r === n;
+}
+function r(e) {
+	return n(e, 32) && e !== "00000000000000000000000000000000";
+}
+function i(e) {
+	return n(e, 16) && e !== "0000000000000000";
+}
+function a(e) {
+	return r(e.traceId) && i(e.spanId);
+}
+function o(t) {
+	return new e(t);
+}
+//#endregion
+export { a as isSpanContextValid, o as wrapSpanContext };

package/dist/vue-components6.es.js

@@ -0,0 +1,13 @@
+import { inject as e, provide as t } from "vue";
+//#region src/utils/index.ts
+var n = Symbol(), r = () => {
+	let t = e(n);
+	if (!t) throw Error("useIntl must be used within a IntlProvider");
+	return t();
+}, i = (e) => t(n, e);
+function a(e) {
+	for (; e.encoding;) e = e.encoding[0].to;
+	return e;
+}
+//#endregion
+export { a as getTransformationFrom, i as provideIntl, r as useIntl, n as useIntlKey };

package/dist/vue-components60.es.js

@@ -0,0 +1,24 @@
+import { ContextAPI as e } from "./vue-components54.es.js";
+import { NonRecordingSpan as t } from "./vue-components57.es.js";
+import { getSpanContext as n, setSpan as r } from "./vue-components58.es.js";
+import { isSpanContextValid as i } from "./vue-components59.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+var a = e.getInstance(), o = class {
+	startSpan(e, r, o = a.active()) {
+		if (r?.root) return new t();
+		let c = o && n(o);
+		return s(c) && i(c) ? new t(c) : new t();
+	}
+	startActiveSpan(e, t, n, i) {
+		let o, s, c;
+		if (arguments.length < 2) return;
+		arguments.length === 2 ? c = t : arguments.length === 3 ? (o = t, c = n) : (o = t, s = n, c = i);
+		let l = s ?? a.active(), u = this.startSpan(e, o, l), d = r(l, u);
+		return a.with(d, c, void 0, u);
+	}
+};
+function s(e) {
+	return typeof e == "object" && !!e && "spanId" in e && typeof e.spanId == "string" && "traceId" in e && typeof e.traceId == "string" && "traceFlags" in e && typeof e.traceFlags == "number";
+}
+//#endregion
+export { o as NoopTracer };

package/dist/vue-components61.es.js

@@ -0,0 +1,21 @@
+import { NoopTracer as e } from "./vue-components60.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var t = new e(), n = class {
+	constructor(e, t, n, r) {
+		this._provider = e, this.name = t, this.version = n, this.options = r;
+	}
+	startSpan(e, t, n) {
+		return this._getTracer().startSpan(e, t, n);
+	}
+	startActiveSpan(e, t, n, r) {
+		let i = this._getTracer();
+		return Reflect.apply(i.startActiveSpan, i, arguments);
+	}
+	_getTracer() {
+		if (this._delegate) return this._delegate;
+		let e = this._provider.getDelegateTracer(this.name, this.version, this.options);
+		return e ? (this._delegate = e, this._delegate) : t;
+	}
+};
+//#endregion
+export { n as ProxyTracer };

package/dist/vue-components62.es.js

@@ -0,0 +1,9 @@
+import { NoopTracer as e } from "./vue-components60.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var t = class {
+	getTracer(t, n, r) {
+		return new e();
+	}
+};
+//#endregion
+export { t as NoopTracerProvider };

package/dist/vue-components63.es.js

@@ -0,0 +1,19 @@
+import { ProxyTracer as e } from "./vue-components61.es.js";
+import { NoopTracerProvider as t } from "./vue-components62.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var n = new t(), r = class {
+	getTracer(t, n, r) {
+		return this.getDelegateTracer(t, n, r) ?? new e(this, t, n, r);
+	}
+	getDelegate() {
+		return this._delegate ?? n;
+	}
+	setDelegate(e) {
+		this._delegate = e;
+	}
+	getDelegateTracer(e, t, n) {
+		return this._delegate?.getTracer(e, t, n);
+	}
+};
+//#endregion
+export { r as ProxyTracerProvider };

package/dist/vue-components64.es.js

@@ -0,0 +1,5 @@
+import { ContextAPI as e } from "./vue-components54.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context-api.js
+var t = e.getInstance();
+//#endregion
+export { t as context };

package/dist/vue-components65.es.js

@@ -0,0 +1,29 @@
+import { getGlobal as e, registerGlobal as t, unregisterGlobal as n } from "./vue-components47.es.js";
+import { DiagAPI as r } from "./vue-components51.es.js";
+import { deleteSpan as i, getActiveSpan as a, getSpan as o, getSpanContext as s, setSpan as c, setSpanContext as l } from "./vue-components58.es.js";
+import { isSpanContextValid as u, wrapSpanContext as d } from "./vue-components59.es.js";
+import { ProxyTracerProvider as f } from "./vue-components63.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/trace.js
+var p = "trace", m = class m {
+	constructor() {
+		this._proxyTracerProvider = new f(), this.wrapSpanContext = d, this.isSpanContextValid = u, this.deleteSpan = i, this.getSpan = o, this.getActiveSpan = a, this.getSpanContext = s, this.setSpan = c, this.setSpanContext = l;
+	}
+	static getInstance() {
+		return this._instance ||= new m(), this._instance;
+	}
+	setGlobalTracerProvider(e) {
+		let n = t(p, this._proxyTracerProvider, r.instance());
+		return n && this._proxyTracerProvider.setDelegate(e), n;
+	}
+	getTracerProvider() {
+		return e(p) || this._proxyTracerProvider;
+	}
+	getTracer(e, t) {
+		return this.getTracerProvider().getTracer(e, t);
+	}
+	disable() {
+		n(p, r.instance()), this._proxyTracerProvider = new f();
+	}
+};
+//#endregion
+export { m as TraceAPI };

package/dist/vue-components66.es.js

@@ -0,0 +1,5 @@
+import { TraceAPI as e } from "./vue-components65.es.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace-api.js
+var t = e.getInstance();
+//#endregion
+export { t as trace };

package/dist/vue-components67.es.js

@@ -0,0 +1,29 @@
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.60/node_modules/effect/dist/Function.js
+var e = function(e, t) {
+	if (typeof e == "function") return function() {
+		return e(arguments) ? t.apply(this, arguments) : (e) => t(e, ...arguments);
+	};
+	switch (e) {
+		case 0:
+		case 1: throw RangeError(`Invalid arity ${e}`);
+		case 2: return function(e, n) {
+			return arguments.length >= 2 ? t(e, n) : function(n) {
+				return t(n, e);
+			};
+		};
+		case 3: return function(e, n, r) {
+			return arguments.length >= 3 ? t(e, n, r) : function(r) {
+				return t(r, e, n);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= e) return t.apply(this, arguments);
+			let n = arguments;
+			return function(e) {
+				return t(e, ...n);
+			};
+		};
+	}
+};
+//#endregion
+export { e as dual };

package/dist/vue-components68.es.js

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.60/node_modules/effect/dist/Predicate.js
+function e(e) {
+	return typeof e == "function";
+}
+//#endregion
+export { e as isFunction };

package/dist/vue-components69.es.js

@@ -0,0 +1,18 @@
+import { dual as e } from "./vue-components67.es.js";
+import { isFunction as t } from "./vue-components68.es.js";
+import { Cause as n, Effect as r, Exit as i, Fiber as a } from "effect";
+//#region ../effect-app/dist/utils.js
+var o = Symbol.for("clone-trait"), s = e(2, (e, t) => o in e ? e[o](t) : Object.setPrototypeOf(t, Object.getPrototypeOf(e)));
+e(2, (e, n) => s(e, {
+	...e,
+	...t(n) ? n(e) : n
+}));
+var c = (e, t) => {
+	let n = () => r.runSync(a.interrupt(e));
+	return t.aborted ? (n(), e) : (t.addEventListener("abort", n), e);
+}, l = (e, t) => (t && c(e, t), new Promise((t, r) => e.addObserver((e) => {
+	i.isSuccess(e) ? t(e.value) : r(n.squash(e.cause));
+})));
+(function* () {}).constructor;
+//#endregion
+export { l as runtimeFiberAsPromise };

package/dist/vue-components7.es.js

@@ -0,0 +1,13 @@
+import { onMounted as e, onUnmounted as t } from "vue";
+//#region src/components/OmegaForm/onMountedWithCleanup.ts
+function n(n) {
+	let r;
+	e(() => {
+		let e = n();
+		e && (r = e);
+	}), t(() => {
+		r && r();
+	});
+}
+//#endregion
+export { n as onMountedWithCleanup };

package/dist/vue-components70.es.js

@@ -0,0 +1,40 @@
+import { context as e } from "./vue-components64.es.js";
+import { trace as t } from "./vue-components66.es.js";
+import { runtimeFiberAsPromise as n } from "./vue-components69.es.js";
+import { Data as r, Effect as i, Fiber as a, Option as o } from "effect-app";
+//#region src/components/OmegaForm/submit.ts
+var s = class extends r.TaggedError("FormErrors") {}, c = (n, r) => n ? e.with(t.setSpan(e.active(), n), r) : r(), l = (e, t, r) => {
+	if (e) return ({ formApi: o, meta: s, value: l }) => c(s?.currentSpan, async () => {
+		let c = e({
+			formApi: o,
+			meta: s,
+			value: await r(t(l))
+		});
+		if (a.isFiber(c)) return await n(c);
+		if (i.isEffect(c)) {
+			let e = await r(c);
+			return a.isFiber(e) ? await n(e) : e;
+		}
+		return c;
+	});
+}, u = (n) => {
+	let r = n.handleSubmit.bind(n), a = async (e) => await r(e), c = (n) => a({
+		currentSpan: t.getSpan(e.active()),
+		...n
+	}), l = (e) => i.currentSpan.pipe(i.option, i.flatMap((t) => i.promise(() => a(o.isSome(t) ? {
+		currentSpan: t.value,
+		...e
+	} : e))));
+	return {
+		handleSubmit: c,
+		handleSubmitEffect: (e) => e?.checkErrors ? l(e?.meta).pipe(i.flatMap(i.fnUntraced(function* () {
+			let e = n.getAllErrors();
+			if (Object.keys(e.fields).length || e.form.errors.length) return yield* i.fail(new s({
+				form: e.form,
+				fields: e.fields
+			}));
+		}))) : l(e?.meta)
+	};
+};
+//#endregion
+export { s as FormErrors, u as makeSubmitHandlers, l as wrapOnSubmit };

package/dist/vue-components71.es.js

@@ -0,0 +1,81 @@
+import { useIntl as e } from "./vue-components6.es.js";
+import { generateMetaFromSchema as t } from "./vue-components14.es.js";
+import { defaultsValueFromSchema as n } from "./vue-components15.es.js";
+import { toFormSchema as r } from "./vue-components16.es.js";
+import { usePersistency as i } from "./vue-components18.es.js";
+import { annotateLiteralUnionMessages as a, toLocalizedStandardSchemaV1 as o } from "./vue-components19.es.js";
+import { eHoc as s, makeFieldMap as c } from "./vue-components20.es.js";
+import { fHoc as l } from "./vue-components21.es.js";
+import u from "./vue-components23.es.js";
+import d from "./vue-components25.es.js";
+import f from "./vue-components29.es.js";
+import p from "./vue-components36.es.js";
+import m from "./vue-components40.es.js";
+import h from "./vue-components44.es.js";
+import { makeSubmitHandlers as g, wrapOnSubmit as _ } from "./vue-components70.es.js";
+import { watch as v } from "vue";
+import { Context as y, S as b } from "effect-app";
+import { revalidateLogic as x, useForm as S } from "@tanstack/vue-form";
+import { makeRunPromise as C } from "@effect-app/vue/runtime";
+//#region src/components/OmegaForm/useOmegaForm.ts
+var w = Symbol("OmegaForm"), T = C(y.empty()), E = (y, C, w) => {
+	if (!y) throw Error("Schema is required");
+	let { trans: E } = e(), D = r(y), O = o(a(D, E), E), k = b.decodeUnknownEffectConcurrently(D), { meta: A, unionMeta: j } = t(D), M = { form: void 0 }, N = i({
+		meta: A,
+		persistency: w?.persistency,
+		preventWindowExit: w?.preventWindowExit,
+		defaultValuesPriority: w?.defaultValuesPriority,
+		tanstackDefaultValues: C?.defaultValues,
+		schemaDefaultValues: () => n(y),
+		getForm: () => M.form
+	}), P = S({
+		...C,
+		validationLogic: x(),
+		validators: {
+			onDynamic: O,
+			...C?.validators
+		},
+		onSubmit: _(C?.onSubmit, k, T),
+		defaultValues: N.defaultValues.value
+	});
+	M.form = P;
+	let F = () => {
+		Object.keys(A).forEach((e) => {
+			P.setFieldValue(e, void 0);
+		});
+	};
+	if (w?.preventWindowExit === "prevent-and-reset") {
+		let e = P.useStore((e) => e.isSubmitting), t = P.useStore((e) => e.submissionAttempts), n = P.useStore((e) => e.canSubmit), r = P.useStore((e) => e.values);
+		v([e, t], ([e, t], [i]) => {
+			i && !e && t > 0 && n.value && P.reset(r.value);
+		});
+	}
+	let { handleSubmit: I, handleSubmitEffect: L } = g(P), { fieldMap: R, registerField: z } = c(), B = Object.assign(P, {
+		i18nNamespace: w?.i18nNamespace,
+		ignorePreventCloseEvents: w?.ignorePreventCloseEvents,
+		meta: A,
+		unionMeta: j,
+		clear: F,
+		handleSubmit: I,
+		handleSubmitEffect: L,
+		registerField: z
+	}), V = {
+		form: B,
+		fieldMap: R
+	};
+	return Object.assign(B, {
+		_paths: void 0,
+		_keys: void 0,
+		_schema: y,
+		errorContext: V,
+		Form: l(B)(h),
+		Input: l(B)(w?.input ?? p),
+		TaggedUnion: l(B)(m),
+		Field: P.Field,
+		Errors: s(V)(f),
+		Array: l(B)(u),
+		AutoGen: l(B)(d)
+	});
+};
+//#endregion
+export { w as OmegaFormKey, E as useOmegaForm };

package/dist/vue-components72.es.js

@@ -0,0 +1,33 @@
+import e from "./vue-components36.es.js";
+import { useOmegaForm as t } from "./vue-components71.es.js";
+import { h as n } from "vue";
+//#region src/components/OmegaForm/createUseFormWithCustomInput.ts
+var r = (r) => (...i) => {
+	let [a, o, s] = i, c = {
+		name: "WrappedInput",
+		inheritAttrs: !1,
+		setup(t, { attrs: i, slots: a }) {
+			return () => n(e, {
+				...t,
+				...i
+			}, {
+				default: ({ field: e, state: t, ...o }) => n(r, {
+					...Object.fromEntries(Object.entries(i).filter(([e]) => !Object.prototype.hasOwnProperty.call(o, e) && e !== "form")),
+					field: e,
+					state: t,
+					inputProps: o
+				}, {
+					...a.label && { label: (e) => a.label(e) },
+					...a.default && { default: (e) => a.default(e) }
+				}),
+				...a.label && { label: (e) => a.label(e) }
+			});
+		}
+	};
+	return t(a, o, {
+		...s,
+		input: c
+	});
+};
+//#endregion
+export { r as createUseFormWithCustomInput };

package/dist/vue-components73.es.js

@@ -0,0 +1,19 @@
+import "./vue-components8.es.js";
+import "./vue-components11.es.js";
+import "./vue-components14.es.js";
+import "./vue-components15.es.js";
+import "./vue-components16.es.js";
+import "./vue-components18.es.js";
+import "./vue-components19.es.js";
+import "./vue-components20.es.js";
+import "./vue-components34.es.js";
+import "./vue-components36.es.js";
+import "./vue-components38.es.js";
+import "./vue-components40.es.js";
+import "./vue-components70.es.js";
+import "./vue-components71.es.js";
+import "./vue-components72.es.js";
+//#region src/components/OmegaForm/index.ts
+var e = (e) => e;
+//#endregion
+export { e as duplicateSchema };

package/dist/vue-components74.es.js

@@ -0,0 +1,48 @@
+import { __exportAll as e } from "./vue-components2.es.js";
+import t from "./vue-components4.es.js";
+import { useOnClose as n, usePreventClose as r } from "./vue-components8.es.js";
+import i from "./vue-components10.es.js";
+import { getInputType as a } from "./vue-components11.es.js";
+import { createMeta as o, generateMetaFromSchema as s, isNullableOrUndefined as c, metadataFromAst as l } from "./vue-components14.es.js";
+import { defaultsValueFromSchema as u } from "./vue-components15.es.js";
+import { toFormSchema as d } from "./vue-components16.es.js";
+import { deepMerge as f } from "./vue-components18.es.js";
+import { makeStandardSchemaV1Hooks as p, toLocalizedStandardSchemaV1 as m } from "./vue-components19.es.js";
+import { useErrorLabel as h } from "./vue-components20.es.js";
+import g from "./vue-components34.es.js";
+import _ from "./vue-components36.es.js";
+import v from "./vue-components38.es.js";
+import y from "./vue-components40.es.js";
+import { FormErrors as b } from "./vue-components70.es.js";
+import { OmegaFormKey as x, useOmegaForm as S } from "./vue-components71.es.js";
+import { createUseFormWithCustomInput as C } from "./vue-components72.es.js";
+import { duplicateSchema as w } from "./vue-components73.es.js";
+//#region src/components/index.ts
+var T = /* @__PURE__ */ e({
+	CommandButton: () => t,
+	Dialog: () => i,
+	FormErrors: () => b,
+	OmegaFormKey: () => x,
+	OmegaInput: () => _,
+	OmegaTaggedUnion: () => y,
+	OmegaTaggedUnionInternal: () => v,
+	OmegaVuetifyInput: () => g,
+	createMeta: () => o,
+	createUseFormWithCustomInput: () => C,
+	deepMerge: () => f,
+	defaultsValueFromSchema: () => u,
+	duplicateSchema: () => w,
+	generateMetaFromSchema: () => s,
+	getInputType: () => a,
+	isNullableOrUndefined: () => c,
+	makeStandardSchemaV1Hooks: () => p,
+	metadataFromAst: () => l,
+	toFormSchema: () => d,
+	toLocalizedStandardSchemaV1: () => m,
+	useErrorLabel: () => h,
+	useOmegaForm: () => S,
+	useOnClose: () => n,
+	usePreventClose: () => r
+});
+//#endregion
+export { T as components_exports };

package/dist/vue-components8.es.js

@@ -0,0 +1,35 @@
+import e from "./vue-components5.es.js";
+import { useIntl as t } from "./vue-components6.es.js";
+import { onMountedWithCleanup as n } from "./vue-components7.es.js";
+import { inject as r, provide as i } from "vue";
+//#region src/components/OmegaForm/blockDialog.ts
+var a = () => e(), o = Symbol("DialogBus"), s = () => r(o, null), c = () => {
+	let e = a();
+	return i(o, e), e;
+}, l = (e) => {
+	let r = s();
+	if (!r) return;
+	let { formatMessage: i, trans: a } = t(), o = e(), c = "There are unsaved changes. Are you sure you want to close?";
+	n(() => {
+		let e = (e) => {
+			if (o.value) {
+				let t = i ? i({
+					id: "form.unsaved_changes_confirm",
+					defaultMessage: c
+				}) : a?.("form.unsaved_changes_confirm") ?? c;
+				confirm(t) || (e.prevent = !0);
+			}
+		};
+		return r.on("dialog-closing", e), () => r.off("dialog-closing", e);
+	});
+}, u = (e) => {
+	let t = s();
+	return t ||= c(), () => {
+		let n = {};
+		t.emit("dialog-closing", n), n.prevent ? typeof n.prevent == "object" && "then" in n.prevent && n.prevent.then((t) => {
+			t && e();
+		}).catch(console.error) : e();
+	};
+};
+//#endregion
+export { u as useOnClose, l as usePreventClose };

package/dist/vue-components9.es.js

@@ -0,0 +1,47 @@
+import { onMountedWithCleanup as e } from "./vue-components7.es.js";
+import { useOnClose as t } from "./vue-components8.es.js";
+import { computed as n, createBlock as r, createSlots as i, defineComponent as a, guardReactiveProps as o, mergeModels as s, normalizeProps as c, openBlock as l, renderList as u, renderSlot as d, resolveComponent as f, unref as p, useModel as m, useSlots as h, withCtx as g } from "vue";
+//#region src/components/Dialog.vue?vue&type=script&setup=true&lang.ts
+var _ = /* @__PURE__ */ a({
+	__name: "Dialog",
+	props: /* @__PURE__ */ s({ persistent: { type: Boolean } }, {
+		modelValue: {
+			type: Boolean,
+			default: !1
+		},
+		modelModifiers: {}
+	}),
+	emits: ["update:modelValue"],
+	setup(a) {
+		let s = a, _ = m(a, "modelValue"), v = h(), y = n(() => {
+			let { default: e, ...t } = v;
+			return t;
+		}), b = t(() => _.value = !1);
+		return e(() => {
+			let e = (e) => {
+				_.value && !s.persistent && e.code === "Escape" && b();
+			};
+			return document.addEventListener("keydown", e), () => document.removeEventListener("keydown", e);
+		}), (e, t) => {
+			let n = f("v-dialog");
+			return l(), r(n, {
+				modelValue: _.value,
+				"onUpdate:modelValue": t[0] ||= (e) => _.value = e,
+				persistent: "",
+				"onClick:outside": p(b)
+			}, i({
+				default: g(({ isActive: t }) => [d(e.$slots, "default", {
+					open: _.value,
+					cancel: p(b),
+					isActive: t
+				})]),
+				_: 2
+			}, [u(y.value, (t, n) => ({
+				name: n,
+				fn: g((t) => [d(e.$slots, n, c(o(t)))])
+			}))]), 1032, ["modelValue", "onClick:outside"]);
+		};
+	}
+});
+//#endregion
+export { _ as default };