ep-craft 0.1.20 → 0.1.21

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

@@ -102,14 +102,14 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
 }>, {
     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 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[]) => "dark" | "light") | (() => "dark" | "light") | (((new (...args: any[]) => "dark" | "light") | (() => "dark" | "light")) | null)[], unknown, unknown>;

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>;

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

@@ -0,0 +1,76 @@
+import { inject as U, ref as F, computed as r, unref as o, watch as a, onMounted as M, onBeforeUnmount as _ } from "vue";
+import { useResizeObserver as C } from "../../../../node_modules/.pnpm/@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import "../../../../hooks/use-size/index.js";
+import { usePopper as I } from "../../../../hooks/use-popper/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_INJECTION_KEY as L } from "../constants.js";
+import { buildPopperOptions as T, unwrapMeasurableEl as h } from "../utils.js";
+import y from "../../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isUndefined.js";
+const A = 0, G = (n) => {
+  const { popperInstanceRef: c, contentRef: s, triggerRef: d, role: l } = U(
+    L,
+    void 0
+  ), m = F(), v = r(() => n.arrowOffset), w = r(() => ({
+    name: "eventListeners",
+    enabled: !!n.visible
+  })), E = r(() => {
+    const e = o(m), f = o(v) ?? A;
+    return {
+      name: "arrow",
+      enabled: !y(e),
+      options: {
+        element: e,
+        padding: f
+      }
+    };
+  }), R = r(() => ({
+    onFirstUpdate: () => {
+      i();
+    },
+    ...T(n, [
+      o(E),
+      o(w)
+    ])
+  })), p = r(
+    () => h(n.referenceEl) || o(d)
+  ), { attributes: P, state: b, styles: g, update: i, forceUpdate: O, instanceRef: u } = I(p, s, R);
+  a(u, (e) => c.value = e, {
+    flush: "sync"
+  }), M(() => {
+    a(
+      () => {
+        var e, f;
+        return (f = (e = o(p)) == null ? void 0 : e.getBoundingClientRect) == null ? void 0 : f.call(e);
+      },
+      () => {
+        i();
+      }
+    );
+  });
+  let t;
+  return a(
+    () => n.visible,
+    (e) => {
+      t == null || t(), t = void 0, e && (t = C(s, i).stop);
+    }
+  ), _(() => {
+    c.value = void 0, t == null || t(), t = void 0;
+  }), {
+    attributes: P,
+    arrowRef: m,
+    contentRef: s,
+    instanceRef: u,
+    state: b,
+    styles: g,
+    role: l,
+    forceUpdate: O,
+    update: i
+  };
+};
+export {
+  G as usePopperContent
+};

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

@@ -0,0 +1,12 @@
+import type { SetupContext } from 'vue';
+import type { PopperContentEmits, PopperContentProps } from '../content';
+export declare const usePopperContentFocusTrap: (props: PopperContentProps, emit: SetupContext<PopperContentEmits>["emit"]) => {
+    focusStartRef: import("vue").Ref<HTMLElement | "first" | "container" | undefined, HTMLElement | "first" | "container" | undefined>;
+    trapped: import("vue").Ref<boolean, boolean>;
+    onFocusAfterReleased: (event: CustomEvent) => void;
+    onFocusAfterTrapped: () => void;
+    onFocusInTrap: (event: FocusEvent) => void;
+    onFocusoutPrevented: (event: CustomEvent) => void;
+    onReleaseRequested: () => void;
+};
+export type UsePopperContentFocusTrapReturn = ReturnType<typeof usePopperContentFocusTrap>;

package/dist/components/popper/src/composables/use-focus-trap.js

@@ -0,0 +1,29 @@
+import { ref as r, onBeforeUnmount as p } from "vue";
+const d = (a, s) => {
+  const o = r(!1), t = r(), u = () => {
+    s("focus");
+  }, f = (e) => {
+    var n;
+    ((n = e.detail) == null ? void 0 : n.focusReason) !== "pointer" && (t.value = "first", s("blur"));
+  }, c = (e) => {
+    a.visible && !o.value && (e.target && (t.value = e.target), o.value = !0);
+  }, l = (e) => {
+    a.trapping || (e.detail.focusReason === "pointer" && e.preventDefault(), o.value = !1);
+  }, i = () => {
+    o.value = !1, s("close");
+  };
+  return p(() => {
+    t.value = void 0;
+  }), {
+    focusStartRef: t,
+    trapped: o,
+    onFocusAfterReleased: f,
+    onFocusAfterTrapped: u,
+    onFocusInTrap: c,
+    onFocusoutPrevented: l,
+    onReleaseRequested: i
+  };
+};
+export {
+  d as usePopperContentFocusTrap
+};

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

@@ -0,0 +1,23 @@
+import type { CSSProperties, ComputedRef, InjectionKey, Ref } from 'vue';
+import type { Instance } from '@popperjs/core';
+export type Measurable = {
+    getBoundingClientRect: () => DOMRect;
+};
+/**
+ * triggerRef indicates the element that triggers popper
+ * contentRef indicates the element of popper content
+ * referenceRef indicates the element that popper content relative with
+ */
+export type ElPopperInjectionContext = {
+    triggerRef: Ref<Measurable | undefined>;
+    contentRef: Ref<HTMLElement | undefined>;
+    popperInstanceRef: Ref<Instance | undefined>;
+    referenceRef: Ref<Measurable | undefined>;
+    role: ComputedRef<string>;
+};
+export type ElPopperContentInjectionContext = {
+    arrowRef: Ref<HTMLElement | undefined>;
+    arrowStyle: ComputedRef<CSSProperties>;
+};
+export declare const POPPER_INJECTION_KEY: InjectionKey<ElPopperInjectionContext>;
+export declare const POPPER_CONTENT_INJECTION_KEY: InjectionKey<ElPopperContentInjectionContext>;

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

@@ -0,0 +1,5 @@
+const o = Symbol("popper"), p = Symbol("popperContent");
+export {
+  p as POPPER_CONTENT_INJECTION_KEY,
+  o as POPPER_INJECTION_KEY
+};