ep-craft 0.1.32 → 0.1.34

package/dist/components/roving-focus-group/index.js

@@ -0,0 +1,15 @@
+import r from "./src/roving-focus-group2.vue.js";
+import "./src/roving-focus-item2.vue.js";
+import "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as C, ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY as N } from "./src/roving-focus-group.js";
+export {
+  r as ElRovingFocusGroup,
+  r as EpRovingFocusGroup,
+  C as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
+  N as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
+  r as default
+};

package/dist/components/roving-focus-group/src/roving-focus-group-impl.vue.d.ts

@@ -0,0 +1,50 @@
+import type { StyleValue } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    currentTabId: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultCurrentTabId: StringConstructor;
+    loop: BooleanConstructor;
+    dir: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    orientation: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onBlur: FunctionConstructor;
+    onFocus: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("currentTabIdChange" | "entryFocus")[], "currentTabIdChange" | "entryFocus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    currentTabId: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultCurrentTabId: StringConstructor;
+    loop: BooleanConstructor;
+    dir: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    orientation: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onBlur: FunctionConstructor;
+    onFocus: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+}>> & Readonly<{
+    onCurrentTabIdChange?: ((...args: any[]) => any) | undefined;
+    onEntryFocus?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: StyleValue;
+    dir: string;
+    loop: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/roving-focus-group/src/roving-focus-group-impl.vue.js

@@ -0,0 +1,10 @@
+import r from "./roving-focus-group-impl2.vue.js";
+import { renderSlot as t } from "vue";
+import e from "../../../_virtual/_plugin-vue_export-helper.js";
+function p(o, s, n, f, c, m) {
+  return t(o.$slots, "default");
+}
+const _ = /* @__PURE__ */ e(r, [["render", p]]);
+export {
+  _ as default
+};

package/dist/components/roving-focus-group/src/roving-focus-group-impl2.vue.js

@@ -0,0 +1,115 @@
+import { defineComponent as B, ref as a, inject as K, computed as T, unref as u, provide as L, toRef as f, readonly as U, watch as V, nextTick as A } from "vue";
+import { useEventListener as P } from "@vueuse/core";
+import "@vue/shared";
+import "lodash-unified";
+import { composeEventHandlers as m } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { rovingFocusGroupProps as Y, ROVING_FOCUS_COLLECTION_INJECTION_KEY as J } from "./roving-focus-group.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY as D } from "./tokens.js";
+import { focusFirst as b, getFocusIntent as H, reorderArray as M } from "./utils.js";
+const _ = "currentTabIdChange", C = "rovingFocusGroup.entryFocus", j = { bubbles: !1, cancelable: !0 }, ne = B({
+  name: "EpRovingFocusGroupImpl",
+  inheritAttrs: !1,
+  props: Y,
+  emits: [_, "entryFocus"],
+  setup(e, { emit: I }) {
+    const i = a(
+      (e.currentTabId || e.defaultCurrentTabId) ?? null
+    ), s = a(!1), l = a(!1), v = a(), { getItems: E } = K(
+      J,
+      void 0
+    ), O = T(() => [
+      {
+        outline: "none"
+      },
+      e.style
+    ]), N = (t) => {
+      I(_, t);
+    }, y = () => {
+      s.value = !0;
+    }, g = m(
+      (t) => {
+        var n;
+        (n = e.onMousedown) == null || n.call(e, t);
+      },
+      () => {
+        l.value = !0;
+      }
+    ), R = m(
+      (t) => {
+        var n;
+        (n = e.onFocus) == null || n.call(e, t);
+      },
+      (t) => {
+        const n = !u(l), { target: F, currentTarget: o } = t;
+        if (F === o && n && !u(s)) {
+          const c = new Event(C, j);
+          if (o == null || o.dispatchEvent(c), !c.defaultPrevented) {
+            const d = E().filter((r) => r.focusable), x = d.find((r) => r.active), S = d.find(
+              (r) => r.id === u(i)
+            ), k = [x, S, ...d].filter(
+              Boolean
+            ).map((r) => r.ref);
+            b(k);
+          }
+        }
+        l.value = !1;
+      }
+    ), G = m(
+      (t) => {
+        var n;
+        (n = e.onBlur) == null || n.call(e, t);
+      },
+      () => {
+        s.value = !1;
+      }
+    ), h = (...t) => {
+      I("entryFocus", ...t);
+    }, w = (t) => {
+      const n = H(t);
+      if (n) {
+        t.preventDefault();
+        let o = E().filter((c) => c.focusable).map((c) => c.ref);
+        switch (n) {
+          case "last": {
+            o.reverse();
+            break;
+          }
+          case "prev":
+          case "next": {
+            n === "prev" && o.reverse();
+            const c = o.indexOf(t.currentTarget);
+            o = e.loop ? M(o, c + 1) : o.slice(c + 1);
+            break;
+          }
+        }
+        A(() => {
+          b(o);
+        });
+      }
+    };
+    L(D, {
+      currentTabbedId: U(i),
+      loop: f(e, "loop"),
+      tabIndex: T(() => u(s) ? -1 : 0),
+      rovingFocusGroupRef: v,
+      rovingFocusGroupRootStyle: O,
+      orientation: f(e, "orientation"),
+      dir: f(e, "dir"),
+      onItemFocus: N,
+      onItemShiftTab: y,
+      onBlur: G,
+      onFocus: R,
+      onMousedown: g,
+      onKeydown: w
+    }), V(
+      () => e.currentTabId,
+      (t) => {
+        i.value = t ?? null;
+      }
+    ), P(v, C, h);
+  }
+});
+export {
+  ne as default
+};

package/dist/components/roving-focus-group/src/roving-focus-group.d.ts

@@ -0,0 +1,56 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes, StyleValue } from 'vue';
+export declare const rovingFocusGroupProps: {
+    style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    currentTabId: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultCurrentTabId: StringConstructor;
+    loop: BooleanConstructor;
+    dir: import("@element-plus/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    orientation: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    onBlur: FunctionConstructor;
+    onFocus: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+};
+export type ElRovingFocusGroupProps = ExtractPropTypes<typeof rovingFocusGroupProps>;
+export type ElRovingFocusGroupPropsPublic = ExtractPublicPropTypes<typeof rovingFocusGroupProps>;
+declare const ElCollection: {
+    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(): void;
+}, ElCollectionItem: {
+    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;
+}, COLLECTION_INJECTION_KEY: import("vue").InjectionKey<import("@element-plus/components/collection").ElCollectionInjectionContext>, COLLECTION_ITEM_INJECTION_KEY: import("vue").InjectionKey<import("@element-plus/components/collection").ElCollectionItemInjectionContext>;
+export { ElCollection, ElCollectionItem, COLLECTION_INJECTION_KEY as ROVING_FOCUS_COLLECTION_INJECTION_KEY, COLLECTION_ITEM_INJECTION_KEY as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY, };

package/dist/components/roving-focus-group/src/roving-focus-group.js

@@ -0,0 +1,43 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t, definePropType as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { createCollectionWithScope as r } from "../../collection/src/collection.js";
+const u = t({
+  style: {
+    type: o([String, Array, Object, Boolean]),
+    default: void 0
+  },
+  currentTabId: {
+    type: o(String)
+  },
+  defaultCurrentTabId: String,
+  loop: Boolean,
+  dir: {
+    type: String,
+    // left for direction support
+    values: ["ltr", "rtl"],
+    default: "ltr"
+  },
+  orientation: {
+    // left for orientation support
+    type: o(String)
+  },
+  onBlur: Function,
+  onFocus: Function,
+  onMousedown: Function
+}), {
+  ElCollection: O,
+  ElCollectionItem: E,
+  COLLECTION_INJECTION_KEY: c,
+  COLLECTION_ITEM_INJECTION_KEY: N
+} = r("RovingFocusGroup");
+export {
+  O as ElCollection,
+  E as ElCollectionItem,
+  c as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
+  N as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
+  u as rovingFocusGroupProps
+};

package/dist/components/roving-focus-group/src/roving-focus-group.vue.d.ts

@@ -0,0 +1,67 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    ElFocusGroupCollection: {
+        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(): void;
+    };
+    ElRovingFocusGroupImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        style: import("../../../utils/index.js").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        currentTabId: {
+            readonly type: import("vue").PropType<import("../../../utils/index.js").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        defaultCurrentTabId: StringConstructor;
+        loop: BooleanConstructor;
+        dir: import("../../../utils/index.js").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+        orientation: {
+            readonly type: import("vue").PropType<import("../../../utils/index.js").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onBlur: FunctionConstructor;
+        onFocus: FunctionConstructor;
+        onMousedown: FunctionConstructor;
+    }>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("currentTabIdChange" | "entryFocus")[], "currentTabIdChange" | "entryFocus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        style: import("../../../utils/index.js").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        currentTabId: {
+            readonly type: import("vue").PropType<import("../../../utils/index.js").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        defaultCurrentTabId: StringConstructor;
+        loop: BooleanConstructor;
+        dir: import("../../../utils/index.js").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+        orientation: {
+            readonly type: import("vue").PropType<import("../../../utils/index.js").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        onBlur: FunctionConstructor;
+        onFocus: FunctionConstructor;
+        onMousedown: FunctionConstructor;
+    }>> & Readonly<{
+        onCurrentTabIdChange?: ((...args: any[]) => any) | undefined;
+        onEntryFocus?: ((...args: any[]) => any) | undefined;
+    }>, {
+        style: import("vue").StyleValue;
+        dir: string;
+        loop: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/roving-focus-group/src/roving-focus-group.vue.js

@@ -0,0 +1,13 @@
+import { defineComponent as o } from "vue";
+import n from "./roving-focus-group-impl.vue.js";
+import { ElCollection as m } from "./roving-focus-group.js";
+const e = o({
+  name: "EpRovingFocusGroup",
+  components: {
+    ElFocusGroupCollection: m,
+    ElRovingFocusGroupImpl: n
+  }
+});
+export {
+  e as default
+};

package/dist/components/roving-focus-group/src/roving-focus-group2.vue.js

@@ -0,0 +1,21 @@
+import c from "./roving-focus-group.vue.js";
+import { resolveComponent as e, openBlock as p, createBlock as l, withCtx as r, createVNode as s, normalizeProps as u, guardReactiveProps as _, renderSlot as i } from "vue";
+import a from "../../../_virtual/_plugin-vue_export-helper.js";
+function f(o, m, d, g, $, v) {
+  const t = e("el-roving-focus-group-impl"), n = e("el-focus-group-collection");
+  return p(), l(n, null, {
+    default: r(() => [
+      s(t, u(_(o.$attrs)), {
+        default: r(() => [
+          i(o.$slots, "default")
+        ]),
+        _: 3
+      }, 16)
+    ]),
+    _: 3
+  });
+}
+const B = /* @__PURE__ */ a(c, [["render", f]]);
+export {
+  B as default
+};

package/dist/components/roving-focus-group/src/roving-focus-item.vue.d.ts

@@ -0,0 +1,43 @@
+declare const _default: 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>;
+export default _default;

package/dist/components/roving-focus-group/src/roving-focus-item.vue.js

@@ -0,0 +1,20 @@
+import t from "./roving-focus-item2.vue.js";
+import { resolveComponent as c, openBlock as r, createBlock as i, withCtx as n, renderSlot as l } from "vue";
+import s from "../../../_virtual/_plugin-vue_export-helper.js";
+function a(o, f, m, p, u, _) {
+  const e = c("el-roving-focus-collection-item");
+  return r(), i(e, {
+    id: o.id,
+    focusable: o.focusable,
+    active: o.active
+  }, {
+    default: n(() => [
+      l(o.$slots, "default")
+    ]),
+    _: 3
+  }, 8, ["id", "focusable", "active"]);
+}
+const b = /* @__PURE__ */ s(t, [["render", a]]);
+export {
+  b as default
+};

package/dist/components/roving-focus-group/src/roving-focus-item2.vue.js

@@ -0,0 +1,78 @@
+import { defineComponent as C, inject as O, ref as b, unref as t, computed as p, provide as T } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { composeEventHandlers as r, getEventCode as w } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { EVENT_CODE as F } from "../../../constants/aria.js";
+import { useId as N } from "../../../hooks/use-id/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 { ElCollectionItem as R } from "./roving-focus-group.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY as g, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as y } from "./tokens.js";
+const A = C({
+  name: "EpRovingFocusItem",
+  components: {
+    ElRovingFocusCollectionItem: R
+  },
+  props: {
+    focusable: {
+      type: Boolean,
+      default: !0
+    },
+    active: Boolean
+  },
+  emits: ["mousedown", "focus", "keydown"],
+  setup(u, { emit: n }) {
+    const { currentTabbedId: d, onItemFocus: m, onItemShiftTab: a, onKeydown: f } = O(
+      g,
+      void 0
+    ), e = N(), l = b(), i = r(
+      (o) => {
+        n("mousedown", o);
+      },
+      (o) => {
+        u.focusable ? m(t(e)) : o.preventDefault();
+      }
+    ), s = r(
+      (o) => {
+        n("focus", o);
+      },
+      () => {
+        m(t(e));
+      }
+    ), c = r(
+      (o) => {
+        n("keydown", o);
+      },
+      (o) => {
+        const { shiftKey: E, target: _, currentTarget: v } = o;
+        if (w(o) === F.tab && E) {
+          a();
+          return;
+        }
+        _ === v && f(o);
+      }
+    ), I = p(() => d.value === t(e));
+    return T(y, {
+      rovingFocusGroupItemRef: l,
+      tabIndex: p(() => t(I) ? 0 : -1),
+      handleMousedown: i,
+      handleFocus: s,
+      handleKeydown: c
+    }), {
+      id: e,
+      handleKeydown: c,
+      handleFocus: s,
+      handleMousedown: i
+    };
+  }
+});
+export {
+  A as default
+};

package/dist/components/roving-focus-group/src/tokens.d.ts

@@ -0,0 +1,28 @@
+import type { InjectionKey, Ref, StyleValue } from 'vue';
+import type { ElRovingFocusGroupProps } from './roving-focus-group';
+type EventHandler<T = Event> = (e: T) => void;
+export type RovingGroupInjectionContext = {
+    currentTabbedId: Ref<string | null>;
+    dir: Ref<ElRovingFocusGroupProps['dir']>;
+    loop: Ref<ElRovingFocusGroupProps['loop']>;
+    orientation: Ref<ElRovingFocusGroupProps['orientation']>;
+    tabIndex: Ref<number>;
+    rovingFocusGroupRef: Ref<HTMLElement | undefined>;
+    rovingFocusGroupRootStyle: Ref<StyleValue>;
+    onBlur: EventHandler;
+    onFocus: EventHandler<FocusEvent>;
+    onMousedown: EventHandler;
+    onItemFocus: (id: string) => void;
+    onItemShiftTab: () => void;
+    onKeydown: EventHandler<KeyboardEvent>;
+};
+export type RovingFocusGroupItemInjectionContext = {
+    rovingFocusGroupItemRef: Ref<HTMLElement | undefined>;
+    tabIndex: Ref<number>;
+    handleMousedown: EventHandler;
+    handleFocus: EventHandler;
+    handleKeydown: EventHandler;
+};
+export declare const ROVING_FOCUS_GROUP_INJECTION_KEY: InjectionKey<RovingGroupInjectionContext>;
+export declare const ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY: InjectionKey<RovingFocusGroupItemInjectionContext>;
+export {};

package/dist/components/roving-focus-group/src/tokens.js

@@ -0,0 +1,5 @@
+const o = Symbol("elRovingFocusGroup"), _ = Symbol("elRovingFocusGroupItem");
+export {
+  o as ROVING_FOCUS_GROUP_INJECTION_KEY,
+  _ as ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY
+};

package/dist/components/roving-focus-group/src/utils.d.ts

@@ -0,0 +1,8 @@
+import type { HTMLAttributes } from 'vue';
+type Orientation = HTMLAttributes['aria-orientation'];
+type Direction = 'ltr' | 'rtl';
+type FocusIntent = 'first' | 'last' | 'prev' | 'next';
+export declare const getFocusIntent: (event: KeyboardEvent, orientation?: Orientation, dir?: Direction) => FocusIntent | undefined;
+export declare const reorderArray: <T>(array: T[], atIdx: number) => T[];
+export declare const focusFirst: (elements: HTMLElement[]) => void;
+export {};

package/dist/components/roving-focus-group/src/utils.js

@@ -0,0 +1,28 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { getEventCode as i } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import "vue";
+const c = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+}, s = (t, e) => t, g = (t, e, r) => {
+  const o = i(t), n = s(o);
+  return c[n];
+}, v = (t, e) => t.map((r, o) => t[(o + e) % t.length]), w = (t) => {
+  const { activeElement: e } = document;
+  for (const r of t)
+    if (r === e || (r.focus(), e !== document.activeElement)) return;
+};
+export {
+  w as focusFirst,
+  g as getFocusIntent,
+  v as reorderArray
+};