ep-craft 0.1.19 → 0.1.21

package/dist/components/collapse-transition/src/collapse-transition.vue.js

@@ -0,0 +1,55 @@
+import { defineComponent as d, openBlock as s, createBlock as i, Transition as n, mergeProps as r, unref as p, toHandlers as l, withCtx as g, renderSlot as m } from "vue";
+import { useNamespace as f } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+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";
+const P = /* @__PURE__ */ d({
+  name: "ElCollapseTransition",
+  __name: "collapse-transition",
+  setup(y) {
+    const a = f("collapse-transition"), o = (t) => {
+      t.style.maxHeight = "", t.style.overflow = t.dataset.oldOverflow, t.style.paddingTop = t.dataset.oldPaddingTop, t.style.paddingBottom = t.dataset.oldPaddingBottom;
+    }, e = {
+      beforeEnter(t) {
+        t.dataset || (t.dataset = {}), t.dataset.oldPaddingTop = t.style.paddingTop, t.dataset.oldPaddingBottom = t.style.paddingBottom, t.style.height && (t.dataset.elExistsHeight = t.style.height), t.style.maxHeight = 0, t.style.paddingTop = 0, t.style.paddingBottom = 0;
+      },
+      enter(t) {
+        requestAnimationFrame(() => {
+          t.dataset.oldOverflow = t.style.overflow, t.dataset.elExistsHeight ? t.style.maxHeight = t.dataset.elExistsHeight : t.scrollHeight !== 0 ? t.style.maxHeight = `${t.scrollHeight}px` : t.style.maxHeight = 0, t.style.paddingTop = t.dataset.oldPaddingTop, t.style.paddingBottom = t.dataset.oldPaddingBottom, t.style.overflow = "hidden";
+        });
+      },
+      afterEnter(t) {
+        t.style.maxHeight = "", t.style.overflow = t.dataset.oldOverflow;
+      },
+      enterCancelled(t) {
+        o(t);
+      },
+      beforeLeave(t) {
+        t.dataset || (t.dataset = {}), t.dataset.oldPaddingTop = t.style.paddingTop, t.dataset.oldPaddingBottom = t.style.paddingBottom, t.dataset.oldOverflow = t.style.overflow, t.style.maxHeight = `${t.scrollHeight}px`, t.style.overflow = "hidden";
+      },
+      leave(t) {
+        t.scrollHeight !== 0 && (t.style.maxHeight = 0, t.style.paddingTop = 0, t.style.paddingBottom = 0);
+      },
+      afterLeave(t) {
+        o(t);
+      },
+      leaveCancelled(t) {
+        o(t);
+      }
+    };
+    return (t, h) => (s(), i(n, r({
+      name: p(a).b()
+    }, l(e)), {
+      default: g(() => [
+        m(t.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["name"]));
+  }
+});
+export {
+  P as default
+};

package/dist/components/collapse-transition/src/collapse-transition2.vue.js

@@ -0,0 +1,4 @@
+import f from "./collapse-transition.vue.js";
+export {
+  f as default
+};

package/dist/components/config-provider/src/constants.d.ts

@@ -0,0 +1,14 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { Language } from '@element-plus/locale';
+import type { ComponentSize } from '@element-plus/constants';
+import type { UseEmptyValuesProps } from '@element-plus/hooks';
+export type ConfigProviderContext = {
+    namespace?: string;
+    locale?: Language;
+    size?: ComponentSize;
+    zIndex?: number;
+    emptyValues?: UseEmptyValuesProps['emptyValues'];
+    valueOnClear?: UseEmptyValuesProps['valueOnClear'];
+    [key: string]: any;
+};
+export declare const configProviderContextKey: InjectionKey<Ref<ConfigProviderContext>>;

package/dist/components/config-provider/src/hooks/use-global-config.d.ts

@@ -0,0 +1,32 @@
+import type { App, MaybeRef, Ref } from 'vue';
+import type { ConfigProviderContext } from '../constants';
+export declare function useGlobalConfig<K extends keyof ConfigProviderContext, D extends ConfigProviderContext[K]>(key: K, defaultValue?: D): Ref<Exclude<ConfigProviderContext[K], undefined> | D>;
+export declare function useGlobalConfig(): Ref<ConfigProviderContext>;
+export declare function useGlobalComponentSettings(block: string, sizeFallback?: MaybeRef<ConfigProviderContext['size']>): {
+    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;
+    };
+    locale: import("@element-plus/hooks").LocaleContext;
+    zIndex: {
+        initialZIndex: import("vue").ComputedRef<number>;
+        currentZIndex: import("vue").ComputedRef<number>;
+        nextZIndex: () => number;
+    };
+    size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+};
+export declare const provideGlobalConfig: (config: MaybeRef<ConfigProviderContext>, app?: App, global?: boolean) => import("vue").ComputedRef<ConfigProviderContext> | undefined;

package/dist/components/focus-trap/index.d.ts

@@ -0,0 +1,81 @@
+import ElFocusTrap from './src/focus-trap.vue';
+export { ElFocusTrap };
+export declare const EpFocusTrap: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        loop: BooleanConstructor;
+        trapped: BooleanConstructor;
+        focusTrapEl: import("vue").PropType<HTMLElement>;
+        focusStartEl: {
+            type: import("vue").PropType<"container" | "first" | HTMLElement>;
+            default: string;
+        };
+    }>> & Readonly<{
+        onFocusin?: ((...args: any[]) => any) | undefined;
+        onFocusout?: ((...args: any[]) => any) | undefined;
+        onFocusAfterTrapped?: ((...args: any[]) => any) | undefined;
+        onFocusAfterReleased?: ((...args: any[]) => any) | undefined;
+        "onFocusout-prevented"?: ((...args: any[]) => any) | undefined;
+        "onRelease-requested"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        onKeydown: (e: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusin" | "focusout" | "focusAfterTrapped" | "focusAfterReleased" | "focusout-prevented" | "release-requested")[], import("vue").PublicProps, {
+        loop: boolean;
+        trapped: boolean;
+        focusStartEl: HTMLElement | "first" | "container";
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        loop: BooleanConstructor;
+        trapped: BooleanConstructor;
+        focusTrapEl: import("vue").PropType<HTMLElement>;
+        focusStartEl: {
+            type: import("vue").PropType<"container" | "first" | HTMLElement>;
+            default: string;
+        };
+    }>> & Readonly<{
+        onFocusin?: ((...args: any[]) => any) | undefined;
+        onFocusout?: ((...args: any[]) => any) | undefined;
+        onFocusAfterTrapped?: ((...args: any[]) => any) | undefined;
+        onFocusAfterReleased?: ((...args: any[]) => any) | undefined;
+        "onFocusout-prevented"?: ((...args: any[]) => any) | undefined;
+        "onRelease-requested"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        onKeydown: (e: KeyboardEvent) => void;
+    }, {}, {}, {}, {
+        loop: boolean;
+        trapped: boolean;
+        focusStartEl: HTMLElement | "first" | "container";
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    loop: BooleanConstructor;
+    trapped: BooleanConstructor;
+    focusTrapEl: import("vue").PropType<HTMLElement>;
+    focusStartEl: {
+        type: import("vue").PropType<"container" | "first" | HTMLElement>;
+        default: string;
+    };
+}>> & Readonly<{
+    onFocusin?: ((...args: any[]) => any) | undefined;
+    onFocusout?: ((...args: any[]) => any) | undefined;
+    onFocusAfterTrapped?: ((...args: any[]) => any) | undefined;
+    onFocusAfterReleased?: ((...args: any[]) => any) | undefined;
+    "onFocusout-prevented"?: ((...args: any[]) => any) | undefined;
+    "onRelease-requested"?: ((...args: any[]) => any) | undefined;
+}>, {
+    onKeydown: (e: KeyboardEvent) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusin" | "focusout" | "focusAfterTrapped" | "focusAfterReleased" | "focusout-prevented" | "release-requested")[], "focusin" | "focusout" | "focusAfterTrapped" | "focusAfterReleased" | "focusout-prevented" | "release-requested", {
+    loop: boolean;
+    trapped: boolean;
+    focusStartEl: HTMLElement | "first" | "container";
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+export default EpFocusTrap;
+export * from './src/tokens';
+export * from './src/utils';

package/dist/components/focus-trap/index.js

@@ -0,0 +1,19 @@
+import { withInstall as e } from "../../utils/with-install.js";
+import s from "./src/focus-trap.vue.js";
+import { createFocusOutPreventedEvent as u, focusFirstDescendant as n, focusableStack as l, getEdges as i, getVisibleElement as p, isFocusCausedByUserEvent as F, isHidden as d, obtainAllFocusableElements as f, tryFocus as m, useFocusReason as E } from "./src/utils.js";
+const r = e(s, "ep-focus-trap");
+export {
+  s as ElFocusTrap,
+  r as EpFocusTrap,
+  u as createFocusOutPreventedEvent,
+  r as default,
+  n as focusFirstDescendant,
+  l as focusableStack,
+  i as getEdges,
+  p as getVisibleElement,
+  F as isFocusCausedByUserEvent,
+  d as isHidden,
+  f as obtainAllFocusableElements,
+  m as tryFocus,
+  E as useFocusReason
+};

package/dist/components/focus-trap/src/focus-trap.vue.d.ts

@@ -0,0 +1,32 @@
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    loop: BooleanConstructor;
+    trapped: BooleanConstructor;
+    focusTrapEl: PropType<HTMLElement>;
+    focusStartEl: {
+        type: PropType<"container" | "first" | HTMLElement>;
+        default: string;
+    };
+}>, {
+    onKeydown: (e: KeyboardEvent) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusin" | "focusout" | "focusAfterTrapped" | "focusAfterReleased" | "focusout-prevented" | "release-requested")[], "focusin" | "focusout" | "focusAfterTrapped" | "focusAfterReleased" | "focusout-prevented" | "release-requested", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    loop: BooleanConstructor;
+    trapped: BooleanConstructor;
+    focusTrapEl: PropType<HTMLElement>;
+    focusStartEl: {
+        type: PropType<"container" | "first" | HTMLElement>;
+        default: string;
+    };
+}>> & Readonly<{
+    onFocusin?: ((...args: any[]) => any) | undefined;
+    onFocusout?: ((...args: any[]) => any) | undefined;
+    onFocusAfterTrapped?: ((...args: any[]) => any) | undefined;
+    onFocusAfterReleased?: ((...args: any[]) => any) | undefined;
+    "onFocusout-prevented"?: ((...args: any[]) => any) | undefined;
+    "onRelease-requested"?: ((...args: any[]) => any) | undefined;
+}>, {
+    loop: boolean;
+    trapped: boolean;
+    focusStartEl: HTMLElement | "first" | "container";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/focus-trap/src/focus-trap.vue.js

@@ -0,0 +1,10 @@
+import r from "./focus-trap2.vue.js";
+import { renderSlot as e } from "vue";
+import t from "../../../_virtual/_plugin-vue_export-helper.js";
+function n(o, s, p, a, d, f) {
+  return e(o.$slots, "default", { handleKeydown: o.onKeydown });
+}
+const l = /* @__PURE__ */ t(r, [["render", n]]);
+export {
+  l as default
+};

package/dist/components/focus-trap/src/focus-trap2.vue.js

@@ -0,0 +1,164 @@
+import { defineComponent as w, ref as V, provide as j, watch as g, unref as m, onMounted as q, onBeforeUnmount as x, nextTick as I } from "vue";
+import { EVENT_CODE as J } from "../../../constants/aria.js";
+import { isString as M } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { getEventCode as Y } from "../../../utils/dom/event.js";
+import "../../../hooks/use-size/index.js";
+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 { useEscapeKeydown as z } from "../../../hooks/use-escape-keydown/index.js";
+import { useFocusReason as G, tryFocus as f, createFocusOutPreventedEvent as T, getEdges as H, focusableStack as U, focusFirstDescendant as Q, obtainAllFocusableElements as W, isFocusCausedByUserEvent as X } from "./utils.js";
+import { ON_TRAP_FOCUS_EVT as K, ON_RELEASE_FOCUS_EVT as k, FOCUS_TRAP_INJECTION_KEY as Z, FOCUS_AFTER_TRAPPED as y, FOCUS_AFTER_TRAPPED_OPTS as N, FOCUS_AFTER_RELEASED as L } from "./tokens.js";
+import $ from "../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isNil.js";
+const me = w({
+  name: "ElFocusTrap",
+  inheritAttrs: !1,
+  props: {
+    loop: Boolean,
+    trapped: Boolean,
+    focusTrapEl: Object,
+    focusStartEl: {
+      type: [Object, String],
+      default: "first"
+    }
+  },
+  emits: [
+    K,
+    k,
+    "focusin",
+    "focusout",
+    "focusout-prevented",
+    "release-requested"
+  ],
+  setup(n, { emit: u }) {
+    const o = V();
+    let d, v;
+    const { focusReason: l } = G();
+    z((e) => {
+      n.trapped && !i.paused && u("release-requested", e);
+    });
+    const i = {
+      paused: !1,
+      pause() {
+        this.paused = !0;
+      },
+      resume() {
+        this.paused = !1;
+      }
+    }, p = (e) => {
+      if (!n.loop && !n.trapped || i.paused) return;
+      const { altKey: t, ctrlKey: s, metaKey: r, currentTarget: a, shiftKey: _ } = e, { loop: D } = n, B = Y(e) === J.tab && !t && !s && !r, E = document.activeElement;
+      if (B && E) {
+        const C = a, [O, b] = H(C);
+        if (O && b) {
+          if (!_ && E === b) {
+            const c = T({
+              focusReason: l.value
+            });
+            u("focusout-prevented", c), c.defaultPrevented || (e.preventDefault(), D && f(O, !0));
+          } else if (_ && [O, C].includes(E)) {
+            const c = T({
+              focusReason: l.value
+            });
+            u("focusout-prevented", c), c.defaultPrevented || (e.preventDefault(), D && f(b, !0));
+          }
+        } else if (E === C) {
+          const c = T({
+            focusReason: l.value
+          });
+          u("focusout-prevented", c), c.defaultPrevented || e.preventDefault();
+        }
+      }
+    };
+    j(Z, {
+      focusTrapRef: o,
+      onKeydown: p
+    }), g(
+      () => n.focusTrapEl,
+      (e) => {
+        e && (o.value = e);
+      },
+      { immediate: !0 }
+    ), g([o], ([e], [t]) => {
+      e && (e.addEventListener("keydown", p), e.addEventListener("focusin", F), e.addEventListener("focusout", P)), t && (t.removeEventListener("keydown", p), t.removeEventListener("focusin", F), t.removeEventListener("focusout", P));
+    });
+    const S = (e) => {
+      u(K, e);
+    }, A = (e) => u(k, e), F = (e) => {
+      const t = m(o);
+      if (!t) return;
+      const s = e.target, r = e.relatedTarget, a = s && t.contains(s);
+      n.trapped || r && t.contains(r) || (d = r), a && u("focusin", e), !i.paused && n.trapped && (a ? v = s : f(v, !0));
+    }, P = (e) => {
+      const t = m(o);
+      if (!(i.paused || !t))
+        if (n.trapped) {
+          const s = e.relatedTarget;
+          !$(s) && !t.contains(s) && setTimeout(() => {
+            if (!i.paused && n.trapped) {
+              const r = T({
+                focusReason: l.value
+              });
+              u("focusout-prevented", r), r.defaultPrevented || f(v, !0);
+            }
+          }, 0);
+        } else {
+          const s = e.target;
+          s && t.contains(s) || u("focusout", e);
+        }
+    };
+    async function R() {
+      await I();
+      const e = m(o);
+      if (e) {
+        U.push(i);
+        const t = e.contains(
+          document.activeElement
+        ) ? d : document.activeElement;
+        if (d = t, !e.contains(t)) {
+          const r = new Event(
+            y,
+            N
+          );
+          e.addEventListener(y, S), e.dispatchEvent(r), r.defaultPrevented || I(() => {
+            let a = n.focusStartEl;
+            M(a) || (f(a), document.activeElement !== a && (a = "first")), a === "first" && Q(
+              W(e),
+              !0
+            ), (document.activeElement === t || a === "container") && f(e);
+          });
+        }
+      }
+    }
+    function h() {
+      const e = m(o);
+      if (e) {
+        e.removeEventListener(y, S);
+        const t = new CustomEvent(L, {
+          ...N,
+          detail: {
+            focusReason: l.value
+          }
+        });
+        e.addEventListener(L, A), e.dispatchEvent(t), !t.defaultPrevented && (l.value == "keyboard" || !X() || e.contains(document.activeElement)) && f(d ?? document.body), e.removeEventListener(L, A), U.remove(i), d = null, v = null;
+      }
+    }
+    return q(() => {
+      n.trapped && R(), g(
+        () => n.trapped,
+        (e) => {
+          e ? R() : h();
+        }
+      );
+    }), x(() => {
+      n.trapped && h(), o.value && (o.value.removeEventListener("keydown", p), o.value.removeEventListener("focusin", F), o.value.removeEventListener("focusout", P), o.value = void 0), d = null, v = null;
+    }), {
+      onKeydown: p
+    };
+  }
+});
+export {
+  me as default
+};

package/dist/components/focus-trap/src/tokens.d.ts

@@ -0,0 +1,13 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
+export declare const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
+export declare const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
+export declare const FOCUS_AFTER_TRAPPED_OPTS: EventInit;
+export declare const FOCUSOUT_PREVENTED_OPTS: EventInit;
+export declare const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
+export declare const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
+export type FocusTrapInjectionContext = {
+    focusTrapRef: Ref<HTMLElement | undefined>;
+    onKeydown: (e: KeyboardEvent) => void;
+};
+export declare const FOCUS_TRAP_INJECTION_KEY: InjectionKey<FocusTrapInjectionContext>;

package/dist/components/focus-trap/src/tokens.js

@@ -0,0 +1,17 @@
+const e = "focus-trap.focus-after-trapped", s = "focus-trap.focus-after-released", c = "focus-trap.focusout-prevented", t = {
+  cancelable: !0,
+  bubbles: !1
+}, E = {
+  cancelable: !0,
+  bubbles: !1
+}, o = "focusAfterTrapped", _ = "focusAfterReleased", T = Symbol("elFocusTrap");
+export {
+  c as FOCUSOUT_PREVENTED,
+  E as FOCUSOUT_PREVENTED_OPTS,
+  s as FOCUS_AFTER_RELEASED,
+  e as FOCUS_AFTER_TRAPPED,
+  t as FOCUS_AFTER_TRAPPED_OPTS,
+  T as FOCUS_TRAP_INJECTION_KEY,
+  _ as ON_RELEASE_FOCUS_EVT,
+  o as ON_TRAP_FOCUS_EVT
+};

package/dist/components/focus-trap/src/utils.d.ts

@@ -0,0 +1,29 @@
+declare const focusReason: import("vue").Ref<"pointer" | "keyboard" | undefined, "pointer" | "keyboard" | undefined>;
+declare const lastUserFocusTimestamp: import("vue").Ref<number, number>;
+declare const lastAutomatedFocusTimestamp: import("vue").Ref<number, number>;
+export type FocusLayer = {
+    paused: boolean;
+    pause: () => void;
+    resume: () => void;
+};
+export type FocusStack = FocusLayer[];
+export declare const obtainAllFocusableElements: (element: HTMLElement) => HTMLElement[];
+export declare const getVisibleElement: (elements: HTMLElement[], container: HTMLElement) => HTMLElement | undefined;
+export declare const isHidden: (element: HTMLElement, container: HTMLElement) => boolean;
+export declare const getEdges: (container: HTMLElement) => (HTMLElement | undefined)[];
+export declare const tryFocus: (element?: HTMLElement | {
+    focus: () => void;
+} | null, shouldSelect?: boolean) => void;
+export declare const focusFirstDescendant: (elements: HTMLElement[], shouldSelect?: boolean) => void;
+export declare const focusableStack: {
+    push: (layer: FocusLayer) => void;
+    remove: (layer: FocusLayer) => void;
+};
+export declare const isFocusCausedByUserEvent: () => boolean;
+export declare const useFocusReason: () => {
+    focusReason: typeof focusReason;
+    lastUserFocusTimestamp: typeof lastUserFocusTimestamp;
+    lastAutomatedFocusTimestamp: typeof lastAutomatedFocusTimestamp;
+};
+export declare const createFocusOutPreventedEvent: (detail: CustomEventInit["detail"]) => CustomEvent<any>;
+export {};

package/dist/components/focus-trap/src/utils.js

@@ -0,0 +1,83 @@
+import { ref as i, onMounted as v, onBeforeUnmount as p } from "vue";
+import { focusElement as F } from "../../../utils/dom/aria.js";
+import { FOCUSOUT_PREVENTED as w, FOCUSOUT_PREVENTED_OPTS as T } from "./tokens.js";
+const a = i(), u = i(0), d = i(0);
+let r = 0;
+const N = (e) => {
+  const n = [], o = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (t) => {
+      const s = t.tagName === "INPUT" && t.type === "hidden";
+      return t.disabled || t.hidden || s ? NodeFilter.FILTER_SKIP : t.tabIndex >= 0 || t === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  for (; o.nextNode(); ) n.push(o.currentNode);
+  return n;
+}, m = (e, n) => {
+  for (const o of e)
+    if (!y(o, n)) return o;
+}, y = (e, n) => {
+  if (process.env.NODE_ENV === "test") return !1;
+  if (getComputedStyle(e).visibility === "hidden") return !0;
+  for (; e; ) {
+    if (n && e === n) return !1;
+    if (getComputedStyle(e).display === "none") return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}, C = (e) => {
+  const n = N(e), o = m(n, e), t = m(n.reverse(), e);
+  return [o, t];
+}, S = (e) => e instanceof HTMLInputElement && "select" in e, L = (e, n) => {
+  if (e) {
+    const o = document.activeElement;
+    F(e, { preventScroll: !0 }), d.value = window.performance.now(), e !== o && S(e) && n && e.select();
+  }
+};
+function f(e, n) {
+  const o = [...e], t = e.indexOf(n);
+  return t !== -1 && o.splice(t, 1), o;
+}
+const b = () => {
+  let e = [];
+  return {
+    push: (t) => {
+      const s = e[0];
+      s && t !== s && s.pause(), e = f(e, t), e.unshift(t);
+    },
+    remove: (t) => {
+      var s, l;
+      e = f(e, t), (l = (s = e[0]) == null ? void 0 : s.resume) == null || l.call(s);
+    }
+  };
+}, I = (e, n = !1) => {
+  const o = document.activeElement;
+  for (const t of e)
+    if (L(t, n), document.activeElement !== o) return;
+}, O = b(), P = () => u.value > d.value, c = () => {
+  a.value = "pointer", u.value = window.performance.now();
+}, E = () => {
+  a.value = "keyboard", u.value = window.performance.now();
+}, U = () => (v(() => {
+  r === 0 && (document.addEventListener("mousedown", c), document.addEventListener("touchstart", c), document.addEventListener("keydown", E)), r++;
+}), p(() => {
+  r--, r <= 0 && (document.removeEventListener("mousedown", c), document.removeEventListener("touchstart", c), document.removeEventListener("keydown", E));
+}), {
+  focusReason: a,
+  lastUserFocusTimestamp: u,
+  lastAutomatedFocusTimestamp: d
+}), _ = (e) => new CustomEvent(w, {
+  ...T,
+  detail: e
+});
+export {
+  _ as createFocusOutPreventedEvent,
+  I as focusFirstDescendant,
+  O as focusableStack,
+  C as getEdges,
+  m as getVisibleElement,
+  P as isFocusCausedByUserEvent,
+  y as isHidden,
+  N as obtainAllFocusableElements,
+  L as tryFocus,
+  U as useFocusReason
+};

package/dist/components/form/index.d.ts

@@ -2,3 +2,6 @@ import type { Plugin } from 'vue';
 import { ElForm } from 'element-plus';
 export declare const EpForm: typeof ElForm & Plugin;
 export default EpForm;
+export * from './src/constants';
+export * from './src/hooks/use-form-common-props';
+export * from './src/hooks/use-form-item';

package/dist/components/form/index.js

@@ -1,7 +1,9 @@
 import "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/index.js";
 import { withInstall as o } from "../../utils/with-install.js";
+import "vue";
+import "../../hooks/use-size/index.js";
 import { ElForm as m } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/form/index.js";
-const r = Object.assign({}, m, { name: "EpForm" }), n = o(r, "ep-form");
+const r = Object.assign({}, m, { name: "EpForm" }), e = o(r, "ep-form");
 export {
-  n as EpForm
+  e as EpForm
 };

package/dist/components/form/src/constants.d.ts

@@ -0,0 +1,4 @@
+import type { InjectionKey } from 'vue';
+import type { FormContext, FormItemContext } from './types';
+export declare const formContextKey: InjectionKey<FormContext>;
+export declare const formItemContextKey: InjectionKey<FormItemContext | undefined>;

package/dist/components/form/src/constants.js

@@ -0,0 +1,4 @@
+const t = Symbol("formItemContextKey");
+export {
+  t as formItemContextKey
+};

package/dist/components/form/src/hooks/use-form-common-props.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentSize } from '@element-plus/constants';
+import type { MaybeRef } from 'vue';
+export declare const useFormSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<"prop" | "form" | "formItem" | "global", boolean>>) => import("vue").ComputedRef<"" | "default" | "small" | "large">;
+export declare const useFormDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;
+export declare const useSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<"prop" | "form" | "formItem" | "global", boolean>>) => import("vue").ComputedRef<"" | "default" | "small" | "large">;
+export declare const useDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;

package/dist/components/form/src/hooks/use-form-item.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { FormItemContext } from '../types';
+export declare const useFormItem: () => {
+    form: import("../types").FormContext | undefined;
+    formItem: FormItemContext | undefined;
+};
+export type IUseFormItemInputCommonProps = {
+    id?: string;
+    label?: string | number | boolean | Record<string, any>;
+    ariaLabel?: string | number | boolean | Record<string, any>;
+};
+export declare const useFormItemInputId: (props: Partial<IUseFormItemInputCommonProps>, { formItemContext, disableIdGeneration, disableIdManagement, }: {
+    formItemContext?: FormItemContext;
+    disableIdGeneration?: ComputedRef<boolean> | Ref<boolean>;
+    disableIdManagement?: ComputedRef<boolean> | Ref<boolean>;
+}) => {
+    isLabeledByFormItem: ComputedRef<boolean>;
+    inputId: Ref<string | undefined, string | undefined>;
+};

package/dist/components/form/src/types.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentSize } from '@element-plus/constants';
+export interface FormContext {
+    size?: ComponentSize;
+    disabled?: boolean;
+    [key: string]: any;
+}
+export interface FormItemContext {
+    size?: ComponentSize;
+    $el?: HTMLDivElement | undefined;
+    validateMessage?: string;
+    validateState?: string;
+    isGroup?: boolean;
+    labelId?: string;
+    inputIds?: string[];
+    hasLabel?: boolean;
+    fieldValue?: any;
+    propString?: string;
+    addInputId: (id: string) => void;
+    removeInputId: (id: string) => void;
+    validate?: (...args: any[]) => any;
+    resetField?: () => void;
+    clearValidate?: () => void;
+    [key: string]: any;
+}