ep-craft 0.1.33 → 0.1.34

package/dist/components/dropdown/index.js

@@ -1,6 +1,26 @@
-import { ElDropdown as o } from "element-plus";
 import { withInstall as p } from "../../utils/with-install.js";
-const n = Object.assign({}, o, { name: "EpDropdown" }), d = p(n, "ep-dropdown");
+import e from "./src/dropdown.vue.js";
+import t from "./src/dropdown-item.vue.js";
+import m from "./src/dropdown-menu.vue.js";
+import { FIRST_KEYS as I, FIRST_LAST_KEYS as S, LAST_KEYS as _, dropdownItemProps as u, dropdownMenuProps as f, dropdownProps as l } from "./src/dropdown.js";
+const r = p(t, "ep-dropdown-item"), d = p(m, "ep-dropdown-menu"), n = Object.assign(
+  p(e, "ep-dropdown"),
+  {
+    DropdownItem: r,
+    DropdownMenu: d
+  }
+);
+n.install = (o) => {
+  o.component("ep-dropdown", n), o.component("ep-dropdown-item", r), o.component("ep-dropdown-menu", d);
+};
 export {
-  d as EpDropdown
+  n as EpDropdown,
+  r as EpDropdownItem,
+  d as EpDropdownMenu,
+  I as FIRST_KEYS,
+  S as FIRST_LAST_KEYS,
+  _ as LAST_KEYS,
+  u as dropdownItemProps,
+  f as dropdownMenuProps,
+  l as dropdownProps
 };

package/dist/components/dropdown/src/dropdown-item-impl.vue.d.ts

@@ -0,0 +1,79 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+    dataset: {
+        "data-el-collection-item": string;
+    };
+    role: import("vue").ComputedRef<string>;
+    tabIndex: import("vue").Ref<number, number>;
+    handleFocus: (e: Event) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    handleMousedown: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+    onPointerleave?: ((...args: any[]) => any) | undefined;
+    onPointermove?: ((...args: any[]) => any) | undefined;
+    onClickimpl?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+    readonly command: import("@element-plus/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly divided: boolean;
+}, {}, {
+    ElIcon: import("@element-plus/utils").SFCWithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("@element-plus/components/icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("@element-plus/components/icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("@element-plus/components/icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    })>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/dropdown/src/dropdown-item-impl.vue.js

@@ -0,0 +1,40 @@
+import t from "./dropdown-item-impl2.vue.js";
+import { resolveComponent as a, openBlock as l, createElementBlock as i, Fragment as p, normalizeClass as u, createCommentVNode as s, createElementVNode as f, mergeProps as $, withModifiers as b, createBlock as r, withCtx as w, renderSlot as d, resolveDynamicComponent as v } from "vue";
+import k from "../../../_virtual/_plugin-vue_export-helper.js";
+const y = ["aria-disabled", "tabindex", "role"];
+function C(e, o, F, M, B, E) {
+  const m = a("el-icon");
+  return l(), i(p, null, [
+    e.divided ? (l(), i("li", {
+      key: 0,
+      role: "separator",
+      class: u(e.ns.bem("menu", "item", "divided"))
+    }, null, 2)) : s("", !0),
+    f("li", $({ ref: e.itemRef }, { ...e.dataset, ...e.$attrs }, {
+      "aria-disabled": e.disabled,
+      class: [e.ns.be("menu", "item"), e.ns.is("disabled", e.disabled)],
+      tabindex: e.tabIndex,
+      role: e.role,
+      onClick: o[0] || (o[0] = (n) => e.$emit("clickimpl", n)),
+      onFocus: o[1] || (o[1] = (...n) => e.handleFocus && e.handleFocus(...n)),
+      onKeydown: o[2] || (o[2] = b((...n) => e.handleKeydown && e.handleKeydown(...n), ["self"])),
+      onMousedown: o[3] || (o[3] = (...n) => e.handleMousedown && e.handleMousedown(...n)),
+      onPointermove: o[4] || (o[4] = (n) => e.$emit("pointermove", n)),
+      onPointerleave: o[5] || (o[5] = (n) => e.$emit("pointerleave", n))
+    }), [
+      e.icon || e.$slots.icon ? (l(), r(m, { key: 0 }, {
+        default: w(() => [
+          d(e.$slots, "icon", {}, () => [
+            (l(), r(v(e.icon)))
+          ])
+        ]),
+        _: 3
+      })) : s("", !0),
+      d(e.$slots, "default")
+    ], 16, y)
+  ], 64);
+}
+const g = /* @__PURE__ */ k(t, [["render", C]]);
+export {
+  g as default
+};

package/dist/components/dropdown/src/dropdown-item-impl2.vue.js

@@ -0,0 +1,68 @@
+import { defineComponent as E, inject as e, computed as _ } from "vue";
+import "../../roving-focus-group/src/roving-focus-group.vue.js";
+import "../../roving-focus-group/src/roving-focus-item2.vue.js";
+import { ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as O } from "../../roving-focus-group/src/tokens.js";
+import { EVENT_CODE as t } from "../../../constants/aria.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { composeEventHandlers as N, getEventCode as C } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { composeRefs as v } from "../../../utils/vue/refs.js";
+import { ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY as T } from "../../roving-focus-group/src/roving-focus-group.js";
+import { COLLECTION_ITEM_SIGN as R } from "../../collection/src/collection.js";
+import { ElIcon as w } from "../../icon/index.js";
+import { useNamespace as K } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { dropdownItemProps as L } from "./dropdown.js";
+import { DROPDOWN_INJECTION_KEY as g } from "./tokens.js";
+const $ = E({
+  name: "EpDropdownItemImpl",
+  components: {
+    ElIcon: w
+  },
+  props: L,
+  emits: ["pointermove", "pointerleave", "click", "clickimpl"],
+  setup(h, { emit: m }) {
+    const n = K("dropdown"), { role: r } = e(g, void 0), { collectionItemRef: i } = e(
+      T,
+      void 0
+    ), {
+      rovingFocusGroupItemRef: p,
+      tabIndex: s,
+      handleFocus: c,
+      handleKeydown: d,
+      handleMousedown: l
+    } = e(O, void 0), I = v(
+      i,
+      p
+    ), a = _(() => r.value === "menu" ? "menuitem" : r.value === "navigation" ? "link" : "button"), u = N((o) => {
+      const f = C(o);
+      if ([t.enter, t.numpadEnter, t.space].includes(
+        f
+      ))
+        return o.preventDefault(), o.stopImmediatePropagation(), m("clickimpl", o), !0;
+    }, d);
+    return {
+      ns: n,
+      itemRef: I,
+      dataset: {
+        [R]: ""
+      },
+      role: a,
+      tabIndex: s,
+      handleFocus: c,
+      handleKeydown: u,
+      handleMousedown: l
+    };
+  }
+});
+export {
+  $ as default
+};

package/dist/components/dropdown/src/dropdown-item.vue.d.ts

@@ -0,0 +1,169 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, {
+    handleClick: (event: PointerEvent) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerLeave: (event: PointerEvent) => void;
+    propsAndAttrs: import("vue").ComputedRef<{
+        class?: import("vue").ClassValue;
+        style?: import("vue").StyleValue;
+        disabled: boolean;
+        command: import("@element-plus/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        divided: boolean;
+        icon: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+        textValue: string | undefined;
+        onClick: ((...args: any[]) => any) | undefined;
+        onPointerleave: ((...args: any[]) => any) | undefined;
+        onPointermove: ((...args: any[]) => any) | undefined;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+    onPointerleave?: ((...args: any[]) => any) | undefined;
+    onPointermove?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+    readonly command: import("@element-plus/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly divided: boolean;
+}, {}, {
+    ElRovingFocusItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        focusable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        active: BooleanConstructor;
+    }>, {
+        id: import("vue").Ref<string, string>;
+        handleKeydown: (event: Event) => void;
+        handleFocus: (event: Event) => void;
+        handleMousedown: (event: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "keydown" | "mousedown")[], "focus" | "keydown" | "mousedown", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        focusable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        active: BooleanConstructor;
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onKeydown?: ((...args: any[]) => any) | undefined;
+        onMousedown?: ((...args: any[]) => any) | undefined;
+    }>, {
+        active: boolean;
+        focusable: boolean;
+    }, {}, {
+        ElRovingFocusCollectionItem: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            name: string;
+            setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+        };
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElDropdownItemImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+        dataset: {
+            "data-el-collection-item": string;
+        };
+        role: import("vue").ComputedRef<string>;
+        tabIndex: import("vue").Ref<number, number>;
+        handleFocus: (e: Event) => void;
+        handleKeydown: (event: KeyboardEvent) => void;
+        handleMousedown: (e: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly command: import("@element-plus/utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onPointerleave?: ((...args: any[]) => any) | undefined;
+        onPointermove?: ((...args: any[]) => any) | undefined;
+        onClickimpl?: ((...args: any[]) => any) | undefined;
+    }>, {
+        readonly disabled: boolean;
+        readonly command: import("@element-plus/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly divided: boolean;
+    }, {}, {
+        ElIcon: import("@element-plus/utils").SFCWithInstall<{
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../../icon/index.js").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../../icon/index.js").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../../icon/index.js").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        })>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/dropdown/src/dropdown-item.vue.js

@@ -0,0 +1,35 @@
+import l from "./dropdown-item2.vue.js";
+import { resolveComponent as n, openBlock as s, createBlock as p, withCtx as e, createVNode as m, mergeProps as a, createSlots as d, renderSlot as r } from "vue";
+import c from "../../../_virtual/_plugin-vue_export-helper.js";
+function f(o, _, u, v, P, $) {
+  const t = n("el-dropdown-item-impl"), i = n("el-roving-focus-item");
+  return s(), p(i, {
+    focusable: !o.disabled
+  }, {
+    default: e(() => [
+      m(t, a(o.propsAndAttrs, {
+        onPointerleave: o.handlePointerLeave,
+        onPointermove: o.handlePointerMove,
+        onClickimpl: o.handleClick
+      }), d({
+        default: e(() => [
+          r(o.$slots, "default")
+        ]),
+        _: 2
+      }, [
+        o.$slots.icon ? {
+          name: "icon",
+          fn: e(() => [
+            r(o.$slots, "icon")
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1040, ["onPointerleave", "onPointermove", "onClickimpl"])
+    ]),
+    _: 3
+  }, 8, ["focusable"]);
+}
+const w = /* @__PURE__ */ c(l, [["render", f]]);
+export {
+  w as default
+};

package/dist/components/dropdown/src/dropdown-item2.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent as E, getCurrentInstance as P, inject as h, computed as k } from "vue";
+import "../../roving-focus-group/src/roving-focus-group.vue.js";
+import C from "../../roving-focus-group/src/roving-focus-item.vue.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { composeEventHandlers as i, whenMouse as d } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import "../../roving-focus-group/src/roving-focus-group.js";
+import _ from "./dropdown-item-impl.vue.js";
+import { useDropdown as O } from "./useDropdown.js";
+import { dropdownItemProps as b } from "./dropdown.js";
+import { DROPDOWN_INJECTION_KEY as g } from "./tokens.js";
+const K = E({
+  name: "EpDropdownItem",
+  components: {
+    ElRovingFocusItem: C,
+    ElDropdownItemImpl: _
+  },
+  inheritAttrs: !1,
+  props: b,
+  emits: ["pointermove", "pointerleave", "click"],
+  setup(o, { emit: r, attrs: s }) {
+    const { elDropdown: t } = O(), l = P(), { onItemEnter: p, onItemLeave: m } = h(
+      g,
+      void 0
+    ), u = i(
+      (e) => (r("pointermove", e), e.defaultPrevented),
+      d((e) => {
+        if (o.disabled) {
+          m(e);
+          return;
+        }
+        const n = e.currentTarget;
+        n === document.activeElement || n.contains(document.activeElement) || (p(e), e.defaultPrevented || n == null || n.focus({
+          preventScroll: !0
+        }));
+      })
+    ), f = i((e) => (r("pointerleave", e), e.defaultPrevented), d(m)), v = i(
+      (e) => {
+        if (!o.disabled)
+          return r("click", e), e.type !== "keydown" && e.defaultPrevented;
+      },
+      (e) => {
+        var n, c, a;
+        if (o.disabled) {
+          e.stopImmediatePropagation();
+          return;
+        }
+        (n = t == null ? void 0 : t.hideOnClick) != null && n.value && ((c = t.handleClick) == null || c.call(t)), (a = t.commandHandler) == null || a.call(t, o.command, l, e);
+      }
+    ), I = k(() => ({ ...o, ...s }));
+    return {
+      handleClick: v,
+      handlePointerMove: u,
+      handlePointerLeave: f,
+      propsAndAttrs: I
+    };
+  }
+});
+export {
+  K as default
+};

package/dist/components/dropdown/src/dropdown-menu.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, {
+    size: import("vue").ComputedRef<string> | undefined;
+    rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+    dropdownKls: import("vue").ComputedRef<string[]>;
+    role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+    triggerId: import("vue").ComputedRef<string>;
+    dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    onBlur: (e: Event) => void;
+    handleFocus: (e: FocusEvent) => void;
+    onMousedown: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/dropdown/src/dropdown-menu.vue.js

@@ -0,0 +1,24 @@
+import l from "./dropdown-menu2.vue.js";
+import { openBlock as s, createElementBlock as d, withModifiers as r, normalizeStyle as i, normalizeClass as u, renderSlot as p } from "vue";
+import a from "../../../_virtual/_plugin-vue_export-helper.js";
+const t = ["role", "aria-labelledby"];
+function f(o, e, m, w, y, b) {
+  return s(), d("ul", {
+    ref: o.dropdownListWrapperRef,
+    class: u(o.dropdownKls),
+    style: i(o.rovingFocusGroupRootStyle),
+    tabindex: -1,
+    role: o.role,
+    "aria-labelledby": o.triggerId,
+    onFocusin: e[0] || (e[0] = (...n) => o.handleFocus && o.handleFocus(...n)),
+    onFocusout: e[1] || (e[1] = (...n) => o.onBlur && o.onBlur(...n)),
+    onKeydown: e[2] || (e[2] = r((...n) => o.handleKeydown && o.handleKeydown(...n), ["self"])),
+    onMousedown: e[3] || (e[3] = r((...n) => o.onMousedown && o.onMousedown(...n), ["self"]))
+  }, [
+    p(o.$slots, "default")
+  ], 46, t);
+}
+const B = /* @__PURE__ */ a(l, [["render", f]]);
+export {
+  B as default
+};

package/dist/components/dropdown/src/dropdown-menu2.vue.js

@@ -0,0 +1,75 @@
+import { defineComponent as K, inject as e, computed as T } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { composeEventHandlers as F, getEventCode as D } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { composeRefs as G } from "../../../utils/vue/refs.js";
+import { EVENT_CODE as y } from "../../../constants/aria.js";
+import "../../roving-focus-group/src/roving-focus-group.vue.js";
+import "../../roving-focus-group/src/roving-focus-item2.vue.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY as L } from "../../roving-focus-group/src/tokens.js";
+import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as b } from "../../roving-focus-group/src/roving-focus-group.js";
+import { useNamespace as J } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { DROPDOWN_INJECTION_KEY as S } from "./tokens.js";
+import { dropdownMenuProps as U } from "./dropdown.js";
+import { useDropdown as Y } from "./useDropdown.js";
+const io = K({
+  name: "EpDropdownMenu",
+  props: U,
+  setup(n) {
+    const m = J("dropdown"), { _elDropdownSize: i } = Y(), r = i.value, { contentRef: p, role: s, triggerId: c, isUsingKeyboard: d, handleClose: u } = e(S, void 0), {
+      rovingFocusGroupRef: f,
+      rovingFocusGroupRootStyle: a,
+      onBlur: l,
+      onFocus: E,
+      onKeydown: O,
+      onMousedown: _
+    } = e(L, void 0), { collectionRef: C } = e(
+      b,
+      void 0
+    ), N = T(() => [m.b("menu"), m.bm("menu", r == null ? void 0 : r.value)]), I = G(
+      p,
+      f,
+      C
+    ), v = F(
+      (o) => {
+        var t;
+        (t = n.onKeydown) == null || t.call(n, o);
+      },
+      (o) => {
+        const { currentTarget: t, target: R } = o, g = D(o);
+        if (t.contains(
+          R
+        ), y.tab === g)
+          return u();
+        O(o);
+      }
+    );
+    function w(o) {
+      d.value && E(o);
+    }
+    return {
+      size: r,
+      rovingFocusGroupRootStyle: a,
+      dropdownKls: N,
+      role: s,
+      triggerId: c,
+      dropdownListWrapperRef: I,
+      handleKeydown: v,
+      onBlur: l,
+      handleFocus: w,
+      onMousedown: _
+    };
+  }
+});
+export {
+  io as default
+};