reka-ui 2.3.1 → 2.4.0

package/dist/Menu/MenuRadioItem.js

@@ -1,45 +1,62 @@
-import { defineComponent, toRefs, computed, createBlock, openBlock, mergeProps, unref, withCtx, renderSlot } from 'vue';
-import { _ as _sfc_main$1 } from './MenuItem.js';
-import { a as getCheckedState } from './utils.js';
-import { i as injectMenuRadioGroupContext } from './MenuRadioGroup.js';
-import { p as provideMenuItemIndicatorContext } from './MenuItemIndicator.js';
+import { getCheckedState } from "./utils.js";
+import { MenuItem_default } from "./MenuItem.js";
+import { provideMenuItemIndicatorContext } from "./MenuItemIndicator.js";
+import { injectMenuRadioGroupContext } from "./MenuRadioGroup.js";
+import { computed, createBlock, defineComponent, mergeProps, openBlock, renderSlot, toRefs, unref, withCtx } from "vue";
 
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "MenuRadioItem",
-  props: {
-    value: {},
-    disabled: { type: Boolean },
-    textValue: {},
-    asChild: { type: Boolean },
-    as: {}
-  },
-  emits: ["select"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { value } = toRefs(props);
-    const radioGroupContext = injectMenuRadioGroupContext();
-    const modelValue = computed(
-      () => radioGroupContext.modelValue.value === value?.value
-    );
-    provideMenuItemIndicatorContext({ modelValue });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(_sfc_main$1, mergeProps({ role: "menuitemradio" }, props, {
-        "aria-checked": modelValue.value,
-        "data-state": unref(getCheckedState)(modelValue.value),
-        onSelect: _cache[0] || (_cache[0] = async (event) => {
-          emits("select", event);
-          unref(radioGroupContext).onValueChange(unref(value));
-        })
-      }), {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 16, ["aria-checked", "data-state"]);
-    };
-  }
+//#region src/Menu/MenuRadioItem.vue?vue&type=script&setup=true&lang.ts
+var MenuRadioItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "MenuRadioItem",
+	props: {
+		value: {
+			type: String,
+			required: true
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		textValue: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["select"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { value } = toRefs(props);
+		const radioGroupContext = injectMenuRadioGroupContext();
+		const modelValue = computed(() => radioGroupContext.modelValue.value === value?.value);
+		provideMenuItemIndicatorContext({ modelValue });
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(MenuItem_default, mergeProps({ role: "menuitemradio" }, props, {
+				"aria-checked": modelValue.value,
+				"data-state": unref(getCheckedState)(modelValue.value),
+				onSelect: _cache[0] || (_cache[0] = async (event) => {
+					emits("select", event);
+					unref(radioGroupContext).onValueChange(unref(value));
+				})
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["aria-checked", "data-state"]);
+		};
+	}
 });
 
-export { _sfc_main as _ };
-//# sourceMappingURL=MenuRadioItem.js.map
+//#endregion
+//#region src/Menu/MenuRadioItem.vue
+var MenuRadioItem_default = MenuRadioItem_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { MenuRadioItem_default };
+//# sourceMappingURL=MenuRadioItem.js.map

package/dist/Menu/MenuRadioItem.js.map

@@ -1 +1 @@
-{"version":3,"file":"MenuRadioItem.js","sources":["../../src/Menu/MenuRadioItem.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type {\n  MenuItemEmits,\n  MenuItemProps,\n} from './MenuItem.vue'\n\nexport type MenuRadioItemEmits = MenuItemEmits\n\nexport interface MenuRadioItemProps extends MenuItemProps {\n  /** The unique value of the item. */\n  value: string\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { computed, toRefs } from 'vue'\nimport MenuItem from './MenuItem.vue'\nimport { provideMenuItemIndicatorContext } from './MenuItemIndicator.vue'\nimport { injectMenuRadioGroupContext } from './MenuRadioGroup.vue'\nimport { getCheckedState } from './utils'\n\nconst props = defineProps<MenuRadioItemProps>()\nconst emits = defineEmits<MenuRadioItemEmits>()\n\nconst { value } = toRefs(props)\nconst radioGroupContext = injectMenuRadioGroupContext()\nconst modelValue = computed(\n  () => radioGroupContext.modelValue.value === value?.value,\n)\n\nprovideMenuItemIndicatorContext({ modelValue })\n</script>\n\n<template>\n  <MenuItem\n    role=\"menuitemradio\"\n    v-bind=\"props\"\n    :aria-checked=\"modelValue\"\n    :data-state=\"getCheckedState(modelValue)\"\n    @select=\"\n      async (event) => {\n        emits('select', event);\n        radioGroupContext.onValueChange(value);\n      }\n    \"\n  >\n    <slot />\n  </MenuItem>\n</template>\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAqBA,IAAA,MAAM,KAAQ,GAAA,OAAA;AACd,IAAA,MAAM,KAAQ,GAAA,MAAA;AAEd,IAAA,MAAM,EAAE,KAAA,EAAU,GAAA,MAAA,CAAO,KAAK,CAAA;AAC9B,IAAA,MAAM,oBAAoB,2BAA4B,EAAA;AACtD,IAAA,MAAM,UAAa,GAAA,QAAA;AAAA,MACjB,MAAM,iBAAA,CAAkB,UAAW,CAAA,KAAA,KAAU,KAAO,EAAA;AAAA,KACtD;AAEA,IAAgC,+BAAA,CAAA,EAAE,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"MenuRadioItem.js","names":[],"sources":["../../src/Menu/MenuRadioItem.vue","../../src/Menu/MenuRadioItem.vue"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBA,MAAM,QAAQ;EACd,MAAM,QAAQ;EAEd,MAAM,EAAE,OAAO,GAAG,OAAO,MAAK;EAC9B,MAAM,oBAAoB,6BAA4B;EACtD,MAAM,aAAa,SACjB,MAAM,kBAAkB,WAAW,UAAU,OAAO,MACtD;AAEA,kCAAgC,EAAE,WAAY,EAAA;;uBAI5C,YAaW,kBAbX,WAaW,EAZT,MAAK,gBAAe,GACZ,OAAK;IACZ,gBAAc,WAAA;IACd,cAAY,MAAA,gBAAe,CAAC,WAAA,MAAU;IACtC,UAAM,OAAA,OAAA,OAAA,YAAgB,UAAK;AAAe,WAAK,UAAW,MAAK;AAAW,WAAA,kBAAiB,CAAC,cAAc,MAAA,MAAK,CAAA;;;qBAOhH,MAAQ,CAAR,WAAQ,KAAA,QAAA,UAAA"}

package/dist/Menu/MenuRoot.cjs

@@ -1,61 +1,95 @@
-'use strict';
+const require_rolldown_runtime = require('../rolldown-runtime.cjs');
+const require_shared_createContext = require('../shared/createContext.cjs');
+const require_shared_useDirection = require('../shared/useDirection.cjs');
+const require_Popper_PopperRoot = require('../Popper/PopperRoot.cjs');
+const require_shared_useIsUsingKeyboard = require('../shared/useIsUsingKeyboard.cjs');
+const vue = require_rolldown_runtime.__toESM(require("vue"));
+const __vueuse_core = require_rolldown_runtime.__toESM(require("@vueuse/core"));
 
-const vue = require('vue');
-const core = require('@vueuse/core');
-const Popper_PopperRoot = require('../Popper/PopperRoot.cjs');
-const shared_useIsUsingKeyboard = require('../shared/useIsUsingKeyboard.cjs');
-const shared_createContext = require('../shared/createContext.cjs');
-const shared_useDirection = require('../shared/useDirection.cjs');
+//#region src/Menu/MenuRoot.vue?vue&type=script&setup=true&lang.ts
+const [injectMenuContext, provideMenuContext] = require_shared_createContext.createContext(["MenuRoot", "MenuSub"], "MenuContext");
+const [injectMenuRootContext, provideMenuRootContext] = require_shared_createContext.createContext("MenuRoot");
+var MenuRoot_vue_vue_type_script_setup_true_lang_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_shared_useDirection.useDirection(propDir);
+		const open = (0, __vueuse_core.useVModel)(props, "open", emits);
+		const content = (0, vue.ref)();
+		const isUsingKeyboardRef = require_shared_useIsUsingKeyboard.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_Popper_PopperRoot.PopperRoot_default), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			});
+		};
+	}
+});
+
+//#endregion
+//#region src/Menu/MenuRoot.vue
+var MenuRoot_default = MenuRoot_vue_vue_type_script_setup_true_lang_default;
 
-const [injectMenuContext, provideMenuContext] = shared_createContext.createContext(["MenuRoot", "MenuSub"], "MenuContext");
-const [injectMenuRootContext, provideMenuRootContext] = shared_createContext.createContext("MenuRoot");
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  __name: "MenuRoot",
-  props: {
-    open: { type: Boolean, default: false },
-    dir: {},
-    modal: { type: Boolean, default: true }
-  },
-  emits: ["update:open"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { modal, dir: propDir } = vue.toRefs(props);
-    const dir = shared_useDirection.useDirection(propDir);
-    const open = core.useVModel(props, "open", emits);
-    const content = vue.ref();
-    const isUsingKeyboardRef = shared_useIsUsingKeyboard.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 vue.openBlock(), vue.createBlock(vue.unref(Popper_PopperRoot._sfc_main), null, {
-        default: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      });
-    };
+//#endregion
+Object.defineProperty(exports, 'MenuRoot_default', {
+  enumerable: true,
+  get: function () {
+    return MenuRoot_default;
   }
 });
-
-exports._sfc_main = _sfc_main;
-exports.injectMenuContext = injectMenuContext;
-exports.injectMenuRootContext = injectMenuRootContext;
-exports.provideMenuContext = provideMenuContext;
-//# sourceMappingURL=MenuRoot.cjs.map
+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;
+  }
+});
+//# sourceMappingURL=MenuRoot.cjs.map

package/dist/Menu/MenuRoot.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"MenuRoot.cjs","sources":["../../src/Menu/MenuRoot.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { Ref } from 'vue'\nimport type { Direction } from './utils'\nimport { createContext, useDirection } from '@/shared'\nimport { useIsUsingKeyboard } from '@/shared/useIsUsingKeyboard'\n\nexport interface MenuContext {\n  open: Ref<boolean>\n  onOpenChange: (open: boolean) => void\n  content: Ref<HTMLElement | undefined>\n  onContentChange: (content: HTMLElement | undefined) => void\n}\n\nexport interface MenuRootContext {\n  onClose: () => void\n  dir: Ref<Direction>\n  isUsingKeyboardRef: Ref<boolean>\n  modal: Ref<boolean>\n}\n\nexport interface MenuProps {\n  /** The controlled open state of the menu. Can be used as `v-model:open`. */\n  open?: boolean\n  /**\n   * The reading direction of the combobox when applicable.\n   *\n   * If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode.\n   */\n  dir?: Direction\n  /**\n   * The modality of the dropdown menu.\n   *\n   * When set to `true`, interaction with outside elements will be disabled and only menu content will be visible to screen readers.\n   */\n  modal?: boolean\n}\n\nexport type MenuEmits = {\n  'update:open': [payload: boolean]\n}\n\nexport const [injectMenuContext, provideMenuContext]\n  = createContext<MenuContext>(['MenuRoot', 'MenuSub'], 'MenuContext')\n\nexport const [injectMenuRootContext, provideMenuRootContext]\n  = createContext<MenuRootContext>('MenuRoot')\n</script>\n\n<script setup lang=\"ts\">\nimport { useVModel } from '@vueuse/core'\nimport {\n  ref,\n  toRefs,\n} from 'vue'\nimport { PopperRoot } from '@/Popper'\n\nconst props = withDefaults(defineProps<MenuProps>(), {\n  open: false,\n  modal: true,\n})\nconst emits = defineEmits<MenuEmits>()\nconst { modal, dir: propDir } = toRefs(props)\nconst dir = useDirection(propDir)\n\nconst open = useVModel(props, 'open', emits)\n\nconst content = ref<HTMLElement>()\nconst isUsingKeyboardRef = useIsUsingKeyboard()\n\nprovideMenuContext({\n  open,\n  onOpenChange: (value) => {\n    open.value = value\n  },\n  content,\n  onContentChange: (element) => {\n    content.value = element\n  },\n})\n\nprovideMenuRootContext({\n  onClose: () => {\n    open.value = false\n  },\n  isUsingKeyboardRef,\n  dir,\n  modal,\n})\n</script>\n\n<template>\n  <PopperRoot>\n    <slot />\n  </PopperRoot>\n</template>\n"],"names":["createContext","toRefs","useDirection","useVModel","ref","useIsUsingKeyboard"],"mappings":";;;;;;;;;AAyCa,MAAA,CAAC,mBAAmB,kBAAkB,CAAA,GAC/CA,mCAA2B,CAAC,UAAA,EAAY,SAAS,CAAA,EAAG,aAAa;AAE9D,MAAM,CAAC,qBAAA,EAAuB,sBAAsB,CAAA,GACvDA,mCAA+B,UAAU;;;;;;;;;;AAW7C,IAAA,MAAM,KAAQ,GAAA,OAAA;AAId,IAAA,MAAM,KAAQ,GAAA,MAAA;AACd,IAAA,MAAM,EAAE,KAAO,EAAA,GAAA,EAAK,OAAQ,EAAA,GAAIC,WAAO,KAAK,CAAA;AAC5C,IAAM,MAAA,GAAA,GAAMC,iCAAa,OAAO,CAAA;AAEhC,IAAA,MAAM,IAAO,GAAAC,cAAA,CAAU,KAAO,EAAA,MAAA,EAAQ,KAAK,CAAA;AAE3C,IAAA,MAAM,UAAUC,OAAiB,EAAA;AACjC,IAAA,MAAM,qBAAqBC,4CAAmB,EAAA;AAE9C,IAAmB,kBAAA,CAAA;AAAA,MACjB,IAAA;AAAA,MACA,YAAA,EAAc,CAAC,KAAU,KAAA;AACvB,QAAA,IAAA,CAAK,KAAQ,GAAA,KAAA;AAAA,OACf;AAAA,MACA,OAAA;AAAA,MACA,eAAA,EAAiB,CAAC,OAAY,KAAA;AAC5B,QAAA,OAAA,CAAQ,KAAQ,GAAA,OAAA;AAAA;AAClB,KACD,CAAA;AAED,IAAuB,sBAAA,CAAA;AAAA,MACrB,SAAS,MAAM;AACb,QAAA,IAAA,CAAK,KAAQ,GAAA,KAAA;AAAA,OACf;AAAA,MACA,kBAAA;AAAA,MACA,GAAA;AAAA,MACA;AAAA,KACD,CAAA;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"MenuRoot.cjs","names":[],"sources":["../../src/Menu/MenuRoot.vue","../../src/Menu/MenuRoot.vue"],"sourcesContent":[],"mappings":";;;;;;;;;AAyCA,MAAa,CAAC,mBAAmB,mBAAkB,GAC/C,2CAA2B,CAAC,YAAY,SAAU,GAAE,cAAa;AAErE,MAAa,CAAC,uBAAuB,uBAAsB,GACvD,2CAA+B,WAAU;;;;;;;;;;;;;;;;;;;;;EAW7C,MAAM,QAAQ;EAId,MAAM,QAAQ;EACd,MAAM,EAAE,OAAO,KAAK,SAAS,GAAG,gBAAO,MAAK;EAC5C,MAAM,MAAM,yCAAa,QAAO;EAEhC,MAAM,OAAO,6BAAU,OAAO,QAAQ,MAAK;EAE3C,MAAM,UAAU,cAAiB;EACjC,MAAM,qBAAqB,sDAAmB;AAE9C,qBAAmB;GACjB;GACA,cAAc,CAAC,UAAU;AACvB,SAAK,QAAQ;GACd;GACD;GACA,iBAAiB,CAAC,YAAY;AAC5B,YAAQ,QAAQ;GACjB;EACF,EAAA;AAED,yBAAuB;GACrB,SAAS,MAAM;AACb,SAAK,QAAQ;GACd;GACD;GACA;GACA;EACD,EAAA;;gCAIC,qBAEa,eAAA,6CAAA,EAAA,MAAA;8BADX,MAAQ,CAAR,oBAAQ,KAAA,QAAA,UAAA"}

package/dist/Menu/MenuRoot.js

@@ -1,56 +1,71 @@
-import { defineComponent, toRefs, ref, createBlock, openBlock, unref, withCtx, renderSlot } from 'vue';
-import { useVModel } from '@vueuse/core';
-import { _ as _sfc_main$1 } from '../Popper/PopperRoot.js';
-import { u as useIsUsingKeyboard } from '../shared/useIsUsingKeyboard.js';
-import { c as createContext } from '../shared/createContext.js';
-import { u as useDirection } from '../shared/useDirection.js';
+import { createContext } from "../shared/createContext.js";
+import { useDirection } from "../shared/useDirection.js";
+import { PopperRoot_default } from "../Popper/PopperRoot.js";
+import { useIsUsingKeyboard } from "../shared/useIsUsingKeyboard.js";
+import { createBlock, defineComponent, openBlock, ref, renderSlot, toRefs, unref, withCtx } from "vue";
+import { useVModel } from "@vueuse/core";
 
+//#region src/Menu/MenuRoot.vue?vue&type=script&setup=true&lang.ts
 const [injectMenuContext, provideMenuContext] = createContext(["MenuRoot", "MenuSub"], "MenuContext");
 const [injectMenuRootContext, provideMenuRootContext] = createContext("MenuRoot");
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "MenuRoot",
-  props: {
-    open: { type: Boolean, default: false },
-    dir: {},
-    modal: { type: Boolean, default: true }
-  },
-  emits: ["update:open"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { modal, dir: propDir } = toRefs(props);
-    const dir = useDirection(propDir);
-    const open = useVModel(props, "open", emits);
-    const content = 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 openBlock(), createBlock(unref(_sfc_main$1), null, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      });
-    };
-  }
+var MenuRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ 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 } = toRefs(props);
+		const dir = useDirection(propDir);
+		const open = useVModel(props, "open", emits);
+		const content = 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 openBlock(), createBlock(unref(PopperRoot_default), null, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			});
+		};
+	}
 });
 
-export { _sfc_main as _, injectMenuRootContext as a, injectMenuContext as i, provideMenuContext as p };
-//# sourceMappingURL=MenuRoot.js.map
+//#endregion
+//#region src/Menu/MenuRoot.vue
+var MenuRoot_default = MenuRoot_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { MenuRoot_default, injectMenuContext, injectMenuRootContext, provideMenuContext };
+//# sourceMappingURL=MenuRoot.js.map

package/dist/Menu/MenuRoot.js.map

@@ -1 +1 @@
-{"version":3,"file":"MenuRoot.js","sources":["../../src/Menu/MenuRoot.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { Ref } from 'vue'\nimport type { Direction } from './utils'\nimport { createContext, useDirection } from '@/shared'\nimport { useIsUsingKeyboard } from '@/shared/useIsUsingKeyboard'\n\nexport interface MenuContext {\n  open: Ref<boolean>\n  onOpenChange: (open: boolean) => void\n  content: Ref<HTMLElement | undefined>\n  onContentChange: (content: HTMLElement | undefined) => void\n}\n\nexport interface MenuRootContext {\n  onClose: () => void\n  dir: Ref<Direction>\n  isUsingKeyboardRef: Ref<boolean>\n  modal: Ref<boolean>\n}\n\nexport interface MenuProps {\n  /** The controlled open state of the menu. Can be used as `v-model:open`. */\n  open?: boolean\n  /**\n   * The reading direction of the combobox when applicable.\n   *\n   * If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode.\n   */\n  dir?: Direction\n  /**\n   * The modality of the dropdown menu.\n   *\n   * When set to `true`, interaction with outside elements will be disabled and only menu content will be visible to screen readers.\n   */\n  modal?: boolean\n}\n\nexport type MenuEmits = {\n  'update:open': [payload: boolean]\n}\n\nexport const [injectMenuContext, provideMenuContext]\n  = createContext<MenuContext>(['MenuRoot', 'MenuSub'], 'MenuContext')\n\nexport const [injectMenuRootContext, provideMenuRootContext]\n  = createContext<MenuRootContext>('MenuRoot')\n</script>\n\n<script setup lang=\"ts\">\nimport { useVModel } from '@vueuse/core'\nimport {\n  ref,\n  toRefs,\n} from 'vue'\nimport { PopperRoot } from '@/Popper'\n\nconst props = withDefaults(defineProps<MenuProps>(), {\n  open: false,\n  modal: true,\n})\nconst emits = defineEmits<MenuEmits>()\nconst { modal, dir: propDir } = toRefs(props)\nconst dir = useDirection(propDir)\n\nconst open = useVModel(props, 'open', emits)\n\nconst content = ref<HTMLElement>()\nconst isUsingKeyboardRef = useIsUsingKeyboard()\n\nprovideMenuContext({\n  open,\n  onOpenChange: (value) => {\n    open.value = value\n  },\n  content,\n  onContentChange: (element) => {\n    content.value = element\n  },\n})\n\nprovideMenuRootContext({\n  onClose: () => {\n    open.value = false\n  },\n  isUsingKeyboardRef,\n  dir,\n  modal,\n})\n</script>\n\n<template>\n  <PopperRoot>\n    <slot />\n  </PopperRoot>\n</template>\n"],"names":[],"mappings":";;;;;;;AAyCa,MAAA,CAAC,mBAAmB,kBAAkB,CAAA,GAC/C,cAA2B,CAAC,UAAA,EAAY,SAAS,CAAA,EAAG,aAAa;AAE9D,MAAM,CAAC,qBAAA,EAAuB,sBAAsB,CAAA,GACvD,cAA+B,UAAU;;;;;;;;;;AAW7C,IAAA,MAAM,KAAQ,GAAA,OAAA;AAId,IAAA,MAAM,KAAQ,GAAA,MAAA;AACd,IAAA,MAAM,EAAE,KAAO,EAAA,GAAA,EAAK,OAAQ,EAAA,GAAI,OAAO,KAAK,CAAA;AAC5C,IAAM,MAAA,GAAA,GAAM,aAAa,OAAO,CAAA;AAEhC,IAAA,MAAM,IAAO,GAAA,SAAA,CAAU,KAAO,EAAA,MAAA,EAAQ,KAAK,CAAA;AAE3C,IAAA,MAAM,UAAU,GAAiB,EAAA;AACjC,IAAA,MAAM,qBAAqB,kBAAmB,EAAA;AAE9C,IAAmB,kBAAA,CAAA;AAAA,MACjB,IAAA;AAAA,MACA,YAAA,EAAc,CAAC,KAAU,KAAA;AACvB,QAAA,IAAA,CAAK,KAAQ,GAAA,KAAA;AAAA,OACf;AAAA,MACA,OAAA;AAAA,MACA,eAAA,EAAiB,CAAC,OAAY,KAAA;AAC5B,QAAA,OAAA,CAAQ,KAAQ,GAAA,OAAA;AAAA;AAClB,KACD,CAAA;AAED,IAAuB,sBAAA,CAAA;AAAA,MACrB,SAAS,MAAM;AACb,QAAA,IAAA,CAAK,KAAQ,GAAA,KAAA;AAAA,OACf;AAAA,MACA,kBAAA;AAAA,MACA,GAAA;AAAA,MACA;AAAA,KACD,CAAA;;;;;;;;;;;;;;"}
+{"version":3,"file":"MenuRoot.js","names":[],"sources":["../../src/Menu/MenuRoot.vue","../../src/Menu/MenuRoot.vue"],"sourcesContent":[],"mappings":";;;;;;;;AAyCA,MAAa,CAAC,mBAAmB,mBAAkB,GAC/C,cAA2B,CAAC,YAAY,SAAU,GAAE,cAAa;AAErE,MAAa,CAAC,uBAAuB,uBAAsB,GACvD,cAA+B,WAAU;;;;;;;;;;;;;;;;;;;;;EAW7C,MAAM,QAAQ;EAId,MAAM,QAAQ;EACd,MAAM,EAAE,OAAO,KAAK,SAAS,GAAG,OAAO,MAAK;EAC5C,MAAM,MAAM,aAAa,QAAO;EAEhC,MAAM,OAAO,UAAU,OAAO,QAAQ,MAAK;EAE3C,MAAM,UAAU,KAAiB;EACjC,MAAM,qBAAqB,oBAAmB;AAE9C,qBAAmB;GACjB;GACA,cAAc,CAAC,UAAU;AACvB,SAAK,QAAQ;GACd;GACD;GACA,iBAAiB,CAAC,YAAY;AAC5B,YAAQ,QAAQ;GACjB;EACF,EAAA;AAED,yBAAuB;GACrB,SAAS,MAAM;AACb,SAAK,QAAQ;GACd;GACD;GACA;GACA;EACD,EAAA;;uBAIC,YAEa,MAAA,mBAAA,EAAA,MAAA;qBADX,MAAQ,CAAR,WAAQ,KAAA,QAAA,UAAA"}

package/dist/Menu/MenuRootContentModal.cjs

@@ -1,59 +1,137 @@
-'use strict';
+const require_rolldown_runtime = require('../rolldown-runtime.cjs');
+const require_shared_useForwardExpose = require('../shared/useForwardExpose.cjs');
+const require_shared_useForwardPropsEmits = require('../shared/useForwardPropsEmits.cjs');
+const require_shared_useHideOthers = require('../shared/useHideOthers.cjs');
+const require_Menu_MenuRoot = require('./MenuRoot.cjs');
+const require_Menu_MenuContentImpl = require('./MenuContentImpl.cjs');
+const vue = require_rolldown_runtime.__toESM(require("vue"));
 
-const vue = require('vue');
-const Menu_MenuContentImpl = require('./MenuContentImpl.cjs');
-const shared_useForwardPropsEmits = require('../shared/useForwardPropsEmits.cjs');
-const shared_useForwardExpose = require('../shared/useForwardExpose.cjs');
-const shared_useHideOthers = require('../shared/useHideOthers.cjs');
-const Menu_MenuRoot = require('./MenuRoot.cjs');
+//#region src/Menu/MenuRootContentModal.vue?vue&type=script&setup=true&lang.ts
+var MenuRootContentModal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "MenuRootContentModal",
+	props: {
+		loop: {
+			type: Boolean,
+			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
+		},
+		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
+		}
+	},
+	emits: [
+		"escapeKeyDown",
+		"pointerDownOutside",
+		"focusOutside",
+		"interactOutside",
+		"entryFocus",
+		"openAutoFocus",
+		"closeAutoFocus"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = require_shared_useForwardPropsEmits.useForwardPropsEmits(props, emits);
+		const menuContext = require_Menu_MenuRoot.injectMenuContext();
+		const { forwardRef, currentElement } = require_shared_useForwardExpose.useForwardExpose();
+		require_shared_useHideOthers.useHideOthers(currentElement);
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)(require_Menu_MenuContentImpl.MenuContentImpl_default, (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+				ref: (0, vue.unref)(forwardRef),
+				"trap-focus": (0, vue.unref)(menuContext).open.value,
+				"disable-outside-pointer-events": (0, vue.unref)(menuContext).open.value,
+				"disable-outside-scroll": true,
+				onDismiss: _cache[0] || (_cache[0] = ($event) => (0, vue.unref)(menuContext).onOpenChange(false)),
+				onFocusOutside: _cache[1] || (_cache[1] = (0, vue.withModifiers)(($event) => emits("focusOutside", $event), ["prevent"]))
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["trap-focus", "disable-outside-pointer-events"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/Menu/MenuRootContentModal.vue
+var MenuRootContentModal_default = MenuRootContentModal_vue_vue_type_script_setup_true_lang_default;
 
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  __name: "MenuRootContentModal",
-  props: {
-    loop: { type: Boolean },
-    side: {},
-    sideOffset: {},
-    align: {},
-    alignOffset: {},
-    avoidCollisions: { type: Boolean },
-    collisionBoundary: {},
-    collisionPadding: {},
-    arrowPadding: {},
-    sticky: {},
-    hideWhenDetached: { type: Boolean },
-    positionStrategy: {},
-    updatePositionStrategy: {},
-    disableUpdateOnLayoutShift: { type: Boolean },
-    prioritizePosition: { type: Boolean },
-    reference: {},
-    asChild: { type: Boolean },
-    as: {}
-  },
-  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "entryFocus", "openAutoFocus", "closeAutoFocus"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const forwarded = shared_useForwardPropsEmits.useForwardPropsEmits(props, emits);
-    const menuContext = Menu_MenuRoot.injectMenuContext();
-    const { forwardRef, currentElement } = shared_useForwardExpose.useForwardExpose();
-    shared_useHideOthers.useHideOthers(currentElement);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(Menu_MenuContentImpl._sfc_main, vue.mergeProps(vue.unref(forwarded), {
-        ref: vue.unref(forwardRef),
-        "trap-focus": vue.unref(menuContext).open.value,
-        "disable-outside-pointer-events": vue.unref(menuContext).open.value,
-        "disable-outside-scroll": true,
-        onDismiss: _cache[0] || (_cache[0] = ($event) => vue.unref(menuContext).onOpenChange(false)),
-        onFocusOutside: _cache[1] || (_cache[1] = vue.withModifiers(($event) => emits("focusOutside", $event), ["prevent"]))
-      }), {
-        default: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 16, ["trap-focus", "disable-outside-pointer-events"]);
-    };
+//#endregion
+Object.defineProperty(exports, 'MenuRootContentModal_default', {
+  enumerable: true,
+  get: function () {
+    return MenuRootContentModal_default;
   }
 });
-
-exports._sfc_main = _sfc_main;
-//# sourceMappingURL=MenuRootContentModal.cjs.map
+//# sourceMappingURL=MenuRootContentModal.cjs.map

package/dist/Menu/MenuRootContentModal.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"MenuRootContentModal.cjs","sources":["../../src/Menu/MenuRootContentModal.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { MenuContentImplEmits, MenuRootContentTypeProps } from './MenuContentImpl.vue'\nimport { useForwardExpose, useForwardPropsEmits, useHideOthers } from '@/shared'\nimport MenuContentImpl from './MenuContentImpl.vue'\nimport { injectMenuContext } from './MenuRoot.vue'\n\nconst props = defineProps<MenuRootContentModalProps>()\nconst emits = defineEmits<MenuRootContentModalEmits>()\nconst forwarded = useForwardPropsEmits(props, emits)\n\nconst menuContext = injectMenuContext()\n\ninterface MenuRootContentModalProps extends MenuRootContentTypeProps {}\ntype MenuRootContentModalEmits = MenuContentImplEmits\n\nconst { forwardRef, currentElement } = useForwardExpose()\nuseHideOthers(currentElement)\n</script>\n\n<template>\n  <MenuContentImpl\n    v-bind=\"forwarded\"\n    :ref=\"forwardRef\"\n    :trap-focus=\"menuContext.open.value\"\n    :disable-outside-pointer-events=\"menuContext.open.value\"\n    :disable-outside-scroll=\"true\"\n    @dismiss=\"menuContext.onOpenChange(false)\"\n    @focus-outside.prevent=\"emits('focusOutside', $event)\"\n  >\n    <slot />\n  </MenuContentImpl>\n</template>\n"],"names":["useForwardPropsEmits","injectMenuContext","useForwardExpose","useHideOthers"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,IAAA,MAAM,KAAQ,GAAA,OAAA;AACd,IAAA,MAAM,KAAQ,GAAA,MAAA;AACd,IAAM,MAAA,SAAA,GAAYA,gDAAqB,CAAA,KAAA,EAAO,KAAK,CAAA;AAEnD,IAAA,MAAM,cAAcC,+BAAkB,EAAA;AAKtC,IAAA,MAAM,EAAE,UAAA,EAAY,cAAe,EAAA,GAAIC,wCAAiB,EAAA;AACxD,IAAAC,kCAAA,CAAc,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"MenuRootContentModal.cjs","names":[],"sources":["../../src/Menu/MenuRootContentModal.vue","../../src/Menu/MenuRootContentModal.vue"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMA,MAAM,QAAQ;EACd,MAAM,QAAQ;EACd,MAAM,YAAY,yDAAqB,OAAO,MAAK;EAEnD,MAAM,cAAc,yCAAkB;EAKtC,MAAM,EAAE,YAAY,gBAAgB,GAAG,kDAAiB;AACxD,6CAAc,eAAc;;gCAI1B,qBAUkB,sDAVlB,oBACU,eASQ,UATC,EAAA;IAChB,KAAK,eAAA,WAAU;IACf,cAAY,eAAA,YAAW,CAAC,KAAK;IAC7B,kCAAgC,eAAA,YAAW,CAAC,KAAK;IACjD,0BAAwB;IACxB,WAAO,OAAA,OAAA,OAAA,KAAA,CAAA,WAAE,eAAA,YAAW,CAAC,aAAY,MAAA;IACjC,gBAAa,OAAA,OAAA,OAAA,KAAA,uBAAA,CAAA,WAAU,MAAK,gBAAiB,OAAM,EAAA,CAAA,SAAA,EAAA;;8BAEpD,MAAQ,CAAR,oBAAQ,KAAA,QAAA,UAAA"}