ep-craft 0.1.19 → 0.1.21

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

@@ -1,4 +1,22 @@
-import type { Plugin } from 'vue';
-import { ElIcon } from 'element-plus';
-export declare const EpIcon: typeof ElIcon & Plugin;
+import Icon from './src/icon.vue';
+import type { SFCWithInstall } from '@element-plus/utils';
+export declare const ElIcon: SFCWithInstall<typeof Icon>;
+export declare const EpIcon: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import(".").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(".").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import(".").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;
+    };
+}) & import("vue").Plugin;
 export default EpIcon;
+export * from './src/icon';

package/dist/components/icon/index.js

@@ -1,7 +1,10 @@
-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 { ElIcon as n } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/icon/index.js";
-const t = Object.assign({}, n, { name: "EpIcon" }), m = o(t, "ep-icon");
+import "vue";
+import { withInstall as i } from "../../utils/vue/install.js";
+import t from "./src/icon.vue.js";
+import "./src/icon.js";
+i(t);
+const s = o(t, "ep-icon");
 export {
-  m as EpIcon
+  s as EpIcon
 };

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

@@ -0,0 +1,34 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type Icon from './icon.vue';
+export interface IconProps {
+    /**
+     * @description SVG icon size, size x size
+     */
+    size?: number | string;
+    /**
+     * @description SVG tag's fill attribute
+     */
+    color?: string;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `IconProps` instead.
+ */
+export declare const iconProps: {
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly color: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `IconProps` instead.
+ */
+export type IconPropsPublic = ExtractPublicPropTypes<typeof iconProps>;
+export type IconInstance = InstanceType<typeof Icon> & unknown;

package/dist/components/icon/src/icon.js

@@ -0,0 +1,16 @@
+import { buildProps as r, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+r({
+  /**
+   * @description SVG icon size, size x size
+   */
+  size: {
+    type: e([Number, String])
+  },
+  /**
+   * @description SVG tag's fill attribute
+   */
+  color: {
+    type: String
+  }
+});

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

@@ -0,0 +1,13 @@
+import type { IconProps } from './icon';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, 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/icon/src/icon.vue.js

@@ -0,0 +1,36 @@
+import { defineComponent as c, computed as m, openBlock as p, createElementBlock as l, mergeProps as a, unref as f, renderSlot as u } from "vue";
+import { addUnit as d } from "../../../utils/dom/style.js";
+import { useNamespace as _ } 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 g = /* @__PURE__ */ c({
+  name: "ElIcon",
+  inheritAttrs: !1,
+  __name: "icon",
+  props: {
+    size: {},
+    color: {}
+  },
+  setup(r) {
+    const n = r, s = _("icon"), i = m(() => {
+      const { size: o, color: t } = n, e = d(o);
+      return !e && !t ? {} : {
+        fontSize: e,
+        "--color": t
+      };
+    });
+    return (o, t) => (p(), l("i", a({
+      class: f(s).b(),
+      style: i.value
+    }, o.$attrs), [
+      u(o.$slots, "default")
+    ], 16));
+  }
+});
+export {
+  g as default
+};

package/dist/components/icon/src/icon2.vue.js

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

package/dist/components/menu/menu.d.ts

@@ -16,7 +16,7 @@ export declare const menuProps: {
     readonly ellipsis: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     readonly popperOffset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
     readonly ellipsisIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown, () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
-    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "light" | "dark") | (() => "light" | "dark") | (((new (...args: any[]) => "light" | "dark") | (() => "light" | "dark")) | null)[], unknown, unknown, "dark", boolean>;
+    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "dark" | "light") | (() => "dark" | "light") | (((new (...args: any[]) => "dark" | "light") | (() => "dark" | "light")) | null)[], unknown, unknown, "dark", boolean>;
     readonly popperClass: StringConstructor;
     readonly popperStyle: {
         readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties) | (((new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties)) | null)[], unknown, unknown>>;
@@ -51,7 +51,7 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly ellipsis: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     readonly popperOffset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
     readonly ellipsisIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown, () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
-    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "light" | "dark") | (() => "light" | "dark") | (((new (...args: any[]) => "light" | "dark") | (() => "light" | "dark")) | null)[], unknown, unknown, "dark", boolean>;
+    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "dark" | "light") | (() => "dark" | "light") | (((new (...args: any[]) => "dark" | "light") | (() => "dark" | "light")) | null)[], unknown, unknown, "dark", boolean>;
     readonly popperClass: StringConstructor;
     readonly popperStyle: {
         readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties) | (((new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties)) | null)[], unknown, unknown>>;
@@ -84,7 +84,7 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly ellipsis: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
     readonly popperOffset: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
     readonly ellipsisIcon: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown, () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
-    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "light" | "dark") | (() => "light" | "dark") | (((new (...args: any[]) => "light" | "dark") | (() => "light" | "dark")) | null)[], unknown, unknown, "dark", boolean>;
+    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => "dark" | "light") | (() => "dark" | "light") | (((new (...args: any[]) => "dark" | "light") | (() => "dark" | "light")) | null)[], unknown, unknown, "dark", boolean>;
     readonly popperClass: StringConstructor;
     readonly popperStyle: {
         readonly type: import("vue").PropType<import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties) | (((new (...args: any[]) => string | CSSProperties) | (() => string | CSSProperties)) | null)[], unknown, unknown>>;
@@ -96,23 +96,23 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly hideTimeout: import("element-plus/es/utils/index.mjs").EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
     readonly persistent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
 }>> & Readonly<{
-    onClose?: ((index: string, indexPath: string[]) => any) | undefined;
     onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<unknown> | undefined) => any) | undefined;
+    onClose?: ((index: string, indexPath: string[]) => any) | undefined;
     onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
 }>, {
+    readonly mode: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
     readonly persistent: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly collapse: boolean;
+    readonly ellipsis: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly showTimeout: number;
     readonly hideTimeout: number;
-    readonly mode: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
-    readonly collapse: boolean;
     readonly defaultActive: string;
     readonly defaultOpeneds: string[];
     readonly menuTrigger: import("element-plus/es/utils/index.mjs").EpPropMergeType<StringConstructor, "click" | "hover", unknown>;
     readonly collapseTransition: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    readonly ellipsis: import("element-plus/es/utils/index.mjs").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     readonly popperOffset: number;
     readonly ellipsisIcon: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown>;
-    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "light" | "dark") | (() => "light" | "dark") | (((new (...args: any[]) => "light" | "dark") | (() => "light" | "dark")) | null)[], unknown, unknown>;
+    readonly popperEffect: import("element-plus/es/utils/index.mjs").EpPropMergeType<(new (...args: any[]) => "dark" | "light") | (() => "dark" | "light") | (((new (...args: any[]) => "dark" | "light") | (() => "dark" | "light")) | null)[], unknown, unknown>;
     readonly uniqueOpened: boolean;
     readonly router: boolean;
     readonly closeOnClickOutside: boolean;

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

@@ -1,4 +1,55 @@
-import type { Plugin } from 'vue';
-import { ElPopper } from 'element-plus';
-export declare const EpPopper: typeof ElPopper & Plugin;
+import Popper from './src/popper.vue';
+import ElPopperArrow from './src/arrow.vue';
+import ElPopperTrigger from './src/trigger.vue';
+import ElPopperContent from './src/content.vue';
+import type { SFCWithInstall } from '@element-plus/utils';
+export { ElPopperArrow, ElPopperTrigger, ElPopperContent };
+export declare const ElPopper: SFCWithInstall<typeof Popper>;
+export declare const EpPopper: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import(".").PopperProps> & Readonly<{}>, {
+        triggerRef: import("vue").Ref<import(".").Measurable | undefined>;
+        contentRef: import("vue").Ref<HTMLElement | undefined>;
+        popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
+        referenceRef: import("vue").Ref<import(".").Measurable | undefined>;
+        role: import("vue").ComputedRef<string>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        role: typeof import(".").roleTypes[number];
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import(".").PopperProps> & Readonly<{}>, {
+        triggerRef: import("vue").Ref<import(".").Measurable | undefined>;
+        contentRef: import("vue").Ref<HTMLElement | undefined>;
+        popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
+        referenceRef: import("vue").Ref<import(".").Measurable | undefined>;
+        role: import("vue").ComputedRef<string>;
+    }, {}, {}, {}, {
+        role: typeof import(".").roleTypes[number];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import(".").PopperProps> & Readonly<{}>, {
+    triggerRef: import("vue").Ref<import(".").Measurable | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined>;
+    popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance | undefined>;
+    referenceRef: import("vue").Ref<import(".").Measurable | undefined>;
+    role: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    role: typeof import(".").roleTypes[number];
+}, {}, 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;
+    };
+}) & import("vue").Plugin;
 export default EpPopper;
+export * from './src/popper';
+export * from './src/trigger';
+export * from './src/content';
+export * from './src/arrow';
+export * from './src/constants';
+export type { Placement, Options } from '@popperjs/core';

package/dist/components/popper/index.js

@@ -1,7 +1,32 @@
-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 p } from "../../utils/with-install.js";
-import { ElPopper as o } from "../../node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/popper/index.js";
-const r = Object.assign({}, o, { name: "EpPopper" }), i = p(r, "ep-popper");
+import { withInstall as o } from "../../utils/with-install.js";
+import "vue";
+import { withInstall as r } from "../../utils/vue/install.js";
+import p from "./src/popper.vue.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 "../slot/src/only-child.js";
+import "../focus-trap/index.js";
+import "../form/index.js";
+import { popperContentEmits as D, popperContentProps as E, popperContentPropsDefaults as I, popperCoreConfigProps as A, popperCoreConfigPropsDefaults as T } from "./src/content.js";
+import { popperProps as y, roleTypes as $ } from "./src/popper.js";
+import { popperTriggerProps as d } from "./src/trigger.js";
+import { popperArrowProps as k, popperArrowPropsDefaults as q } from "./src/arrow.js";
+const g = r(p), c = o(p, "ep-popper");
 export {
-  i as EpPopper
+  g as ElPopper,
+  c as EpPopper,
+  k as popperArrowProps,
+  q as popperArrowPropsDefaults,
+  D as popperContentEmits,
+  E as popperContentProps,
+  I as popperContentPropsDefaults,
+  A as popperCoreConfigProps,
+  T as popperCoreConfigPropsDefaults,
+  y as popperProps,
+  d as popperTriggerProps,
+  $ as roleTypes
 };

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

@@ -0,0 +1,30 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type Arrow from './arrow.vue';
+export interface PopperArrowProps {
+    /**
+     * @description arrow offset
+     */
+    arrowOffset?: number;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperArrowProps` instead.
+ */
+export declare const popperArrowProps: {
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopperArrowProps` instead.
+ */
+export type PopperArrowPropsPublic = ExtractPublicPropTypes<typeof popperArrowProps>;
+export declare const popperArrowPropsDefaults: {
+    readonly arrowOffset: 5;
+};
+export type PopperArrowInstance = InstanceType<typeof Arrow> & unknown;
+/** @deprecated use `popperArrowProps` instead, and it will be deprecated in the next major version */
+export declare const usePopperArrowProps: {
+    readonly arrowOffset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
+};
+/** @deprecated use `PopperArrowProps` instead, and it will be deprecated in the next major version */
+export type UsePopperArrowProps = PopperArrowProps;
+/** @deprecated use `PopperArrowInstance` instead, and it will be deprecated in the next major version */
+export type ElPopperArrowInstance = PopperArrowInstance;

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

@@ -0,0 +1,14 @@
+import { buildProps as r } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const t = r({
+  arrowOffset: {
+    type: Number,
+    default: 5
+  }
+}), e = {
+  arrowOffset: 5
+};
+export {
+  t as popperArrowProps,
+  e as popperArrowPropsDefaults
+};

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

@@ -0,0 +1,7 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    /**
+     * @description Arrow element
+     */
+    arrowRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

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

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

@@ -0,0 +1,37 @@
+import { defineComponent as a, inject as n, onBeforeUnmount as m, openBlock as s, createElementBlock as i, normalizeStyle as l, unref as e, normalizeClass as c } 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";
+import { POPPER_CONTENT_INJECTION_KEY as _ } from "./constants.js";
+const O = /* @__PURE__ */ a({
+  name: "ElPopperArrow",
+  inheritAttrs: !1,
+  __name: "arrow",
+  setup(u, { expose: o }) {
+    const t = f("popper"), { arrowRef: r, arrowStyle: p } = n(
+      _,
+      void 0
+    );
+    return m(() => {
+      r.value = void 0;
+    }), o({
+      /**
+       * @description Arrow element
+       */
+      arrowRef: r
+    }), (w, E) => (s(), i("span", {
+      ref_key: "arrowRef",
+      ref: r,
+      class: c(e(t).e("arrow")),
+      style: l(e(p)),
+      "data-popper-arrow": ""
+    }, null, 6));
+  }
+});
+export {
+  O as default
+};

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

@@ -0,0 +1,4 @@
+import { usePopperContent } from "./use-content";
+import { usePopperContentDOM } from "./use-content-dom";
+import { usePopperContentFocusTrap } from "./use-focus-trap";
+export { usePopperContent, usePopperContentDOM, usePopperContentFocusTrap };

package/dist/components/popper/src/composables/use-content-dom.d.ts

@@ -0,0 +1,40 @@
+import type { CSSProperties, StyleValue } from 'vue';
+import type { UsePopperReturn } from '@element-plus/hooks';
+import type { UsePopperContentReturn } from './use-content';
+import type { PopperContentProps } from '../content';
+export declare const usePopperContentDOM: (props: PopperContentProps, { attributes, styles, role, }: Pick<UsePopperReturn, "attributes" | "styles"> & Pick<UsePopperContentReturn, "role">) => {
+    ariaModal: import("vue").ComputedRef<string | undefined>;
+    arrowStyle: import("vue").ComputedRef<CSSProperties>;
+    contentAttrs: import("vue").ComputedRef<{
+        [key: string]: string | boolean;
+    }>;
+    contentClass: import("vue").ComputedRef<((string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | (string | {
+        [x: string]: boolean;
+    } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | undefined)[]>;
+    contentStyle: import("vue").ComputedRef<StyleValue[]>;
+    contentZIndex: import("vue").Ref<number, number>;
+    updateZIndex: () => void;
+};
+export type UsePopperContentDOMReturn = ReturnType<typeof usePopperContentDOM>;

package/dist/components/popper/src/composables/use-content-dom.js

@@ -0,0 +1,45 @@
+import { computed as t, unref as n, ref as f } from "vue";
+import { useNamespace as l } from "../../../../hooks/use-namespace/index.js";
+import { isNumber as d } from "../../../../utils/types.js";
+import "../../../../hooks/use-size/index.js";
+import { useZIndex as z } from "../../../../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 A = (e, {
+  attributes: m,
+  styles: p,
+  role: a
+}) => {
+  const { nextZIndex: c } = z(), o = l("popper"), i = t(() => n(m).popper), r = f(
+    d(e.zIndex) ? e.zIndex : c()
+  ), s = t(() => [
+    o.b(),
+    o.is("pure", e.pure),
+    o.is(e.effect),
+    e.popperClass
+  ]), u = t(() => [
+    { zIndex: n(r) },
+    n(p).popper,
+    e.popperStyle || {}
+  ]), x = t(
+    () => a.value === "dialog" ? "false" : void 0
+  ), I = t(
+    () => n(p).arrow || {}
+  );
+  return {
+    ariaModal: x,
+    arrowStyle: I,
+    contentAttrs: i,
+    contentClass: s,
+    contentStyle: u,
+    contentZIndex: r,
+    updateZIndex: () => {
+      r.value = d(e.zIndex) ? e.zIndex : c();
+    }
+  };
+};
+export {
+  A as usePopperContentDOM
+};

package/dist/components/popper/src/composables/use-content.d.ts

@@ -0,0 +1,77 @@
+import type { Modifier } from '@popperjs/core';
+import type { PopperContentProps } from '../content';
+export declare const usePopperContent: (props: PopperContentProps) => {
+    attributes: import("vue").ComputedRef<{
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    }>;
+    arrowRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    instanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance | undefined>;
+    state: import("vue").ComputedRef<{
+        elements?: {
+            reference: Element | import("@popperjs/core").VirtualElement;
+            popper: HTMLElement;
+            arrow?: HTMLElement;
+        } | undefined;
+        options?: import("@popperjs/core").OptionsGeneric<any> | undefined;
+        placement?: import("element-plus").Placement | undefined;
+        strategy?: import("@popperjs/core").PositioningStrategy | undefined;
+        orderedModifiers?: Modifier<any, any>[] | undefined;
+        rects?: import("@popperjs/core").StateRects | undefined;
+        scrollParents?: {
+            reference: Array<Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport>;
+            popper: Array<Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport>;
+        } | undefined;
+        styles?: {
+            [key: string]: Partial<CSSStyleDeclaration>;
+        } | undefined;
+        attributes?: {
+            [key: string]: {
+                [key: string]: string | boolean;
+            };
+        } | undefined;
+        modifiersData?: {
+            [key: string]: any;
+            arrow?: {
+                x?: number;
+                y?: number;
+                centerOffset: number;
+            };
+            hide?: {
+                isReferenceHidden: boolean;
+                hasPopperEscaped: boolean;
+                referenceClippingOffsets: import("@popperjs/core").SideObject;
+                popperEscapeOffsets: import("@popperjs/core").SideObject;
+            };
+            offset?: {
+                top?: import("@popperjs/core").Offsets | undefined;
+                bottom?: import("@popperjs/core").Offsets | undefined;
+                left?: import("@popperjs/core").Offsets | undefined;
+                "top-start"?: import("@popperjs/core").Offsets | undefined;
+                "top-end"?: import("@popperjs/core").Offsets | undefined;
+                "bottom-start"?: import("@popperjs/core").Offsets | undefined;
+                "bottom-end"?: import("@popperjs/core").Offsets | undefined;
+                right?: import("@popperjs/core").Offsets | undefined;
+                auto?: import("@popperjs/core").Offsets | undefined;
+                "auto-start"?: import("@popperjs/core").Offsets | undefined;
+                "auto-end"?: import("@popperjs/core").Offsets | undefined;
+                "right-start"?: import("@popperjs/core").Offsets | undefined;
+                "right-end"?: import("@popperjs/core").Offsets | undefined;
+                "left-start"?: import("@popperjs/core").Offsets | undefined;
+                "left-end"?: import("@popperjs/core").Offsets | undefined;
+            };
+            preventOverflow?: import("@popperjs/core").Offsets;
+            popperOffsets?: import("@popperjs/core").Offsets;
+        } | undefined;
+        reset?: boolean | undefined;
+    }>;
+    styles: import("vue").ComputedRef<{
+        [key: string]: Partial<CSSStyleDeclaration>;
+    }>;
+    role: import("vue").ComputedRef<string>;
+    forceUpdate: () => void | undefined;
+    update: () => Promise<Partial<import("@popperjs/core").State>> | undefined;
+};
+export type UsePopperContentReturn = ReturnType<typeof usePopperContent>;