@maas/vue-equipment 0.40.0 → 1.0.0-beta.2

package/dist/plugins/MagicMenu/src/components/MagicMenuRemote.vue

@@ -1,93 +1,104 @@
-<template>
-  <primitive
-    :class="[
-      'magic-menu-remote',
-      { '-active': channel?.active, '-disabled': disabled },
-    ]"
-    :data-id="`${channelId}-remote`"
-    :as-child="asChild"
-    @click="onClick"
-    @mouseenter="onMouseenter"
-  >
-    <slot :channel-active="channel?.active" :remote-disabled="disabled" />
-  </primitive>
-</template>
-
-<script lang="ts" setup>
-import { computed, inject, watch } from 'vue'
-import { Primitive } from '@maas/vue-primitive'
-import { useMenuView } from '../composables/private/useMenuView'
-import { useMenuChannel } from '../composables/private/useMenuChannel'
-import { MagicMenuInstanceId, MagicMenuViewId } from '../symbols'
-
-import type { Interaction } from '../types'
-import { useMenuRemote } from '../composables/private/useMenuRemote'
-
-interface MagicMenuRemoteProps {
-  channelId: string
-  viewId?: string
-  instanceId?: string
-  disabled?: boolean
-  trigger?: Interaction[]
-  asChild?: boolean
-}
-
-const props = defineProps<MagicMenuRemoteProps>()
-
-const instanceId = inject(MagicMenuInstanceId, props.instanceId)
-const viewId = inject(MagicMenuViewId, props.viewId)
-
-if (!instanceId) {
-  throw new Error(
-    'MagicMenuRemote must be nested inside MagicMenuProvider or an instanceId must be provided'
-  )
-}
-
-if (!viewId) {
-  throw new Error(
-    'MagicMenuTrigger must be nested inside MagicMenuView or a viewId must be provided'
-  )
-}
-
-if (!props.channelId) {
-  throw new Error('MagicMenuRemote requires a channelId')
-}
-
-const mappedChannelId = computed(() => `magic-menu-channel-${props.channelId}`)
-
-const mappedTrigger = computed<Interaction[]>(
-  () => props.trigger ?? ['mouseenter']
-)
-
-const { getView } = useMenuView(instanceId)
-const view = getView(viewId)
-
-const { initializeChannel, deleteChannel } = useMenuChannel({
-  instanceId,
-  viewId,
-})
-
-const { onClick, onMouseenter } = useMenuRemote({
-  viewId,
-  instanceId,
-  mappedChannelId,
-  mappedTrigger,
-})
-
-let channel = initializeChannel({ id: mappedChannelId.value })
-
-watch(
-  () => view?.active,
-  (value) => {
-    // Reset if parent view is inactive
-    if (!value) {
-      deleteChannel(mappedChannelId.value)
-      channel = initializeChannel({ id: mappedChannelId.value })
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { unref as _unref, renderSlot as _renderSlot, normalizeClass as _normalizeClass, withCtx as _withCtx, createVNode as _createVNode, resolveComponent as _resolveComponent, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { computed, inject, watch } from "vue";
+import { Primitive } from "@maas/vue-primitive";
+import { useMenuView } from "../composables/private/useMenuView";
+import { useMenuChannel } from "../composables/private/useMenuChannel";
+import { MagicMenuInstanceId, MagicMenuViewId } from "../symbols";
+import { useMenuRemote } from "../composables/private/useMenuRemote";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicMenuRemote",
+  props: {
+    channelId: { type: String, required: true },
+    viewId: { type: String, required: false },
+    instanceId: { type: String, required: false },
+    disabled: { type: Boolean, required: false },
+    trigger: { type: Array, required: false },
+    asChild: { type: Boolean, required: false }
+  },
+  setup(__props) {
+    const mappedInstanceId = inject(MagicMenuInstanceId, __props.instanceId);
+    const mappedViewId = inject(MagicMenuViewId, __props.viewId);
+    if (!mappedInstanceId) {
+      throw new Error(
+        "MagicMenuRemote must be nested inside MagicMenuProvider or an instanceId must be provided"
+      );
+    }
+    if (!mappedViewId) {
+      throw new Error(
+        "MagicMenuTrigger must be nested inside MagicMenuView or a viewId must be provided"
+      );
+    }
+    if (!__props.channelId) {
+      throw new Error("MagicMenuRemote requires a channelId");
     }
+    const mappedChannelId = computed(() => `magic-menu-channel-${__props.channelId}`);
+    const mappedTrigger = computed(() => __props.trigger ?? ["mouseenter"]);
+    const { getView } = useMenuView(mappedInstanceId);
+    const view = getView(mappedViewId);
+    const { initializeChannel, deleteChannel } = useMenuChannel({
+      instanceId: mappedInstanceId,
+      viewId: mappedViewId
+    });
+    const { onClick, onMouseenter } = useMenuRemote({
+      instanceId: mappedInstanceId,
+      viewId: mappedViewId,
+      mappedChannelId,
+      mappedTrigger
+    });
+    let channel = initializeChannel({ id: mappedChannelId.value });
+    watch(
+      () => view?.active,
+      (value) => {
+        if (!value) {
+          deleteChannel(mappedChannelId.value);
+          channel = initializeChannel({ id: mappedChannelId.value });
+        }
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_magic_menu_trigger = _resolveComponent("magic-menu-trigger");
+      return _openBlock(), _createBlock(_component_magic_menu_trigger, {
+        "view-id": _unref(mappedViewId),
+        disabled: _ctx.disabled,
+        trigger: _ctx.trigger
+      }, {
+        default: _withCtx(() => [
+          _createVNode(_unref(Primitive), {
+            class: _normalizeClass([
+              "magic-menu-remote",
+              { "-active": _unref(channel)?.active, "-disabled": _ctx.disabled }
+            ]),
+            "data-id": `${_ctx.channelId}-remote`,
+            "as-child": _ctx.asChild,
+            onClick: _unref(onClick),
+            onMouseenter: _unref(onMouseenter)
+          }, {
+            default: _withCtx(() => [
+              _renderSlot(_ctx.$slots, "default", {
+                channelActive: _unref(channel)?.active,
+                remoteDisabled: _ctx.disabled
+              })
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 8, ["class", "data-id", "as-child", "onClick", "onMouseenter"])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["view-id", "disabled", "trigger"]);
+    };
   }
-)
+});
 </script>
 
 <style>
-.magic-menu-remote{cursor:var(--magic-menu-remote-cursor,pointer)}.magic-menu-remote.-disabled{pointer-events:none}
+.magic-menu-remote {
+  cursor: var(--magic-menu-remote-cursor, pointer);
+}
+
+.magic-menu-remote.-disabled {
+  pointer-events: none;
+}
 </style>

package/dist/plugins/MagicMenu/src/components/MagicMenuRemote.vue.d.ts

@@ -1,4 +1,4 @@
-import type { Interaction } from '../types';
+import type { Interaction } from '../types/index.js';
 interface MagicMenuRemoteProps {
     channelId: string;
     viewId?: string;
@@ -19,9 +19,18 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<MagicMenuRemoteProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuRemoteProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuRemoteProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuRemoteProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/plugins/MagicMenu/src/components/MagicMenuTrigger.vue

@@ -1,121 +1,120 @@
-<template>
-  <primitive
-    ref="elRef"
-    :class="[
-      'magic-menu-trigger',
-      { '-active': view?.active, '-disabled': mappedDisabled },
-    ]"
-    :data-id="`${viewId}-trigger`"
-    :tabindex="mappedTabindex"
-    :as-child="asChild"
-    @click="onClick"
-    @contextmenu="onClick"
-    @mouseenter="onMouseenter"
-  >
-    <slot :view-active="view?.active" :trigger-disabled="mappedDisabled" />
-  </primitive>
-</template>
-
-<script lang="ts" setup>
-import { computed, inject, ref, toValue, watch } from 'vue'
-import { Primitive } from '@maas/vue-primitive'
-import { useMenuState } from '../composables/private/useMenuState'
-import { useMenuView } from '../composables/private/useMenuView'
-import { useMenuItem } from '../composables/private/useMenuItem'
-import { useMenuTrigger } from '../composables/private/useMenuTrigger'
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { unref as _unref, renderSlot as _renderSlot, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { computed, inject, ref, toValue, watch } from "vue";
+import { Primitive } from "@maas/vue-primitive";
+import { useMenuState } from "../composables/private/useMenuState";
+import { useMenuView } from "../composables/private/useMenuView";
+import { useMenuItem } from "../composables/private/useMenuItem";
+import { useMenuTrigger } from "../composables/private/useMenuTrigger";
 import {
   MagicMenuInstanceId,
   MagicMenuViewId,
-  MagicMenuItemId,
-} from '../symbols'
-
-import type { Interaction } from '../types'
-import { onKeyStroke } from '@vueuse/core'
-
-interface MagicMenuTriggerProps {
-  disabled?: boolean
-  trigger?: Interaction[]
-  asChild?: boolean
-}
-
-const props = defineProps<MagicMenuTriggerProps>()
-const elRef = ref<InstanceType<typeof Primitive> | undefined>(undefined)
-
-const instanceId = inject(MagicMenuInstanceId, undefined)
-const viewId = inject(MagicMenuViewId, undefined)
-const itemId = inject(MagicMenuItemId, undefined)
-
-if (!instanceId) {
-  throw new Error('MagicMenuTrigger must be nested inside MagicMenuProvider')
-}
-
-if (!viewId) {
-  throw new Error('MagicMenuTrigger must be nested inside MagicMenuView')
-}
-
-const { getView, getRelativeViewIndex } = useMenuView(instanceId)
-const view = getView(viewId)
-const viewIndex = getRelativeViewIndex(viewId)
-
-const { initializeState } = useMenuState(instanceId)
-const state = initializeState()
-
-const { getItem } = useMenuItem({ instanceId, viewId })
-const item = getItem(itemId ?? '')
-
-const mappedDisabled = computed(() => props.disabled ?? item?.disabled ?? false)
-
-const mappedTrigger = computed<Interaction[]>(() => {
-  if (props.trigger?.length) {
-    return props.trigger
-  }
-
-  switch (state.options.mode) {
-    case 'menubar':
-      return view?.parent.item
-        ? ['mouseenter', 'click']
-        : state.active
-        ? ['mouseenter', 'click']
-        : ['click']
-    case 'dropdown':
-      return view?.parent.item ? ['mouseenter', 'click'] : ['click']
-    case 'context':
-      return view?.parent.item ? ['mouseenter', 'click'] : ['right-click']
-    case 'navigation':
-      return ['mouseenter']
-  }
-})
-
-const mappedTabindex = computed(() => {
-  if (viewIndex === 0 && state.options.mode !== 'context' && !itemId) {
-    return 0
-  } else {
-    return undefined
-  }
-})
-
-const { onMouseenter, onClick, onEnter } = useMenuTrigger({
-  instanceId,
-  viewId,
-  itemId,
-  mappedDisabled,
-  mappedTrigger,
-  elRef,
-})
-
-watch(
-  () => view?.active,
-  async (value) => {
-    if (value) {
-      await new Promise((resolve) => requestAnimationFrame(resolve))
-      toValue(elRef)?.$el?.blur()
+  MagicMenuItemId
+} from "../symbols";
+import { onKeyStroke } from "@vueuse/core";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicMenuTrigger",
+  props: {
+    disabled: { type: Boolean, required: false },
+    trigger: { type: Array, required: false },
+    asChild: { type: Boolean, required: false }
+  },
+  setup(__props) {
+    const elRef = ref(void 0);
+    const instanceId = inject(MagicMenuInstanceId, void 0);
+    const viewId = inject(MagicMenuViewId, void 0);
+    const itemId = inject(MagicMenuItemId, void 0);
+    if (!instanceId) {
+      throw new Error("MagicMenuTrigger must be nested inside MagicMenuProvider");
+    }
+    if (!viewId) {
+      throw new Error("MagicMenuTrigger must be nested inside MagicMenuView");
     }
+    const { getView, getRelativeViewIndex } = useMenuView(instanceId);
+    const view = getView(viewId);
+    const viewIndex = getRelativeViewIndex(viewId);
+    const { initializeState } = useMenuState(instanceId);
+    const state = initializeState();
+    const { getItem } = useMenuItem({ instanceId, viewId });
+    const item = getItem(itemId ?? "");
+    const mappedDisabled = computed(() => __props.disabled ?? item?.disabled ?? false);
+    const mappedTrigger = computed(() => {
+      if (__props.trigger?.length) {
+        return __props.trigger;
+      }
+      switch (state.options.mode) {
+        case "menubar":
+          return view?.parent.item ? ["mouseenter", "click"] : state.active ? ["mouseenter", "click"] : ["click"];
+        case "dropdown":
+          return view?.parent.item ? ["mouseenter", "click"] : ["click"];
+        case "context":
+          return view?.parent.item ? ["mouseenter", "click"] : ["right-click"];
+        case "navigation":
+          return ["mouseenter"];
+        default:
+          return [];
+      }
+    });
+    const mappedTabindex = computed(() => {
+      if (viewIndex === 0 && state.options.mode !== "context" && !itemId) {
+        return 0;
+      } else {
+        return void 0;
+      }
+    });
+    const { onMouseenter, onClick, onEnter } = useMenuTrigger({
+      instanceId,
+      viewId,
+      itemId,
+      mappedDisabled,
+      mappedTrigger,
+      elRef
+    });
+    watch(
+      () => view?.active,
+      async (value) => {
+        if (value) {
+          await new Promise((resolve) => requestAnimationFrame(resolve));
+          toValue(elRef)?.$el?.blur();
+        }
+      }
+    );
+    onKeyStroke("Enter", onEnter);
+    return (_ctx, _cache) => {
+      return _openBlock(), _createBlock(_unref(Primitive), {
+        ref_key: "elRef",
+        ref: elRef,
+        "data-id": `${_unref(viewId)}-trigger`,
+        "data-active": _unref(view)?.active,
+        "data-disabled": mappedDisabled.value,
+        tabindex: mappedTabindex.value,
+        "as-child": _ctx.asChild,
+        class: "magic-menu-trigger",
+        onClick: _unref(onClick),
+        onContextmenu: _unref(onClick),
+        onMouseenter: _unref(onMouseenter)
+      }, {
+        default: _withCtx(() => [
+          _renderSlot(_ctx.$slots, "default", {
+            viewActive: _unref(view)?.active,
+            triggerDisabled: mappedDisabled.value
+          })
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["data-id", "data-active", "data-disabled", "tabindex", "as-child", "onClick", "onContextmenu", "onMouseenter"]);
+    };
   }
-)
-
-onKeyStroke('Enter', onEnter)
+});
 </script>
 
 <style>
-.magic-menu-trigger{cursor:var(--magic-menu-trigger-cursor,pointer)}.magic-menu-trigger.-disabled{pointer-events:none}
+.magic-menu-trigger {
+  cursor: var(--magic-menu-trigger-cursor, pointer);
+}
+
+.magic-menu-trigger.-disabled {
+  pointer-events: none;
+}
 </style>

package/dist/plugins/MagicMenu/src/components/MagicMenuTrigger.vue.d.ts

@@ -1,4 +1,4 @@
-import type { Interaction } from '../types';
+import type { Interaction } from '../types/index.js';
 interface MagicMenuTriggerProps {
     disabled?: boolean;
     trigger?: Interaction[];
@@ -53,9 +53,18 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<MagicMenuTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuTriggerProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuTriggerProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/plugins/MagicMenu/src/components/MagicMenuView.vue

@@ -1,77 +1,74 @@
-<template>
-  <div class="magic-menu-view" :id="mappedId">
-    <slot />
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { computed, inject, onBeforeUnmount, provide, useId } from 'vue'
-import { useMenuView } from '../composables/private/useMenuView'
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { unref as _unref, renderSlot as _renderSlot, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = ["id"];
+import { computed, inject, onBeforeUnmount, provide, useId } from "vue";
+import { useMenuView } from "../composables/private/useMenuView";
 import {
   MagicMenuInstanceId,
   MagicMenuViewId,
   MagicMenuParentTree,
   MagicMenuItemId,
-  MagicMenuViewActive,
-} from '../symbols'
-import type { Placement } from '@floating-ui/vue'
-import { useMenuState } from '../composables/private/useMenuState'
-
-interface MagicMenuViewProps {
-  id?: string
-  placement?: Placement
-}
-
-const props = defineProps<MagicMenuViewProps>()
-
-const parentTree = inject(MagicMenuParentTree, [])
-const instanceId = inject(MagicMenuInstanceId, undefined)
-const itemId = inject(MagicMenuItemId, undefined)
-
-if (!instanceId) {
-  throw new Error('MagicMenuView must be nested inside MagicMenuProvider')
-}
-
-const mappedId = computed(() => props.id ?? `magic-menu-view-${useId()}`)
-const mappedParentTree = computed(() => [...parentTree, mappedId.value])
-
-// Register view
-const { initializeView, deleteView } = useMenuView(instanceId)
-const { initializeState } = useMenuState(instanceId)
-const state = initializeState()
-
-const mappedPlacement = computed(() => {
-  if (props.placement) {
-    return props.placement
+  MagicMenuViewActive
+} from "../symbols";
+import { useMenuState } from "../composables/private/useMenuState";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicMenuView",
+  props: {
+    id: { type: String, required: false },
+    placement: { type: null, required: false }
+  },
+  setup(__props) {
+    const parentTree = inject(MagicMenuParentTree, []);
+    const instanceId = inject(MagicMenuInstanceId, void 0);
+    const itemId = inject(MagicMenuItemId, void 0);
+    if (!instanceId) {
+      throw new Error("MagicMenuView must be nested inside MagicMenuProvider");
+    }
+    const mappedId = computed(() => __props.id ?? `magic-menu-view-${useId()}`);
+    const mappedParentTree = computed(() => [...parentTree, mappedId.value]);
+    const mappedActive = computed(() => view.active);
+    const { initializeView, deleteView } = useMenuView(instanceId);
+    const { initializeState } = useMenuState(instanceId);
+    const state = initializeState();
+    const mappedPlacement = computed(() => {
+      if (__props.placement) {
+        return __props.placement;
+      }
+      switch (state.options.mode) {
+        case "navigation":
+          return "bottom";
+        case "menubar":
+          return !itemId ? "bottom-start" : "right-start";
+        case "dropdown":
+          return !itemId ? "bottom" : "right-start";
+        case "context":
+          return "right-start";
+        default:
+          return void 0;
+      }
+    });
+    const view = initializeView({
+      id: mappedId.value,
+      parent: { views: parentTree, item: itemId ?? "" },
+      placement: mappedPlacement.value ?? "bottom"
+    });
+    provide(MagicMenuParentTree, mappedParentTree.value);
+    provide(MagicMenuViewId, mappedId.value);
+    provide(MagicMenuViewActive, mappedActive);
+    onBeforeUnmount(() => {
+      deleteView(mappedId.value);
+    });
+    return (_ctx, _cache) => {
+      return _openBlock(), _createElementBlock("div", {
+        id: mappedId.value,
+        class: "magic-menu-view"
+      }, [
+        _renderSlot(_ctx.$slots, "default", {
+          viewActive: _unref(view).active
+        })
+      ], 8, _hoisted_1);
+    };
   }
-
-  switch (state.options.mode) {
-    case 'navigation':
-      return 'bottom'
-    case 'menubar':
-      return !itemId ? 'bottom-start' : 'right-start'
-    case 'dropdown':
-      return !itemId ? 'bottom' : 'right-start'
-    case 'context':
-      return 'right-start'
-    default:
-      return 'bottom'
-  }
-})
-
-const view = initializeView({
-  id: mappedId.value,
-  parent: { views: parentTree, item: itemId ?? '' },
-  placement: mappedPlacement.value,
-})
-
-// Pass id, active state and parent tree to children
-provide(MagicMenuParentTree, mappedParentTree.value)
-provide(MagicMenuViewId, mappedId.value)
-provide(MagicMenuViewActive, view.active)
-
-// Lifecycle
-onBeforeUnmount(() => {
-  deleteView(mappedId.value)
-})
+});
 </script>

package/dist/plugins/MagicMenu/src/components/MagicMenuView.vue.d.ts

@@ -6,15 +6,26 @@ interface MagicMenuViewProps {
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
-        default?(_: {}): any;
+        default?(_: {
+            viewActive: boolean;
+        }): any;
     };
     refs: {};
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<MagicMenuViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuViewProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuViewProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuViewProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/plugins/MagicMenu/src/composables/private/useMenuCallback.d.ts

@@ -12,11 +12,11 @@ type UseMenuCallbackArgs = {
     removeScrollLockPadding: () => void;
 };
 export declare function useMenuCallback(args: UseMenuCallbackArgs): {
-    onBeforeEnter: (_el: Element) => void;
-    onEnter: (_el: Element) => void;
-    onAfterEnter: (_el: Element) => void;
-    onBeforeLeave: (_el: Element) => void;
-    onLeave: (_el: Element) => void;
-    onAfterLeave: (_el: Element) => void;
+    onBeforeEnter: () => void;
+    onEnter: () => void;
+    onAfterEnter: () => void;
+    onBeforeLeave: () => void;
+    onLeave: () => void;
+    onAfterLeave: () => void;
 };
 export {};