ep-craft 0.1.20 → 0.1.21

package/dist/components/popper/src/content.d.ts

@@ -0,0 +1,234 @@
+import type { PopperEffect } from './popper';
+import type { ExtractPublicPropTypes, StyleValue } from 'vue';
+import type { Options, Placement } from '@popperjs/core';
+import type { Measurable } from './constants';
+import type Content from './content.vue';
+import type { PopperArrowProps } from './arrow';
+type ClassObjectType = Record<string, boolean>;
+type ClassType = string | ClassObjectType | ClassType[];
+declare const POSITIONING_STRATEGIES: readonly ["fixed", "absolute"];
+export interface CreatePopperInstanceParams {
+    referenceEl: Measurable;
+    popperContentEl: HTMLElement;
+    arrowEl: HTMLElement | undefined;
+}
+export interface PopperCoreConfigProps {
+    boundariesPadding?: number;
+    fallbackPlacements?: Placement[];
+    gpuAcceleration?: boolean;
+    /**
+     * @description offset of the Tooltip
+     */
+    offset?: number;
+    /**
+     * @description position of Tooltip
+     */
+    placement?: Placement;
+    /**
+     * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+     */
+    popperOptions?: Partial<Options>;
+    strategy?: (typeof POSITIONING_STRATEGIES)[number];
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperCoreConfigProps` instead.
+ */
+export declare const popperCoreConfigProps: {
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, Placement, unknown, "bottom", boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperCoreConfigProps` instead.
+ */
+export type PopperCoreConfigPropsPublic = ExtractPublicPropTypes<typeof popperCoreConfigProps>;
+export interface PopperContentProps extends PopperCoreConfigProps, PopperArrowProps {
+    id?: string;
+    style?: StyleValue;
+    className?: ClassType;
+    effect?: PopperEffect;
+    visible?: boolean;
+    enterable?: boolean;
+    pure?: boolean;
+    focusOnShow?: boolean;
+    trapping?: boolean;
+    popperClass?: ClassType;
+    popperStyle?: StyleValue;
+    referenceEl?: HTMLElement;
+    triggerTargetEl?: HTMLElement;
+    stopPopperMouseEvent?: boolean;
+    virtualTriggering?: boolean;
+    zIndex?: number;
+    ariaLabel?: string;
+    loop?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperContentProps` instead.
+ */
+export declare const popperContentProps: {
+    readonly loop: BooleanConstructor;
+    readonly ariaLabel: StringConstructor;
+    readonly id: StringConstructor;
+    readonly 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>;
+    readonly className: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType) | (((new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => PopperEffect) | (((new (...args: any[]) => string) | (() => PopperEffect)) | null)[], unknown, unknown, "dark", boolean>;
+    readonly visible: BooleanConstructor;
+    readonly enterable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly pure: BooleanConstructor;
+    readonly focusOnShow: BooleanConstructor;
+    readonly trapping: BooleanConstructor;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType) | (((new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: 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>;
+    readonly referenceEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly triggerTargetEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly stopPopperMouseEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly zIndex: NumberConstructor;
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, Placement, unknown, "bottom", boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperContentProps` instead.
+ */
+export type PopperContentPropsPublic = ExtractPublicPropTypes<typeof popperContentProps>;
+export declare const popperCoreConfigPropsDefaults: {
+    readonly boundariesPadding: 0;
+    readonly gpuAcceleration: true;
+    readonly offset: 12;
+    readonly placement: "bottom";
+    readonly popperOptions: () => {};
+    readonly strategy: "absolute";
+};
+export declare const popperContentPropsDefaults: {
+    readonly effect: "dark";
+    readonly enterable: true;
+    readonly stopPopperMouseEvent: true;
+    readonly visible: false;
+    readonly pure: false;
+    readonly focusOnShow: false;
+    readonly trapping: false;
+    readonly virtualTriggering: false;
+    readonly loop: false;
+    readonly style: undefined;
+    readonly popperStyle: undefined;
+    readonly arrowOffset: 5;
+    readonly boundariesPadding: 0;
+    readonly gpuAcceleration: true;
+    readonly offset: 12;
+    readonly placement: "bottom";
+    readonly popperOptions: () => {};
+    readonly strategy: "absolute";
+};
+export declare const popperContentEmits: {
+    mouseenter: (evt: MouseEvent) => boolean;
+    mouseleave: (evt: MouseEvent) => boolean;
+    focus: () => boolean;
+    blur: () => boolean;
+    close: () => boolean;
+};
+export type PopperContentEmits = typeof popperContentEmits;
+export type PopperContentInstance = InstanceType<typeof Content> & unknown;
+/** @deprecated use `popperCoreConfigProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperCoreConfigProps: {
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, Placement, unknown, "bottom", boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+};
+/** @deprecated use `popperContentProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperContentProps: {
+    readonly loop: BooleanConstructor;
+    readonly ariaLabel: StringConstructor;
+    readonly id: StringConstructor;
+    readonly 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>;
+    readonly className: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType) | (((new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => PopperEffect) | (((new (...args: any[]) => string) | (() => PopperEffect)) | null)[], unknown, unknown, "dark", boolean>;
+    readonly visible: BooleanConstructor;
+    readonly enterable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly pure: BooleanConstructor;
+    readonly focusOnShow: BooleanConstructor;
+    readonly trapping: BooleanConstructor;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType) | (((new (...args: any[]) => string | ClassObjectType | ClassType[]) | (() => ClassType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: 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>;
+    readonly referenceEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly triggerTargetEl: {
+        readonly type: import("vue").PropType<HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly stopPopperMouseEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly zIndex: NumberConstructor;
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+    readonly boundariesPadding: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, undefined, boolean>;
+    readonly gpuAcceleration: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, Placement, unknown, "bottom", boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly strategy: import("@element-plus/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
+};
+/** @deprecated use `popperContentEmits` instead, and it will be deprecated in the next major version */
+export declare const usePopperContentEmits: {
+    mouseenter: (evt: MouseEvent) => boolean;
+    mouseleave: (evt: MouseEvent) => boolean;
+    focus: () => boolean;
+    blur: () => boolean;
+    close: () => boolean;
+};
+/** @deprecated use `PopperCoreConfigProps` instead, and it will be deprecated in the next major version */
+export type UsePopperCoreConfigProps = PopperCoreConfigProps;
+/** @deprecated use `PopperContentProps` instead, and it will be deprecated in the next major version */
+export type UsePopperContentProps = PopperContentProps;
+/** @deprecated use `PopperContentInstance` instead, and it will be deprecated in the next major version */
+export type ElPopperArrowContent = PopperContentInstance;
+export {};

package/dist/components/popper/src/content.js

@@ -0,0 +1,129 @@
+import { placements as r } from "../../../node_modules/.pnpm/@sxzz_popperjs-es@2.11.8/node_modules/@sxzz/popperjs-es/dist/index.js";
+import { buildProps as o, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as p } from "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { popperArrowProps as a, popperArrowPropsDefaults as l } from "./arrow.js";
+const n = ["fixed", "absolute"], s = o({
+  boundariesPadding: {
+    type: Number,
+    default: 0
+  },
+  fallbackPlacements: {
+    type: e(Array),
+    default: void 0
+  },
+  gpuAcceleration: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description offset of the Tooltip
+   */
+  offset: {
+    type: Number,
+    default: 12
+  },
+  /**
+   * @description position of Tooltip
+   */
+  placement: {
+    type: String,
+    values: r,
+    default: "bottom"
+  },
+  /**
+   * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+   */
+  popperOptions: {
+    type: e(Object),
+    default: () => ({})
+  },
+  strategy: {
+    type: String,
+    values: n,
+    default: "absolute"
+  }
+}), S = o({
+  ...s,
+  ...a,
+  id: String,
+  style: {
+    type: e([String, Array, Object, Boolean]),
+    default: void 0
+  },
+  className: {
+    type: e([String, Array, Object])
+  },
+  effect: {
+    type: e(String),
+    default: "dark"
+  },
+  visible: Boolean,
+  enterable: {
+    type: Boolean,
+    default: !0
+  },
+  pure: Boolean,
+  focusOnShow: Boolean,
+  trapping: Boolean,
+  popperClass: {
+    type: e([String, Array, Object])
+  },
+  popperStyle: {
+    type: e([String, Array, Object, Boolean]),
+    default: void 0
+  },
+  referenceEl: {
+    type: e(Object)
+  },
+  triggerTargetEl: {
+    type: e(Object)
+  },
+  stopPopperMouseEvent: {
+    type: Boolean,
+    default: !0
+  },
+  virtualTriggering: Boolean,
+  zIndex: Number,
+  ...p(["ariaLabel"]),
+  loop: Boolean
+}), i = {
+  boundariesPadding: 0,
+  gpuAcceleration: !0,
+  offset: 12,
+  placement: "bottom",
+  popperOptions: () => ({}),
+  strategy: "absolute"
+}, O = {
+  ...i,
+  ...l,
+  effect: "dark",
+  enterable: !0,
+  stopPopperMouseEvent: !0,
+  visible: !1,
+  pure: !1,
+  focusOnShow: !1,
+  trapping: !1,
+  virtualTriggering: !1,
+  loop: !1,
+  style: void 0,
+  popperStyle: void 0
+}, A = {
+  mouseenter: (t) => t instanceof MouseEvent,
+  mouseleave: (t) => t instanceof MouseEvent,
+  focus: () => !0,
+  blur: () => !0,
+  close: () => !0
+};
+export {
+  A as popperContentEmits,
+  S as popperContentProps,
+  O as popperContentPropsDefaults,
+  s as popperCoreConfigProps,
+  i as popperCoreConfigPropsDefaults
+};

package/dist/components/popper/src/content.vue.d.ts

@@ -0,0 +1,61 @@
+import type { PopperContentProps } from './content';
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<PopperContentProps, {
+    /**
+     * @description popper content element
+     */
+    popperContentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    /**
+     * @description popperjs instance
+     */
+    popperInstanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance | undefined>;
+    /**
+     * @description method for updating popper
+     */
+    updatePopper: (shouldUpdateZIndex?: boolean) => void;
+    /**
+     * @description content style
+     */
+    contentStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: () => void;
+    close: () => void;
+    focus: () => void;
+    mouseenter: (evt: MouseEvent) => void;
+    mouseleave: (evt: MouseEvent) => void;
+}, string, import("vue").PublicProps, Readonly<PopperContentProps> & Readonly<{
+    onBlur?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onFocus?: (() => any) | undefined;
+    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+}>, {
+    offset: number;
+    style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    effect: import("./popper").PopperEffect;
+    visible: boolean;
+    enterable: boolean;
+    pure: boolean;
+    focusOnShow: boolean;
+    trapping: boolean;
+    popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    stopPopperMouseEvent: boolean;
+    virtualTriggering: boolean;
+    loop: boolean;
+    boundariesPadding: number;
+    gpuAcceleration: boolean;
+    placement: import("element-plus").Placement;
+    popperOptions: Partial<import("element-plus").Options>;
+    strategy: "fixed" | "absolute";
+    arrowOffset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/popper/src/content.vue.js

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

package/dist/components/popper/src/content2.vue.js

@@ -0,0 +1,151 @@
+import { defineComponent as z, inject as J, provide as P, onMounted as U, watch as u, unref as e, onBeforeUnmount as V, openBlock as Y, createElementBlock as Z, mergeProps as G, createVNode as H, withCtx as Q, renderSlot as X, mergeDefaults as h } from "vue";
+import { isElement as R } from "../../../utils/types.js";
+import { NOOP as E } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { EpFocusTrap as W } from "../../focus-trap/index.js";
+import "../../form/index.js";
+import { POPPER_CONTENT_INJECTION_KEY as ee } from "./constants.js";
+import { popperContentEmits as oe, popperContentPropsDefaults as te } from "./content.js";
+import { usePopperContent as re } from "./composables/use-content.js";
+import { usePopperContentDOM as ne } from "./composables/use-content-dom.js";
+import { usePopperContentFocusTrap as pe } from "./composables/use-focus-trap.js";
+import { formItemContextKey as C } from "../../form/src/constants.js";
+import ae from "../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isNil.js";
+const Re = /* @__PURE__ */ z({
+  name: "ElPopperContent",
+  __name: "content",
+  props: /* @__PURE__ */ h({
+    id: {},
+    style: { type: [Boolean, null, String, Object, Array] },
+    className: {},
+    effect: {},
+    visible: { type: Boolean },
+    enterable: { type: Boolean },
+    pure: { type: Boolean },
+    focusOnShow: { type: Boolean },
+    trapping: { type: Boolean },
+    popperClass: {},
+    popperStyle: { type: [Boolean, null, String, Object, Array] },
+    referenceEl: {},
+    triggerTargetEl: {},
+    stopPopperMouseEvent: { type: Boolean },
+    virtualTriggering: { type: Boolean },
+    zIndex: {},
+    ariaLabel: {},
+    loop: { type: Boolean },
+    boundariesPadding: {},
+    fallbackPlacements: {},
+    gpuAcceleration: { type: Boolean },
+    offset: {},
+    placement: {},
+    popperOptions: {},
+    strategy: {},
+    arrowOffset: {}
+  }, te),
+  emits: oe,
+  setup(f, { expose: B, emit: F }) {
+    const I = F, o = f, {
+      focusStartRef: O,
+      trapped: l,
+      onFocusAfterReleased: A,
+      onFocusAfterTrapped: g,
+      onFocusInTrap: T,
+      onFocusoutPrevented: N,
+      onReleaseRequested: w
+    } = pe(o, I), { attributes: M, arrowRef: S, contentRef: p, styles: x, instanceRef: j, role: m, update: k } = re(o), {
+      ariaModal: q,
+      arrowStyle: D,
+      contentAttrs: $,
+      contentClass: K,
+      contentStyle: d,
+      updateZIndex: L
+    } = ne(o, {
+      styles: x,
+      attributes: M,
+      role: m
+    }), c = J(C, void 0);
+    P(ee, {
+      arrowStyle: D,
+      arrowRef: S
+    }), c && P(C, {
+      ...c,
+      addInputId: E,
+      removeInputId: E
+    });
+    let t;
+    const v = (n = !0) => {
+      k(), n && L();
+    }, _ = () => {
+      v(!1), o.visible && o.focusOnShow ? l.value = !0 : o.visible === !1 && (l.value = !1);
+    };
+    return U(() => {
+      u(
+        () => o.triggerTargetEl,
+        (n, a) => {
+          t == null || t(), t = void 0;
+          const r = e(n || p.value), i = e(a || p.value);
+          R(r) && (t = u(
+            [m, () => o.ariaLabel, q, () => o.id],
+            (s) => {
+              ["role", "aria-label", "aria-modal", "id"].forEach((y, b) => {
+                ae(s[b]) ? r.removeAttribute(y) : r.setAttribute(y, s[b]);
+              });
+            },
+            { immediate: !0 }
+          )), i !== r && R(i) && ["role", "aria-label", "aria-modal", "id"].forEach((s) => {
+            i.removeAttribute(s);
+          });
+        },
+        { immediate: !0 }
+      ), u(() => o.visible, _, { immediate: !0 });
+    }), V(() => {
+      t == null || t(), t = void 0, p.value = void 0;
+    }), B({
+      /**
+       * @description popper content element
+       */
+      popperContentRef: p,
+      /**
+       * @description popperjs instance
+       */
+      popperInstanceRef: j,
+      /**
+       * @description method for updating popper
+       */
+      updatePopper: v,
+      /**
+       * @description content style
+       */
+      contentStyle: d
+    }), (n, a) => (Y(), Z("div", G({
+      ref_key: "contentRef",
+      ref: p
+    }, e($), {
+      style: e(d),
+      class: e(K),
+      tabindex: "-1",
+      onMouseenter: a[0] || (a[0] = (r) => n.$emit("mouseenter", r)),
+      onMouseleave: a[1] || (a[1] = (r) => n.$emit("mouseleave", r))
+    }), [
+      H(e(W), {
+        loop: f.loop,
+        trapped: e(l),
+        "trap-on-focus-in": !0,
+        "focus-trap-el": e(p),
+        "focus-start-el": e(O),
+        onFocusAfterTrapped: e(g),
+        onFocusAfterReleased: e(A),
+        onFocusin: e(T),
+        onFocusoutPrevented: e(N),
+        onReleaseRequested: e(w)
+      }, {
+        default: Q(() => [
+          X(n.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["loop", "trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
+    ], 16));
+  }
+});
+export {
+  Re as default
+};

package/dist/components/popper/src/popper.d.ts

@@ -0,0 +1,35 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type Popper from './popper.vue';
+declare const effects: readonly ["light", "dark"];
+declare const triggers: readonly ["click", "contextmenu", "hover", "focus"];
+export declare const Effect: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+export declare const roleTypes: readonly ["dialog", "grid", "group", "listbox", "menu", "navigation", "tooltip", "tree"];
+export type PopperEffect = (typeof effects)[number] | (string & NonNullable<unknown>);
+export type PopperTrigger = (typeof triggers)[number];
+export interface PopperProps {
+    /**
+     * @description role determines how aria attributes are distributed
+     */
+    role?: (typeof roleTypes)[number];
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperProps` instead.
+ */
+export declare const popperProps: {
+    readonly role: import("@element-plus/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "listbox" | "grid" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperProps` instead.
+ */
+export type PopperPropsPublic = ExtractPublicPropTypes<typeof popperProps>;
+export type PopperInstance = InstanceType<typeof Popper> & unknown;
+/** @deprecated use `popperProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperProps: {
+    readonly role: import("@element-plus/utils").EpPropFinalized<StringConstructor, "dialog" | "menu" | "listbox" | "grid" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
+};
+/** @deprecated use `PopperProps` instead, and it will be deprecated in the next major version */
+export type UsePopperProps = PopperProps;
+export {};

package/dist/components/popper/src/popper.js

@@ -0,0 +1,22 @@
+import { buildProps as o } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const t = [
+  "dialog",
+  "grid",
+  "group",
+  "listbox",
+  "menu",
+  "navigation",
+  "tooltip",
+  "tree"
+], e = o({
+  role: {
+    type: String,
+    values: t,
+    default: "tooltip"
+  }
+});
+export {
+  e as popperProps,
+  t as roleTypes
+};

package/dist/components/popper/src/popper.vue.d.ts

@@ -0,0 +1,22 @@
+import type { Instance as PopperInstance } from '@popperjs/core';
+import type { PopperProps } from './popper';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<PopperProps, {
+    triggerRef: import("vue").Ref<import("./constants").Measurable | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined>;
+    popperInstanceRef: import("vue").Ref<PopperInstance | undefined>;
+    referenceRef: import("vue").Ref<import("./constants").Measurable | undefined>;
+    role: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PopperProps> & Readonly<{}>, {
+    role: typeof import("./popper").roleTypes[number];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};