ep-craft 0.1.32 → 0.1.34

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

@@ -1,4 +1,122 @@
-import type { Plugin } from 'vue';
-import { ElPopover } from 'element-plus';
-export declare const EpPopover: typeof ElPopover & Plugin;
+export declare const EpPopoverDirective: import("../../utils").SFCWithInstall<import("vue").ObjectDirective<any, any, string, any>>;
+export declare const EpPopover: ({
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import(".").PopoverProps> & Readonly<{
+        "onAfter-leave"?: (() => any) | undefined;
+        "onBefore-enter"?: (() => any) | undefined;
+        "onAfter-enter"?: (() => any) | undefined;
+        "onBefore-leave"?: (() => any) | undefined;
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    }>, {
+        popperRef: import("vue").ComputedRef<import("../popper").PopperInstance | undefined>;
+        hide: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "after-leave": () => void;
+        "before-enter": () => void;
+        "after-enter": () => void;
+        "before-leave": () => void;
+        "update:visible": (value: boolean) => void;
+    }, import("vue").PublicProps, {
+        content: string;
+        visible: boolean | null;
+        width: string | number;
+        offset: number;
+        tabindex: string | number;
+        teleported: boolean;
+        placement: import("element-plus").Placement;
+        effect: import("../popper").PopperEffect;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+        popperOptions: Partial<import("element-plus").Options>;
+        enterable: boolean;
+        popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        triggerKeys: string[];
+        persistent: boolean;
+        showArrow: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import(".").PopoverProps> & Readonly<{
+        "onAfter-leave"?: (() => any) | undefined;
+        "onBefore-enter"?: (() => any) | undefined;
+        "onAfter-enter"?: (() => any) | undefined;
+        "onBefore-leave"?: (() => any) | undefined;
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    }>, {
+        popperRef: import("vue").ComputedRef<import("../popper").PopperInstance | undefined>;
+        hide: () => void;
+    }, {}, {}, {}, {
+        content: string;
+        visible: boolean | null;
+        width: string | number;
+        offset: number;
+        tabindex: string | number;
+        teleported: boolean;
+        placement: import("element-plus").Placement;
+        effect: import("../popper").PopperEffect;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+        popperOptions: Partial<import("element-plus").Options>;
+        enterable: boolean;
+        popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        triggerKeys: string[];
+        persistent: boolean;
+        showArrow: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import(".").PopoverProps> & Readonly<{
+    "onAfter-leave"?: (() => any) | undefined;
+    "onBefore-enter"?: (() => any) | undefined;
+    "onAfter-enter"?: (() => any) | undefined;
+    "onBefore-leave"?: (() => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {
+    popperRef: import("vue").ComputedRef<import("../popper").PopperInstance | undefined>;
+    hide: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "after-leave": () => void;
+    "before-enter": () => void;
+    "after-enter": () => void;
+    "before-leave": () => void;
+    "update:visible": (value: boolean) => void;
+}, string, {
+    content: string;
+    visible: boolean | null;
+    width: string | number;
+    offset: number;
+    tabindex: string | number;
+    teleported: boolean;
+    placement: import("element-plus").Placement;
+    effect: import("../popper").PopperEffect;
+    showAfter: number;
+    hideAfter: number;
+    autoClose: number;
+    trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+    popperOptions: Partial<import("element-plus").Options>;
+    enterable: boolean;
+    popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    triggerKeys: string[];
+    persistent: boolean;
+    showArrow: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        reference?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            hide: () => void;
+        }) => any;
+    };
+}) & import("vue").Plugin) & {
+    directive: import("../../utils").SFCWithInstall<import("vue").ObjectDirective<any, any, string, any>>;
+};
 export default EpPopover;
+export * from './src/popover';

package/dist/components/popover/index.js

@@ -1,6 +1,21 @@
-import { ElPopover as o } from "element-plus";
-import { withInstall as p } from "../../utils/with-install.js";
-const r = Object.assign({}, o, { name: "EpPopover" }), m = p(r, "ep-popover");
+import { withInstall as t } from "../../utils/with-install.js";
+import { withInstallDirective as i } from "../../utils/vue/install.js";
+import v from "./src/popover.vue.js";
+import m, { VPopover as e } from "./src/directive.js";
+import { popoverEmits as a, popoverProps as D, popoverPropsDefaults as E } from "./src/popover.js";
+const p = i(
+  m,
+  e
+), r = Object.assign(t(v, "ep-popover"), {
+  directive: p
+});
+r.install = (o) => {
+  o.component("ep-popover", r), o.directive(e, p);
+};
 export {
-  m as EpPopover
+  r as EpPopover,
+  p as EpPopoverDirective,
+  a as popoverEmits,
+  D as popoverProps,
+  E as popoverPropsDefaults
 };

package/dist/components/popover/src/directive.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDirective } from 'vue';
+declare const _default: ObjectDirective;
+export default _default;
+export declare const VPopover = "popover";

package/dist/components/popover/src/directive.js

@@ -0,0 +1,15 @@
+const a = (o, e) => {
+  const t = e.arg || e.value, r = t == null ? void 0 : t.popperRef;
+  r && (r.triggerRef = o);
+}, c = {
+  mounted(o, e) {
+    a(o, e);
+  },
+  updated(o, e) {
+    a(o, e);
+  }
+}, p = "popover";
+export {
+  p as VPopover,
+  c as default
+};

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

@@ -0,0 +1,291 @@
+import type { ExtractPublicPropTypes, PropType } from 'vue';
+import type Popover from './popover.vue';
+import type { Placement } from '@element-plus/components/popper';
+import type { Options } from '@popperjs/core';
+import type { ElTooltipContentProps, UseTooltipTriggerProps } from '@element-plus/components/tooltip';
+export interface PopoverProps {
+    /**
+     * @description how the popover is triggered, not valid in controlled mode
+     */
+    trigger?: UseTooltipTriggerProps['trigger'];
+    /**
+     * @description When you click the mouse to focus on the trigger element, you can define a set of keyboard codes to control the display of popover through the keyboard, not valid in controlled mode
+     */
+    triggerKeys?: UseTooltipTriggerProps['triggerKeys'];
+    /**
+     * @description popover placement
+     */
+    placement?: Placement;
+    /**
+     * @description whether Popover is disabled
+     */
+    disabled?: UseTooltipTriggerProps['disabled'];
+    /**
+     * @description whether popover is visible
+     */
+    visible?: ElTooltipContentProps['visible'];
+    /**
+     * @description popover transition animation
+     */
+    transition?: ElTooltipContentProps['transition'];
+    /**
+     * @description parameters for [popper.js](https://popper.js.org/docs/v2/)
+     */
+    popperOptions?: Partial<Options>;
+    /**
+     * @description [tabindex](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex) of Popover
+     */
+    tabindex?: string | number;
+    /**
+     * @description popover content, can be replaced with a default `slot`
+     */
+    content?: ElTooltipContentProps['content'];
+    /**
+     * @description custom style for popover
+     */
+    popperStyle?: ElTooltipContentProps['popperStyle'];
+    /**
+     * @description custom class name for popover
+     */
+    popperClass?: ElTooltipContentProps['popperClass'];
+    /**
+     * @description whether the mouse can enter the popover
+     */
+    enterable?: ElTooltipContentProps['enterable'];
+    /**
+     * @description Tooltip theme, built-in theme: `dark` / `light`
+     */
+    effect?: ElTooltipContentProps['effect'];
+    /**
+     * @description whether popover dropdown is teleported to the body
+     */
+    teleported?: ElTooltipContentProps['teleported'];
+    /**
+     * @description which select dropdown appends to
+     */
+    appendTo?: ElTooltipContentProps['appendTo'];
+    /**
+     * @description popover title
+     */
+    title?: string;
+    /**
+     * @description popover width
+     */
+    width?: string | number;
+    /**
+     * @description popover offset
+     */
+    offset?: number;
+    /**
+     * @description delay of appearance, in millisecond, not valid in controlled mode
+     */
+    showAfter?: number;
+    /**
+     * @description delay of disappear, in millisecond, not valid in controlled mode
+     */
+    hideAfter?: number;
+    /**
+     * @description timeout in milliseconds to hide tooltip, not valid in controlled mode
+     */
+    autoClose?: number;
+    /**
+     * @description whether a tooltip arrow is displayed or not. For more info, please refer to [ElPopper](https://github.com/element-plus/element-plus/tree/dev/packages/components/popper)
+     */
+    showArrow?: boolean;
+    /**
+     * @description when popover inactive and `persistent` is `false` , popover will be destroyed
+     */
+    persistent?: boolean;
+    /**
+     * @description update:visible event handler
+     */
+    'onUpdate:visible'?: (visible: boolean) => void;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `PopoverProps` instead.
+ */
+export declare const popoverProps: {
+    readonly trigger: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("@element-plus/components/tooltip").TooltipTriggerType[]) | (() => import("@element-plus/utils").Arrayable<import("@element-plus/components/tooltip").TooltipTriggerType>) | (((new (...args: any[]) => "click" | "focus" | "contextmenu" | "hover" | import("@element-plus/components/tooltip").TooltipTriggerType[]) | (() => import("@element-plus/utils").Arrayable<import("@element-plus/components/tooltip").TooltipTriggerType>)) | null)[], unknown, unknown, "hover", boolean>;
+    readonly triggerKeys: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], unknown, unknown, "bottom", boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly visible: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | (((new (...args: any[]) => boolean) | (() => boolean | null)) | null)[], unknown, unknown, null, boolean>;
+    readonly transition: StringConstructor;
+    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 tabindex: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+    readonly content: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly popperClass: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => 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)[])[])[])[])[])[])[])[])[])[])[]) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => 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)[])[])[])[])[])[])[])[])[])[])[]) | (() => 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)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly enterable: {
+        readonly default: true;
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly effect: {
+        readonly default: "light";
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("@element-plus/components/popper").PopperEffect)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly appendTo: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly title: StringConstructor;
+    readonly width: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 150, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, undefined, boolean>;
+    readonly showAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly hideAfter: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
+    readonly autoClose: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly showArrow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly 'onUpdate:visible': {
+        readonly type: PropType<(visible: boolean) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `PopoverProps` instead.
+ */
+export type PopoverPropsPublic = ExtractPublicPropTypes<typeof popoverProps>;
+export declare const popoverEmits: {
+    'update:visible': (value: boolean) => boolean;
+    'before-enter': () => boolean;
+    'before-leave': () => boolean;
+    'after-enter': () => boolean;
+    'after-leave': () => boolean;
+};
+export type PopoverEmits = typeof popoverEmits;
+export type PopoverInstance = InstanceType<typeof Popover> & unknown;
+/**
+ * @description default values for PopoverProps
+ */
+export declare const popoverPropsDefaults: {
+    readonly trigger: "hover";
+    readonly triggerKeys: () => string[];
+    readonly placement: "bottom";
+    readonly visible: null;
+    readonly popperOptions: () => {};
+    readonly tabindex: 0;
+    readonly content: "";
+    readonly popperStyle: undefined;
+    readonly enterable: true;
+    readonly effect: "light";
+    readonly teleported: true;
+    readonly width: 150;
+    readonly offset: undefined;
+    readonly showAfter: 0;
+    readonly hideAfter: 200;
+    readonly autoClose: 0;
+    readonly showArrow: true;
+    readonly persistent: true;
+};

package/dist/components/popover/src/popover.js

@@ -0,0 +1,168 @@
+import { isBoolean as i } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { EVENT_CODE as t } from "../../../constants/aria.js";
+import "@element-plus/icons-vue";
+import { buildProps as l } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../tooltip/index.js";
+import "../../dropdown/index.js";
+import { useTooltipContentProps as e } from "../../tooltip/src/content.js";
+import { dropdownProps as r } from "../../dropdown/src/dropdown.js";
+import { useTooltipTriggerProps as o } from "../../tooltip/src/trigger.js";
+const w = l({
+  /**
+   * @description how the popover is triggered, not valid in controlled mode
+   */
+  trigger: o.trigger,
+  /**
+   * @description When you click the mouse to focus on the trigger element, you can define a set of keyboard codes to control the display of popover through the keyboard, not valid in controlled mode
+   */
+  triggerKeys: o.triggerKeys,
+  /**
+   * @description popover placement
+   */
+  placement: r.placement,
+  /**
+   * @description whether Popover is disabled
+   */
+  disabled: o.disabled,
+  /**
+   * @description whether popover is visible
+   */
+  visible: e.visible,
+  /**
+   * @description popover transition animation
+   */
+  transition: e.transition,
+  /**
+   * @description parameters for [popper.js](https://popper.js.org/docs/v2/)
+   */
+  popperOptions: r.popperOptions,
+  /**
+   * @description [tabindex](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex) of Popover
+   */
+  tabindex: r.tabindex,
+  /**
+   * @description popover content, can be replaced with a default `slot`
+   */
+  content: e.content,
+  /**
+   * @description custom style for popover
+   */
+  popperStyle: e.popperStyle,
+  /**
+   * @description custom class name for popover
+   */
+  popperClass: e.popperClass,
+  enterable: {
+    ...e.enterable,
+    default: !0
+  },
+  /**
+   * @description Tooltip theme, built-in theme: `dark` / `light`
+   */
+  effect: {
+    ...e.effect,
+    default: "light"
+  },
+  /**
+   * @description whether popover dropdown is teleported to the body
+   */
+  teleported: e.teleported,
+  /**
+   * @description which select dropdown appends to
+   */
+  appendTo: e.appendTo,
+  /**
+   * @description popover title
+   */
+  title: String,
+  /**
+   * @description popover width
+   */
+  width: {
+    type: [String, Number],
+    default: 150
+  },
+  /**
+   * @description popover offset
+   */
+  offset: {
+    type: Number,
+    default: void 0
+  },
+  /**
+   * @description delay of appearance, in millisecond, not valid in controlled mode
+   */
+  showAfter: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description delay of disappear, in millisecond, not valid in controlled mode
+   */
+  hideAfter: {
+    type: Number,
+    default: 200
+  },
+  /**
+   * @description timeout in milliseconds to hide tooltip, not valid in controlled mode
+   */
+  autoClose: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description whether a tooltip arrow is displayed or not. For more info, please refer to [ElPopper](https://github.com/element-plus/element-plus/tree/dev/packages/components/popper)
+   */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description when popover inactive and `persistent` is `false` , popover will be destroyed
+   */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  "onUpdate:visible": {
+    type: Function
+  }
+}), A = {
+  "update:visible": (p) => i(p),
+  "before-enter": () => !0,
+  "before-leave": () => !0,
+  "after-enter": () => !0,
+  "after-leave": () => !0
+}, C = {
+  trigger: "hover",
+  triggerKeys: () => [
+    t.enter,
+    t.numpadEnter,
+    t.space
+  ],
+  placement: "bottom",
+  visible: null,
+  popperOptions: () => ({}),
+  tabindex: 0,
+  content: "",
+  popperStyle: void 0,
+  enterable: !0,
+  effect: "light",
+  teleported: !0,
+  width: 150,
+  offset: void 0,
+  showAfter: 0,
+  hideAfter: 200,
+  autoClose: 0,
+  showArrow: !0,
+  persistent: !0
+};
+export {
+  A as popoverEmits,
+  w as popoverProps,
+  C as popoverPropsDefaults
+};