@youcan/celeste 0.6.102 → 0.7.1

package/dist/cjs/chunks/DialogRoot.cjs

@@ -0,0 +1,81 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Dialog/DialogRoot.js
+var [injectDialogRootContext, provideDialogRootContext] = /* @__PURE__ */ require_createContext.createContext("DialogRoot");
+var DialogRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "DialogRoot",
+	props: {
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		modal: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		unmountOnHide: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const open = require_dist.useVModel(props, "open", __emit, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		const triggerElement = (0, vue.ref)();
+		const contentElement = (0, vue.ref)();
+		const { modal, unmountOnHide } = (0, vue.toRefs)(props);
+		provideDialogRootContext({
+			open,
+			modal,
+			unmountOnHide,
+			openModal: () => {
+				open.value = true;
+			},
+			onOpenChange: (value) => {
+				open.value = value;
+			},
+			onOpenToggle: () => {
+				open.value = !open.value;
+			},
+			contentId: "",
+			titleId: "",
+			descriptionId: "",
+			triggerElement,
+			contentElement
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.renderSlot)(_ctx.$slots, "default", {
+				open: (0, vue.unref)(open),
+				close: () => open.value = false
+			});
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DialogRoot_default", {
+	enumerable: true,
+	get: function() {
+		return DialogRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectDialogRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectDialogRootContext;
+	}
+});

package/dist/cjs/chunks/DialogTitle.cjs

@@ -0,0 +1,38 @@
+require("./chunk.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_DialogRoot = require("./DialogRoot.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Dialog/DialogTitle.js
+var DialogTitle_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "DialogTitle",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "h2"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = require_DialogRoot.injectDialogRootContext();
+		require_useForwardExpose.useForwardExpose();
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)(props, { id: (0, vue.unref)(rootContext).titleId }), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["id"]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DialogTitle_default", {
+	enumerable: true,
+	get: function() {
+		return DialogTitle_default;
+	}
+});

package/dist/cjs/chunks/DialogTrigger.cjs

@@ -0,0 +1,57 @@
+require("./chunk.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useId = require("./useId.cjs");
+const require_DialogRoot = require("./DialogRoot.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Dialog/DialogTrigger.js
+var DialogTrigger_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "DialogTrigger",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = require_DialogRoot.injectDialogRootContext();
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		rootContext.contentId ||= require_useId.useId(void 0, "reka-dialog-content");
+		(0, vue.onMounted)(() => {
+			rootContext.triggerElement.value = currentElement.value;
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)(props, {
+				ref: (0, vue.unref)(forwardRef),
+				type: _ctx.as === "button" ? "button" : void 0,
+				"aria-haspopup": "dialog",
+				"aria-expanded": (0, vue.unref)(rootContext).open.value || false,
+				"aria-controls": (0, vue.unref)(rootContext).open.value ? (0, vue.unref)(rootContext).contentId : void 0,
+				"data-state": (0, vue.unref)(rootContext).open.value ? "open" : "closed",
+				onClick: (0, vue.unref)(rootContext).onOpenToggle
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, [
+				"type",
+				"aria-expanded",
+				"aria-controls",
+				"data-state",
+				"onClick"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DialogTrigger_default", {
+	enumerable: true,
+	get: function() {
+		return DialogTrigger_default;
+	}
+});

package/dist/cjs/chunks/DismissableLayer.cjs

@@ -0,0 +1,292 @@
+require("./chunk.cjs");
+const require_handleAndDispatchCustomEvent = require("./handleAndDispatchCustomEvent.cjs");
+const require_nullish = require("./nullish.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/defu@6.1.7/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = { ...defaults };
+	for (const key of Object.keys(baseObject)) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+var defu = createDefu();
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/DismissableLayer/utils.js
+var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+function isLayerExist(layerElement, targetElement) {
+	if (!(targetElement instanceof Element)) return false;
+	const targetLayer = targetElement.closest("[data-dismissable-layer]");
+	const mainLayer = layerElement.dataset.dismissableLayer === "" ? layerElement : layerElement.querySelector("[data-dismissable-layer]");
+	const nodeList = Array.from(layerElement.ownerDocument.querySelectorAll("[data-dismissable-layer]"));
+	if (targetLayer && (mainLayer === targetLayer || nodeList.indexOf(mainLayer) < nodeList.indexOf(targetLayer))) return true;
+	else return false;
+}
+/**
+* Listens for `pointerdown` outside a DOM subtree. We use `pointerdown` rather than `pointerup`
+* to mimic layer dismissing behaviour present in OS.
+* Returns props to pass to the node we want to check for outside events.
+*/
+function usePointerDownOutside(onPointerDownOutside, element, enabled = true) {
+	const ownerDocument = element?.value?.ownerDocument ?? globalThis?.document;
+	const isPointerInsideDOMTree = (0, vue.ref)(false);
+	const handleClickRef = (0, vue.ref)(() => {});
+	(0, vue.watchEffect)((cleanupFn) => {
+		if (!require_dist.isClient || !(0, vue.toValue)(enabled)) return;
+		const handlePointerDown = async (event) => {
+			const target = event.target;
+			if (!element?.value || !target) return;
+			if (isLayerExist(element.value, target)) {
+				isPointerInsideDOMTree.value = false;
+				return;
+			}
+			if (event.target && !isPointerInsideDOMTree.value) {
+				const eventDetail = { originalEvent: event };
+				function handleAndDispatchPointerDownOutsideEvent() {
+					require_handleAndDispatchCustomEvent.handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, onPointerDownOutside, eventDetail);
+				}
+				/**
+				* On touch devices, we need to wait for a click event because browsers implement
+				* a ~350ms delay between the time the user stops touching the display and when the
+				* browser executes events. We need to ensure we don't reactivate pointer-events within
+				* this timeframe otherwise the browser may execute events that should have been prevented.
+				*
+				* Additionally, this also lets us deal automatically with cancellations when a click event
+				* isn't raised because the page was considered scrolled/drag-scrolled, long-pressed, etc.
+				*
+				* This is why we also continuously remove the previous listener, because we cannot be
+				* certain that it was raised, and therefore cleaned-up.
+				*/
+				if (event.pointerType === "touch") {
+					ownerDocument.removeEventListener("click", handleClickRef.value);
+					handleClickRef.value = handleAndDispatchPointerDownOutsideEvent;
+					ownerDocument.addEventListener("click", handleClickRef.value, { once: true });
+				} else handleAndDispatchPointerDownOutsideEvent();
+			} else ownerDocument.removeEventListener("click", handleClickRef.value);
+			isPointerInsideDOMTree.value = false;
+		};
+		/**
+		* if this hook executes in a component that mounts via a `pointerdown` event, the event
+		* would bubble up to the document and trigger a `pointerDownOutside` event. We avoid
+		* this by delaying the event listener registration on the document.
+		* This is how the DOM works, ie:
+		* ```
+		* button.addEventListener('pointerdown', () => {
+		*   console.log('I will log');
+		*   document.addEventListener('pointerdown', () => {
+		*     console.log('I will also log');
+		*   })
+		* });
+		*/
+		const timerId = window.setTimeout(() => {
+			ownerDocument.addEventListener("pointerdown", handlePointerDown);
+		}, 0);
+		cleanupFn(() => {
+			window.clearTimeout(timerId);
+			ownerDocument.removeEventListener("pointerdown", handlePointerDown);
+			ownerDocument.removeEventListener("click", handleClickRef.value);
+		});
+	});
+	return { onPointerDownCapture: () => {
+		if (!(0, vue.toValue)(enabled)) return;
+		isPointerInsideDOMTree.value = true;
+	} };
+}
+/**
+* Listens for when focus happens outside a DOM subtree.
+* Returns props to pass to the root (node) of the subtree we want to check.
+*/
+function useFocusOutside(onFocusOutside, element, enabled = true) {
+	const ownerDocument = element?.value?.ownerDocument ?? globalThis?.document;
+	const isFocusInsideDOMTree = (0, vue.ref)(false);
+	(0, vue.watchEffect)((cleanupFn) => {
+		if (!require_dist.isClient || !(0, vue.toValue)(enabled)) return;
+		const handleFocus = async (event) => {
+			if (!element?.value) return;
+			await (0, vue.nextTick)();
+			await (0, vue.nextTick)();
+			const target = event.target;
+			if (!element.value || !target || isLayerExist(element.value, target)) return;
+			if (event.target && !isFocusInsideDOMTree.value) require_handleAndDispatchCustomEvent.handleAndDispatchCustomEvent(FOCUS_OUTSIDE, onFocusOutside, { originalEvent: event });
+		};
+		ownerDocument.addEventListener("focusin", handleFocus);
+		cleanupFn(() => ownerDocument.removeEventListener("focusin", handleFocus));
+	});
+	return {
+		onFocusCapture: () => {
+			if (!(0, vue.toValue)(enabled)) return;
+			isFocusInsideDOMTree.value = true;
+		},
+		onBlurCapture: () => {
+			if (!(0, vue.toValue)(enabled)) return;
+			isFocusInsideDOMTree.value = false;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/DismissableLayer/DismissableLayer.js
+var context = /* @__PURE__ */ (0, vue.reactive)({
+	layersRoot: /* @__PURE__ */ new Set(),
+	layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+	originalBodyPointerEvents: void 0,
+	branches: /* @__PURE__ */ new Set()
+});
+var DismissableLayer_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "DismissableLayer",
+	props: {
+		disableOutsidePointerEvents: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		present: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"dismiss"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { forwardRef, currentElement: layerElement } = require_useForwardExpose.useForwardExpose();
+		const ownerDocument = (0, vue.computed)(() => layerElement.value?.ownerDocument ?? globalThis.document);
+		const layers = (0, vue.computed)(() => context.layersRoot);
+		const index = (0, vue.computed)(() => {
+			return layerElement.value ? Array.from(layers.value).indexOf(layerElement.value) : -1;
+		});
+		const isBodyPointerEventsDisabled = (0, vue.computed)(() => {
+			return context.layersWithOutsidePointerEventsDisabled.size > 0;
+		});
+		const isPointerEventsEnabled = (0, vue.computed)(() => {
+			const localLayers = Array.from(layers.value);
+			const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+			const highestLayerWithOutsidePointerEventsDisabledIndex = localLayers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+			return index.value >= highestLayerWithOutsidePointerEventsDisabledIndex;
+		});
+		const pointerDownOutside = usePointerDownOutside(async (event) => {
+			const isPointerDownOnBranch = [...context.branches].some((branch) => branch?.contains(event.target));
+			if (!props.present || !isPointerEventsEnabled.value || isPointerDownOnBranch) return;
+			emits("pointerDownOutside", event);
+			emits("interactOutside", event);
+			await (0, vue.nextTick)();
+			if (!event.defaultPrevented) emits("dismiss");
+		}, layerElement);
+		const focusOutside = useFocusOutside((event) => {
+			const isFocusInBranch = [...context.branches].some((branch) => branch?.contains(event.target));
+			if (!props.present || isFocusInBranch) return;
+			emits("focusOutside", event);
+			emits("interactOutside", event);
+			if (!event.defaultPrevented) emits("dismiss");
+		}, layerElement);
+		require_dist.onKeyStroke("Escape", (event) => {
+			if (!props.present) return;
+			if (!(index.value === layers.value.size - 1)) return;
+			emits("escapeKeyDown", event);
+			if (!event.defaultPrevented) emits("dismiss");
+		});
+		(0, vue.watch)([
+			layerElement,
+			() => props.disableOutsidePointerEvents,
+			() => props.present
+		], ([element, disableOutsidePointerEvents, present], _, onCleanup) => {
+			if (!element || !present) return;
+			if (disableOutsidePointerEvents) {
+				if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+					context.originalBodyPointerEvents = ownerDocument.value.body.style.pointerEvents;
+					ownerDocument.value.body.style.pointerEvents = "none";
+				}
+				context.layersWithOutsidePointerEventsDisabled.add(element);
+				onCleanup(() => {
+					context.layersWithOutsidePointerEventsDisabled.delete(element);
+					if (context.layersWithOutsidePointerEventsDisabled.size === 0 && !require_nullish.isNullish(context.originalBodyPointerEvents)) ownerDocument.value.body.style.pointerEvents = context.originalBodyPointerEvents;
+				});
+			}
+		}, { immediate: true });
+		(0, vue.watch)([layerElement, () => props.present], ([element, present], _, onCleanup) => {
+			if (!element || !present) return;
+			layers.value.add(element);
+			onCleanup(() => {
+				layers.value.delete(element);
+			});
+		}, { immediate: true });
+		(0, vue.watchEffect)((cleanupFn) => {
+			cleanupFn(() => {
+				if (!layerElement.value) return;
+				layers.value.delete(layerElement.value);
+				context.layersWithOutsidePointerEventsDisabled.delete(layerElement.value);
+			});
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				ref: (0, vue.unref)(forwardRef),
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				"data-dismissable-layer": "",
+				style: (0, vue.normalizeStyle)({ pointerEvents: isBodyPointerEventsDisabled.value ? isPointerEventsEnabled.value ? "auto" : "none" : void 0 }),
+				onFocusCapture: (0, vue.unref)(focusOutside).onFocusCapture,
+				onBlurCapture: (0, vue.unref)(focusOutside).onBlurCapture,
+				onPointerdownCapture: (0, vue.unref)(pointerDownOutside).onPointerDownCapture
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as-child",
+				"as",
+				"style",
+				"onFocusCapture",
+				"onBlurCapture",
+				"onPointerdownCapture"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DismissableLayer_default", {
+	enumerable: true,
+	get: function() {
+		return DismissableLayer_default;
+	}
+});
+Object.defineProperty(exports, "defu", {
+	enumerable: true,
+	get: function() {
+		return defu;
+	}
+});

package/dist/cjs/chunks/DropdownMenuPortal.cjs

@@ -0,0 +1,73 @@
+require("./chunk.cjs");
+const require_Teleport = require("./Teleport.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Menu/MenuPortal.js
+var MenuPortal_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuPortal",
+	props: {
+		to: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		defer: {
+			type: Boolean,
+			required: false
+		},
+		forceMount: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Teleport.Teleport_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/DropdownMenu/DropdownMenuPortal.js
+var DropdownMenuPortal_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "DropdownMenuPortal",
+	props: {
+		to: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		defer: {
+			type: Boolean,
+			required: false
+		},
+		forceMount: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(MenuPortal_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DropdownMenuPortal_default", {
+	enumerable: true,
+	get: function() {
+		return DropdownMenuPortal_default;
+	}
+});

package/dist/cjs/chunks/DropdownMenuRoot.cjs

@@ -0,0 +1,87 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_MenuRoot = require("./MenuRoot.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/DropdownMenu/DropdownMenuRoot.js
+var [injectDropdownMenuRootContext, provideDropdownMenuRootContext] = /* @__PURE__ */ require_createContext.createContext("DropdownMenuRoot");
+var DropdownMenuRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "DropdownMenuRoot",
+	props: {
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		modal: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		require_useForwardExpose.useForwardExpose();
+		const open = require_dist.useVModel(props, "open", emit, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		const triggerElement = (0, vue.ref)();
+		const { modal, dir: propDir } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		provideDropdownMenuRootContext({
+			open,
+			onOpenChange: (value) => {
+				open.value = value;
+			},
+			onOpenToggle: () => {
+				open.value = !open.value;
+			},
+			triggerId: "",
+			triggerElement,
+			contentId: "",
+			modal,
+			dir
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_MenuRoot.MenuRoot_default), {
+				open: (0, vue.unref)(open),
+				"onUpdate:open": _cache[0] || (_cache[0] = ($event) => (0, vue.isRef)(open) ? open.value = $event : null),
+				dir: (0, vue.unref)(dir),
+				modal: (0, vue.unref)(modal)
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { open: (0, vue.unref)(open) })]),
+				_: 3
+			}, 8, [
+				"open",
+				"dir",
+				"modal"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "DropdownMenuRoot_default", {
+	enumerable: true,
+	get: function() {
+		return DropdownMenuRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectDropdownMenuRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectDropdownMenuRootContext;
+	}
+});