@youcan/celeste 0.6.102 → 0.7.0

package/dist/cjs/chunks/MenuContentImpl.cjs

@@ -0,0 +1,371 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_getActiveElement = require("./getActiveElement.cjs");
+const require_useArrowNavigation = require("./useArrowNavigation.cjs");
+const require_DismissableLayer = require("./DismissableLayer.cjs");
+const require_FocusScope = require("./FocusScope.cjs");
+const require_useFocusGuards = require("./useFocusGuards.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useTypeahead = require("./useTypeahead.cjs");
+const require_utils = require("./utils.cjs");
+const require_PopperContent = require("./PopperContent.cjs");
+const require_RovingFocusGroup = require("./RovingFocusGroup.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@5.9.3_/node_modules/reka-ui/dist/Menu/MenuContentImpl.js
+var [injectMenuContentContext, provideMenuContentContext] = /* @__PURE__ */ require_createContext.createContext("MenuContent");
+var MenuContentImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuContentImpl",
+	props: /* @__PURE__ */ (0, vue.mergeDefaults)({
+		loop: {
+			type: Boolean,
+			required: false
+		},
+		disableOutsidePointerEvents: {
+			type: Boolean,
+			required: false
+		},
+		disableOutsideScroll: {
+			type: Boolean,
+			required: false
+		},
+		trapFocus: {
+			type: Boolean,
+			required: false
+		},
+		memoDependencies: {
+			type: Array,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		sideFlip: {
+			type: Boolean,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		alignFlip: {
+			type: Boolean,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		hideShiftedArrow: {
+			type: Boolean,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		},
+		disableUpdateOnLayoutShift: {
+			type: Boolean,
+			required: false
+		},
+		prioritizePosition: {
+			type: Boolean,
+			required: false
+		},
+		reference: {
+			type: null,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	}, { ...require_PopperContent.PopperContentPropsDefaultValue }),
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"entryFocus",
+		"openAutoFocus",
+		"closeAutoFocus",
+		"dismiss"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const menuContext = require_MenuRoot.injectMenuContext();
+		const rootContext = require_MenuRoot.injectMenuRootContext();
+		const { trapFocus, disableOutsidePointerEvents, loop } = (0, vue.toRefs)(props);
+		require_useFocusGuards.useFocusGuards();
+		require_FocusScope.useBodyScrollLock(disableOutsidePointerEvents.value);
+		const searchRef = (0, vue.ref)("");
+		const timerRef = (0, vue.ref)(0);
+		const pointerGraceTimerRef = (0, vue.ref)(0);
+		const pointerGraceIntentRef = (0, vue.ref)(null);
+		const pointerDirRef = (0, vue.ref)("right");
+		const lastPointerXRef = (0, vue.ref)(0);
+		const currentItemId = (0, vue.ref)(null);
+		const rovingFocusGroupRef = (0, vue.ref)();
+		const { forwardRef, currentElement: contentElement } = require_useForwardExpose.useForwardExpose();
+		const { handleTypeaheadSearch } = require_useTypeahead.useTypeahead();
+		const highlightedElement = (0, vue.ref)();
+		function onKeydownNavigation(event) {
+			const el = require_useArrowNavigation.useArrowNavigation(event, highlightedElement.value || require_getActiveElement.getActiveElement(), contentElement.value, {
+				loop: loop.value,
+				arrowKeyOptions: "vertical",
+				dir: rootContext?.dir.value,
+				focus: false,
+				attributeName: "[data-reka-collection-item]:not([data-disabled])"
+			});
+			if (el) {
+				highlightedElement.value = el;
+				el.scrollIntoView({ block: "nearest" });
+			}
+		}
+		function onKeydownEnter() {
+			if (highlightedElement.value) highlightedElement.value.click();
+		}
+		const filterElement = (0, vue.ref)();
+		const activeSubmenuContext = (0, vue.ref)();
+		(0, vue.watch)(highlightedElement, (el) => {
+			if (activeSubmenuContext.value && (el === void 0 || el !== activeSubmenuContext.value.trigger.value)) {
+				if (el === void 0) return;
+				activeSubmenuContext.value.onOpenChange(false);
+				activeSubmenuContext.value = void 0;
+			}
+		});
+		(0, vue.watch)(contentElement, (el) => {
+			menuContext.onContentChange(el);
+		});
+		(0, vue.onUnmounted)(() => {
+			window.clearTimeout(timerRef.value);
+		});
+		function isPointerMovingToSubmenu(event) {
+			return pointerDirRef.value === pointerGraceIntentRef.value?.side && require_utils.isPointerInGraceArea(event, pointerGraceIntentRef.value?.area);
+		}
+		async function handleMountAutoFocus(event) {
+			emits("openAutoFocus", event);
+			if (event.defaultPrevented) return;
+			event.preventDefault();
+			contentElement.value?.focus({ preventScroll: true });
+		}
+		function handleKeyDown(event) {
+			if (event.defaultPrevented) return;
+			const target = event.target;
+			const isKeyDownInside = target.closest("[data-reka-menu-content]") === event.currentTarget;
+			const isKeyDownInTextField = ["input", "textarea"].includes(target.tagName.toLowerCase());
+			const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+			const isCharacterKey = event.key.length === 1;
+			const el = require_useArrowNavigation.useArrowNavigation(event, require_getActiveElement.getActiveElement(), contentElement.value, {
+				loop: loop.value,
+				arrowKeyOptions: "vertical",
+				dir: rootContext?.dir.value,
+				focus: true,
+				attributeName: "[data-reka-collection-item]:not([data-disabled])"
+			});
+			if (el) return el?.focus();
+			if (event.code === "Space") return;
+			const collectionItems = rovingFocusGroupRef.value?.getItems() ?? [];
+			if (isKeyDownInside) {
+				if (event.key === "Tab" && rootContext.modal.value) event.preventDefault();
+				if (!isModifierKey && isCharacterKey && !isKeyDownInTextField) handleTypeaheadSearch(event.key, collectionItems);
+			}
+			if (event.target !== contentElement.value) return;
+			if (!require_utils.FIRST_LAST_KEYS.includes(event.key)) return;
+			event.preventDefault();
+			const candidateNodes = [...collectionItems.map((item) => item.ref)];
+			if (require_utils.LAST_KEYS.includes(event.key)) candidateNodes.reverse();
+			require_utils.focusFirst(candidateNodes);
+		}
+		function handleBlur(event) {
+			if (!event?.currentTarget?.contains?.(event.target)) {
+				window.clearTimeout(timerRef.value);
+				searchRef.value = "";
+			}
+		}
+		function handlePointerMove(event) {
+			if (!require_utils.isMouseEvent(event)) return;
+			const target = event.target;
+			const pointerXHasChanged = lastPointerXRef.value !== event.clientX;
+			if ((event?.currentTarget)?.contains(target) && pointerXHasChanged) {
+				pointerDirRef.value = event.clientX > lastPointerXRef.value ? "right" : "left";
+				lastPointerXRef.value = event.clientX;
+			}
+		}
+		function handlePointerEnter(event) {
+			if (!require_utils.isMouseEvent(event)) return;
+			if (filterElement.value) filterElement.value.focus();
+		}
+		provideMenuContentContext({
+			onItemEnter: (event) => {
+				if (isPointerMovingToSubmenu(event)) return true;
+				else return false;
+			},
+			onItemLeave: (event) => {
+				if (isPointerMovingToSubmenu(event)) return true;
+				if (!["INPUT", "TEXTAREA"].includes(require_getActiveElement.getActiveElement()?.tagName || "")) contentElement.value?.focus();
+				currentItemId.value = null;
+				return false;
+			},
+			onTriggerLeave: (event) => {
+				if (isPointerMovingToSubmenu(event)) return true;
+				else return false;
+			},
+			searchRef,
+			highlightedElement,
+			onKeydownNavigation,
+			onKeydownEnter,
+			filterElement,
+			onFilterElementChange: (el) => {
+				filterElement.value = el;
+			},
+			activeSubmenuContext,
+			pointerGraceTimerRef,
+			onPointerGraceIntentChange: (intent) => {
+				pointerGraceIntentRef.value = intent;
+			}
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_FocusScope.FocusScope_default), {
+				"as-child": "",
+				trapped: (0, vue.unref)(trapFocus),
+				onMountAutoFocus: handleMountAutoFocus,
+				onUnmountAutoFocus: _cache[7] || (_cache[7] = ($event) => emits("closeAutoFocus", $event))
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_DismissableLayer.DismissableLayer_default), {
+					"as-child": "",
+					"disable-outside-pointer-events": (0, vue.unref)(disableOutsidePointerEvents),
+					onEscapeKeyDown: _cache[2] || (_cache[2] = ($event) => emits("escapeKeyDown", $event)),
+					onPointerDownOutside: _cache[3] || (_cache[3] = ($event) => emits("pointerDownOutside", $event)),
+					onFocusOutside: _cache[4] || (_cache[4] = ($event) => emits("focusOutside", $event)),
+					onInteractOutside: _cache[5] || (_cache[5] = ($event) => emits("interactOutside", $event)),
+					onDismiss: _cache[6] || (_cache[6] = ($event) => emits("dismiss"))
+				}, {
+					default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_RovingFocusGroup.RovingFocusGroup_default), {
+						ref_key: "rovingFocusGroupRef",
+						ref: rovingFocusGroupRef,
+						"current-tab-stop-id": currentItemId.value,
+						"onUpdate:currentTabStopId": _cache[0] || (_cache[0] = ($event) => currentItemId.value = $event),
+						"as-child": "",
+						orientation: "vertical",
+						dir: (0, vue.unref)(rootContext).dir.value,
+						loop: (0, vue.unref)(loop),
+						onEntryFocus: _cache[1] || (_cache[1] = (event) => {
+							emits("entryFocus", event);
+							if (!(0, vue.unref)(rootContext).isUsingKeyboardRef.value) event.preventDefault();
+						})
+					}, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_PopperContent.PopperContent_default), {
+							ref: (0, vue.unref)(forwardRef),
+							role: "menu",
+							as: _ctx.as,
+							"as-child": _ctx.asChild,
+							"aria-orientation": "vertical",
+							"data-reka-menu-content": "",
+							"data-state": (0, vue.unref)(require_utils.getOpenState)((0, vue.unref)(menuContext).open.value),
+							dir: (0, vue.unref)(rootContext).dir.value,
+							side: _ctx.side,
+							"side-offset": _ctx.sideOffset,
+							align: _ctx.align,
+							"align-offset": _ctx.alignOffset,
+							"avoid-collisions": _ctx.avoidCollisions,
+							"collision-boundary": _ctx.collisionBoundary,
+							"collision-padding": _ctx.collisionPadding,
+							"arrow-padding": _ctx.arrowPadding,
+							"prioritize-position": _ctx.prioritizePosition,
+							"position-strategy": _ctx.positionStrategy,
+							"update-position-strategy": _ctx.updatePositionStrategy,
+							sticky: _ctx.sticky,
+							"hide-when-detached": _ctx.hideWhenDetached,
+							reference: _ctx.reference,
+							onKeydown: handleKeyDown,
+							onBlur: handleBlur,
+							onPointermove: handlePointerMove,
+							onPointerenter: handlePointerEnter
+						}, {
+							default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+							_: 3
+						}, 8, [
+							"as",
+							"as-child",
+							"data-state",
+							"dir",
+							"side",
+							"side-offset",
+							"align",
+							"align-offset",
+							"avoid-collisions",
+							"collision-boundary",
+							"collision-padding",
+							"arrow-padding",
+							"prioritize-position",
+							"position-strategy",
+							"update-position-strategy",
+							"sticky",
+							"hide-when-detached",
+							"reference"
+						])]),
+						_: 3
+					}, 8, [
+						"current-tab-stop-id",
+						"dir",
+						"loop"
+					])]),
+					_: 3
+				}, 8, ["disable-outside-pointer-events"])]),
+				_: 3
+			}, 8, ["trapped"]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "MenuContentImpl_default", {
+	enumerable: true,
+	get: function() {
+		return MenuContentImpl_default;
+	}
+});
+Object.defineProperty(exports, "injectMenuContentContext", {
+	enumerable: true,
+	get: function() {
+		return injectMenuContentContext;
+	}
+});

package/dist/cjs/chunks/MenuGroup.cjs

@@ -0,0 +1,44 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useId = require("./useId.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuGroup.js
+var [injectMenuGroupContext, provideMenuGroupContext] = /* @__PURE__ */ require_createContext.createContext("MenuGroup");
+var MenuGroup_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuGroup",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const id = require_useId.useId(void 0, "reka-menu-group");
+		provideMenuGroupContext({ id });
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)({ role: "group" }, props, { "aria-labelledby": (0, vue.unref)(id) }), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["aria-labelledby"]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "MenuGroup_default", {
+	enumerable: true,
+	get: function() {
+		return MenuGroup_default;
+	}
+});
+Object.defineProperty(exports, "injectMenuGroupContext", {
+	enumerable: true,
+	get: function() {
+		return injectMenuGroupContext;
+	}
+});

package/dist/cjs/chunks/MenuItemImpl.cjs

@@ -0,0 +1,100 @@
+require("./chunk.cjs");
+const require_getActiveElement = require("./getActiveElement.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_utils = require("./utils.cjs");
+const require_Collection = require("./Collection.cjs");
+const require_MenuContentImpl = require("./MenuContentImpl.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuItemImpl.js
+var MenuItemImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "MenuItemImpl",
+	props: {
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		textValue: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const contentContext = require_MenuContentImpl.injectMenuContentContext();
+		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
+		const { CollectionItem } = require_Collection.useCollection();
+		const isFocused = (0, vue.ref)(false);
+		const isHighlighted = (0, vue.computed)(() => isFocused.value || currentElement.value != null && contentContext.highlightedElement.value === currentElement.value);
+		async function handlePointerMove(event) {
+			if (event.defaultPrevented || !require_utils.isMouseEvent(event)) return;
+			if (props.disabled) contentContext.onItemLeave(event);
+			else if (!contentContext.onItemEnter(event)) {
+				const item = event.currentTarget;
+				contentContext.highlightedElement.value = item;
+				if (!["INPUT", "TEXTAREA"].includes(require_getActiveElement.getActiveElement()?.tagName || "")) item.focus({ preventScroll: true });
+			}
+		}
+		async function handlePointerLeave(event) {
+			await (0, vue.nextTick)();
+			if (event.defaultPrevented) return;
+			if (!require_utils.isMouseEvent(event)) return;
+			if (contentContext.highlightedElement.value !== currentElement.value) return;
+			if (!contentContext.onItemLeave(event) && contentContext.highlightedElement.value === currentElement.value) contentContext.highlightedElement.value = void 0;
+		}
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(CollectionItem), { value: { textValue: _ctx.textValue } }, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)({
+					ref: (0, vue.unref)(forwardRef),
+					role: "menuitem",
+					tabindex: "-1"
+				}, _ctx.$attrs, {
+					as: _ctx.as,
+					"as-child": _ctx.asChild,
+					"aria-disabled": _ctx.disabled || void 0,
+					"data-disabled": _ctx.disabled ? "" : void 0,
+					"data-highlighted": isHighlighted.value ? "" : void 0,
+					onPointermove: handlePointerMove,
+					onPointerleave: handlePointerLeave,
+					onFocus: _cache[0] || (_cache[0] = async (event) => {
+						await (0, vue.nextTick)();
+						if (event.defaultPrevented || _ctx.disabled) return;
+						isFocused.value = true;
+						(0, vue.unref)(contentContext).highlightedElement.value = event.currentTarget;
+					}),
+					onBlur: _cache[1] || (_cache[1] = async (event) => {
+						await (0, vue.nextTick)();
+						if (event.defaultPrevented) return;
+						isFocused.value = false;
+					})
+				}), {
+					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+					_: 3
+				}, 16, [
+					"as",
+					"as-child",
+					"aria-disabled",
+					"data-disabled",
+					"data-highlighted"
+				])]),
+				_: 3
+			}, 8, ["value"]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "MenuItemImpl_default", {
+	enumerable: true,
+	get: function() {
+		return MenuItemImpl_default;
+	}
+});

package/dist/cjs/chunks/MenuRoot.cjs

@@ -0,0 +1,108 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_PopperRoot = require("./PopperRoot.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useIsUsingKeyboard.js
+function useIsUsingKeyboardImpl() {
+	const isUsingKeyboard = (0, vue.ref)(false);
+	(0, vue.onMounted)(() => {
+		require_dist.useEventListener("keydown", () => {
+			isUsingKeyboard.value = true;
+		}, {
+			capture: true,
+			passive: true
+		});
+		require_dist.useEventListener(["pointerdown", "pointermove"], () => {
+			isUsingKeyboard.value = false;
+		}, {
+			capture: true,
+			passive: true
+		});
+	});
+	return isUsingKeyboard;
+}
+var useIsUsingKeyboard = require_dist.createSharedComposable(useIsUsingKeyboardImpl);
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuRoot.js
+var [injectMenuContext, provideMenuContext] = /* @__PURE__ */ require_createContext.createContext(["MenuRoot", "MenuSub"], "MenuContext");
+var [injectMenuRootContext, provideMenuRootContext] = /* @__PURE__ */ require_createContext.createContext("MenuRoot");
+var MenuRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuRoot",
+	props: {
+		open: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		modal: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { modal, dir: propDir } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		const open = require_dist.useVModel(props, "open", emits);
+		const content = (0, vue.ref)();
+		const isUsingKeyboardRef = useIsUsingKeyboard();
+		provideMenuContext({
+			open,
+			onOpenChange: (value) => {
+				open.value = value;
+			},
+			content,
+			onContentChange: (element) => {
+				content.value = element;
+			}
+		});
+		provideMenuRootContext({
+			onClose: () => {
+				open.value = false;
+			},
+			isUsingKeyboardRef,
+			dir,
+			modal
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperRoot.PopperRoot_default), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "MenuRoot_default", {
+	enumerable: true,
+	get: function() {
+		return MenuRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectMenuContext", {
+	enumerable: true,
+	get: function() {
+		return injectMenuContext;
+	}
+});
+Object.defineProperty(exports, "injectMenuRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectMenuRootContext;
+	}
+});
+Object.defineProperty(exports, "provideMenuContext", {
+	enumerable: true,
+	get: function() {
+		return provideMenuContext;
+	}
+});

package/dist/cjs/chunks/MenuSub.cjs

@@ -0,0 +1,68 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_PopperRoot = require("./PopperRoot.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@5.9.3_/node_modules/reka-ui/dist/Menu/MenuSub.js
+var [injectMenuSubContext, provideMenuSubContext] = /* @__PURE__ */ require_createContext.createContext("MenuSub");
+var MenuSub_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuSub",
+	props: { open: {
+		type: Boolean,
+		required: false,
+		default: void 0
+	} },
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const open = require_dist.useVModel(props, "open", __emit, {
+			defaultValue: false,
+			passive: props.open === void 0
+		});
+		const parentMenuContext = require_MenuRoot.injectMenuContext();
+		const trigger = (0, vue.ref)();
+		const content = (0, vue.ref)();
+		(0, vue.watchEffect)((cleanupFn) => {
+			if (parentMenuContext?.open.value === false) open.value = false;
+			cleanupFn(() => open.value = false);
+		});
+		require_MenuRoot.provideMenuContext({
+			open,
+			onOpenChange: (value) => {
+				open.value = value;
+			},
+			content,
+			onContentChange: (element) => {
+				content.value = element;
+			}
+		});
+		provideMenuSubContext({
+			triggerId: "",
+			contentId: "",
+			trigger,
+			onTriggerChange: (element) => {
+				trigger.value = element;
+			}
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperRoot.PopperRoot_default), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "MenuSub_default", {
+	enumerable: true,
+	get: function() {
+		return MenuSub_default;
+	}
+});
+Object.defineProperty(exports, "injectMenuSubContext", {
+	enumerable: true,
+	get: function() {
+		return injectMenuSubContext;
+	}
+});