ep-craft 0.1.19 → 0.1.21

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

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