@element-plus/nightly 0.0.20220920 → 0.0.20220922

package/lib/components/tooltip/src/trigger.vue.d.ts

@@ -9,13 +9,48 @@ declare const _default: import("vue").DefineComponent<{
         __epPropKey: true;
     };
     readonly virtualTriggering: BooleanConstructor;
-    readonly onMouseenter: FunctionConstructor;
-    readonly onMouseleave: FunctionConstructor;
-    readonly onClick: FunctionConstructor;
-    readonly onKeydown: FunctionConstructor;
-    readonly onFocus: FunctionConstructor;
-    readonly onBlur: FunctionConstructor;
-    readonly onContextmenu: FunctionConstructor;
+    readonly onMouseenter: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onMouseleave: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onClick: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onKeydown: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onFocus: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onBlur: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onContextmenu: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
     readonly id: StringConstructor;
     readonly open: BooleanConstructor;
 }, {
@@ -30,13 +65,48 @@ declare const _default: import("vue").DefineComponent<{
             __epPropKey: true;
         };
         readonly virtualTriggering: BooleanConstructor;
-        readonly onMouseenter: FunctionConstructor;
-        readonly onMouseleave: FunctionConstructor;
-        readonly onClick: FunctionConstructor;
-        readonly onKeydown: FunctionConstructor;
-        readonly onFocus: FunctionConstructor;
-        readonly onBlur: FunctionConstructor;
-        readonly onContextmenu: FunctionConstructor;
+        readonly onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         readonly id: StringConstructor;
         readonly open: BooleanConstructor;
     }>> & {
@@ -84,13 +154,48 @@ declare const _default: import("vue").DefineComponent<{
             __epPropKey: true;
         };
         readonly virtualTriggering: BooleanConstructor;
-        readonly onMouseenter: FunctionConstructor;
-        readonly onMouseleave: FunctionConstructor;
-        readonly onClick: FunctionConstructor;
-        readonly onKeydown: FunctionConstructor;
-        readonly onFocus: FunctionConstructor;
-        readonly onBlur: FunctionConstructor;
-        readonly onContextmenu: FunctionConstructor;
+        readonly onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         readonly id: StringConstructor;
         readonly open: BooleanConstructor;
     }, {
@@ -102,13 +207,48 @@ declare const _default: import("vue").DefineComponent<{
                 __epPropKey: true;
             };
             readonly virtualTriggering: BooleanConstructor;
-            readonly onMouseenter: FunctionConstructor;
-            readonly onMouseleave: FunctionConstructor;
-            readonly onClick: FunctionConstructor;
-            readonly onKeydown: FunctionConstructor;
-            readonly onFocus: FunctionConstructor;
-            readonly onBlur: FunctionConstructor;
-            readonly onContextmenu: FunctionConstructor;
+            readonly onMouseenter: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onMouseleave: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onClick: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onKeydown: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onFocus: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onBlur: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onContextmenu: {
+                readonly type: import("vue").PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
             readonly id: StringConstructor;
             readonly open: BooleanConstructor;
         }>> & {
@@ -132,13 +272,48 @@ declare const _default: import("vue").DefineComponent<{
             __epPropKey: true;
         };
         readonly virtualTriggering: BooleanConstructor;
-        readonly onMouseenter: FunctionConstructor;
-        readonly onMouseleave: FunctionConstructor;
-        readonly onClick: FunctionConstructor;
-        readonly onKeydown: FunctionConstructor;
-        readonly onFocus: FunctionConstructor;
-        readonly onBlur: FunctionConstructor;
-        readonly onContextmenu: FunctionConstructor;
+        readonly onMouseenter: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onMouseleave: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onClick: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onKeydown: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onFocus: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onBlur: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly onContextmenu: {
+            readonly type: import("vue").PropType<(e: Event) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
         readonly id: StringConstructor;
         readonly open: BooleanConstructor;
     }>>, {
@@ -156,13 +331,48 @@ declare const _default: import("vue").DefineComponent<{
         __epPropKey: true;
     };
     readonly virtualTriggering: BooleanConstructor;
-    readonly onMouseenter: FunctionConstructor;
-    readonly onMouseleave: FunctionConstructor;
-    readonly onClick: FunctionConstructor;
-    readonly onKeydown: FunctionConstructor;
-    readonly onFocus: FunctionConstructor;
-    readonly onBlur: FunctionConstructor;
-    readonly onContextmenu: FunctionConstructor;
+    readonly onMouseenter: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onMouseleave: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onClick: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onKeydown: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onFocus: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onBlur: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onContextmenu: {
+        readonly type: import("vue").PropType<(e: Event) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
     readonly id: StringConstructor;
     readonly open: BooleanConstructor;
 }>>, {

package/lib/components/tooltip-v2/index.d.ts

@@ -229,7 +229,6 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -240,6 +239,7 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -260,7 +260,6 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -271,6 +270,7 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -291,7 +291,6 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -302,6 +301,7 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -322,7 +322,6 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -333,6 +332,7 @@ export declare const ElTooltipV2: import("element-plus/es/utils").SFCWithInstall
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };

package/lib/components/tooltip-v2/src/tooltip.vue.d.ts

@@ -229,7 +229,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -240,6 +239,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -260,7 +260,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -271,6 +270,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -291,7 +291,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -302,6 +301,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };
@@ -322,7 +322,6 @@ declare const _default: import("vue").DefineComponent<{
         readonly onClick?: ((e: Event) => boolean | void) | undefined;
         readonly showArrow?: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
         readonly to?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined) | ((new (...args: any[]) => (string | import("vue").RendererElement | null | undefined) & {}) | (() => string | import("vue").RendererElement | null | undefined))[], unknown, unknown>;
-        readonly contentClass?: string | undefined;
         readonly reference?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null) | ((new (...args: any[]) => HTMLElement | import("@floating-ui/dom").VirtualElement) | (() => HTMLElement | import("@floating-ui/dom").VirtualElement | null))[], unknown, unknown> | undefined;
         readonly alwaysOn?: boolean | undefined;
         readonly delayDuration?: number | undefined;
@@ -333,6 +332,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly onMouseEnter?: ((e: Event) => boolean | void) | undefined;
         readonly onMouseLeave?: ((e: Event) => boolean | void) | undefined;
         readonly arrowPadding?: number | undefined;
+        readonly contentClass?: string | undefined;
         readonly transitionProps?: import("../../../utils").EpPropMergeType<(new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null) | ((new (...args: any[]) => import("vue").TransitionProps) | (() => import("vue").TransitionProps | null))[], unknown, unknown> | undefined;
         readonly fullTransition?: boolean | undefined;
     };

package/lib/directives/index.d.ts

@@ -1,4 +1,4 @@
 export { default as ClickOutside } from './click-outside';
-export { default as RepeatClick } from './repeat-click';
+export { vRepeatClick } from './repeat-click';
 export { default as TrapFocus } from './trap-focus';
 export { default as Mousewheel } from './mousewheel';

package/lib/directives/index.js

@@ -10,7 +10,7 @@ var index$3 = require('./mousewheel/index.js');
 
 
 exports.ClickOutside = index["default"];
-exports.RepeatClick = index$1["default"];
+exports.vRepeatClick = index$1.vRepeatClick;
 exports.TrapFocus = index$2["default"];
 exports.Mousewheel = index$3["default"];
 //# sourceMappingURL=index.js.map

package/lib/directives/repeat-click/index.d.ts

@@ -1,5 +1,9 @@
 import type { ObjectDirective } from 'vue';
 export declare const REPEAT_INTERVAL = 100;
 export declare const REPEAT_DELAY = 600;
-declare const RepeatClick: ObjectDirective;
-export default RepeatClick;
+export interface RepeatClickOptions {
+    interval?: number;
+    delay?: number;
+    handler: (...args: unknown[]) => unknown;
+}
+export declare const vRepeatClick: ObjectDirective<HTMLElement, RepeatClickOptions | RepeatClickOptions['handler']>;

package/lib/directives/repeat-click/index.js

@@ -2,39 +2,46 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+require('../../utils/index.js');
+var shared = require('@vue/shared');
+
 const REPEAT_INTERVAL = 100;
 const REPEAT_DELAY = 600;
-const RepeatClick = {
+const vRepeatClick = {
   beforeMount(el, binding) {
-    let interval = null;
-    let delay = null;
-    const handler = () => binding.value && binding.value();
+    const value = binding.value;
+    const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = shared.isFunction(value) ? {} : value;
+    let intervalId;
+    let delayId;
+    const handler = () => shared.isFunction(value) ? value() : value.handler();
     const clear = () => {
-      if (delay) {
-        clearTimeout(delay);
-        delay = null;
+      if (delayId) {
+        clearTimeout(delayId);
+        delayId = void 0;
       }
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = void 0;
       }
     };
-    el.addEventListener("mousedown", (e) => {
-      if (e.button !== 0)
+    el.addEventListener("mousedown", (evt) => {
+      if (evt.button !== 0)
         return;
-      handler();
-      document.addEventListener("mouseup", clear, { once: true });
       clear();
-      delay = setTimeout(() => {
-        interval = setInterval(() => {
+      handler();
+      document.addEventListener("mouseup", () => clear(), {
+        once: true
+      });
+      delayId = setTimeout(() => {
+        intervalId = setInterval(() => {
           handler();
-        }, REPEAT_INTERVAL);
-      }, REPEAT_DELAY);
+        }, interval);
+      }, delay);
     });
   }
 };
 
 exports.REPEAT_DELAY = REPEAT_DELAY;
 exports.REPEAT_INTERVAL = REPEAT_INTERVAL;
-exports["default"] = RepeatClick;
+exports.vRepeatClick = vRepeatClick;
 //# sourceMappingURL=index.js.map

package/lib/directives/repeat-click/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../packages/directives/repeat-click/index.ts"],"sourcesContent":["import type { DirectiveBinding, ObjectDirective } from 'vue'\n\nexport const REPEAT_INTERVAL = 100\nexport const REPEAT_DELAY = 600\n\nconst RepeatClick: ObjectDirective = {\n  beforeMount(el: HTMLElement, binding: DirectiveBinding) {\n    let interval: ReturnType<typeof setInterval> | null = null\n    let delay: ReturnType<typeof setTimeout> | null = null\n\n    const handler = () => binding.value && binding.value()\n\n    const clear = () => {\n      if (delay) {\n        clearTimeout(delay)\n        delay = null\n      }\n      if (interval) {\n        clearInterval(interval)\n        interval = null\n      }\n    }\n\n    el.addEventListener('mousedown', (e: MouseEvent) => {\n      if (e.button !== 0) return\n      handler()\n\n      document.addEventListener('mouseup', clear, { once: true })\n      clear()\n      delay = setTimeout(() => {\n        interval = setInterval(() => {\n          handler()\n        }, REPEAT_INTERVAL)\n      }, REPEAT_DELAY)\n    })\n  },\n}\n\nexport default RepeatClick\n"],"names":[],"mappings":";;;;AAAY,MAAC,eAAe,GAAG,IAAI;AACvB,MAAC,YAAY,GAAG,IAAI;AAC3B,MAAC,WAAW,GAAG;AACpB,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE;AAC3B,IAAI,IAAI,QAAQ,GAAG,IAAI,CAAC;AACxB,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC;AACrB,IAAI,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;AAC3D,IAAI,MAAM,KAAK,GAAG,MAAM;AACxB,MAAM,IAAI,KAAK,EAAE;AACjB,QAAQ,YAAY,CAAC,KAAK,CAAC,CAAC;AAC5B,QAAQ,KAAK,GAAG,IAAI,CAAC;AACrB,OAAO;AACP,MAAM,IAAI,QAAQ,EAAE;AACpB,QAAQ,aAAa,CAAC,QAAQ,CAAC,CAAC;AAChC,QAAQ,QAAQ,GAAG,IAAI,CAAC;AACxB,OAAO;AACP,KAAK,CAAC;AACN,IAAI,EAAE,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,KAAK;AAC5C,MAAM,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC;AACxB,QAAQ,OAAO;AACf,MAAM,OAAO,EAAE,CAAC;AAChB,MAAM,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAClE,MAAM,KAAK,EAAE,CAAC;AACd,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM;AAC/B,QAAQ,QAAQ,GAAG,WAAW,CAAC,MAAM;AACrC,UAAU,OAAO,EAAE,CAAC;AACpB,SAAS,EAAE,eAAe,CAAC,CAAC;AAC5B,OAAO,EAAE,YAAY,CAAC,CAAC;AACvB,KAAK,CAAC,CAAC;AACP,GAAG;AACH;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../packages/directives/repeat-click/index.ts"],"sourcesContent":["import { isFunction } from '@element-plus/utils'\n\nimport type { ObjectDirective } from 'vue'\n\nexport const REPEAT_INTERVAL = 100\nexport const REPEAT_DELAY = 600\n\nexport interface RepeatClickOptions {\n  interval?: number\n  delay?: number\n  handler: (...args: unknown[]) => unknown\n}\n\nexport const vRepeatClick: ObjectDirective<\n  HTMLElement,\n  RepeatClickOptions | RepeatClickOptions['handler']\n> = {\n  beforeMount(el, binding) {\n    const value = binding.value\n    const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = isFunction(\n      value\n    )\n      ? {}\n      : value\n\n    let intervalId: ReturnType<typeof setInterval> | undefined\n    let delayId: ReturnType<typeof setTimeout> | undefined\n\n    const handler = () => (isFunction(value) ? value() : value.handler())\n\n    const clear = () => {\n      if (delayId) {\n        clearTimeout(delayId)\n        delayId = undefined\n      }\n      if (intervalId) {\n        clearInterval(intervalId)\n        intervalId = undefined\n      }\n    }\n\n    el.addEventListener('mousedown', (evt: MouseEvent) => {\n      if (evt.button !== 0) return\n      clear()\n      handler()\n\n      document.addEventListener('mouseup', () => clear(), {\n        once: true,\n      })\n\n      delayId = setTimeout(() => {\n        intervalId = setInterval(() => {\n          handler()\n        }, interval)\n      }, delay)\n    })\n  },\n}\n"],"names":["isFunction"],"mappings":";;;;;;;AACY,MAAC,eAAe,GAAG,IAAI;AACvB,MAAC,YAAY,GAAG,IAAI;AACpB,MAAC,YAAY,GAAG;AAC5B,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE;AAC3B,IAAI,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;AAChC,IAAI,MAAM,EAAE,QAAQ,GAAG,eAAe,EAAE,KAAK,GAAG,YAAY,EAAE,GAAGA,iBAAU,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;AAChG,IAAI,IAAI,UAAU,CAAC;AACnB,IAAI,IAAI,OAAO,CAAC;AAChB,IAAI,MAAM,OAAO,GAAG,MAAMA,iBAAU,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;AACxE,IAAI,MAAM,KAAK,GAAG,MAAM;AACxB,MAAM,IAAI,OAAO,EAAE;AACnB,QAAQ,YAAY,CAAC,OAAO,CAAC,CAAC;AAC9B,QAAQ,OAAO,GAAG,KAAK,CAAC,CAAC;AACzB,OAAO;AACP,MAAM,IAAI,UAAU,EAAE;AACtB,QAAQ,aAAa,CAAC,UAAU,CAAC,CAAC;AAClC,QAAQ,UAAU,GAAG,KAAK,CAAC,CAAC;AAC5B,OAAO;AACP,KAAK,CAAC;AACN,IAAI,EAAE,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK;AAC9C,MAAM,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;AAC1B,QAAQ,OAAO;AACf,MAAM,KAAK,EAAE,CAAC;AACd,MAAM,OAAO,EAAE,CAAC;AAChB,MAAM,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,KAAK,EAAE,EAAE;AAC1D,QAAQ,IAAI,EAAE,IAAI;AAClB,OAAO,CAAC,CAAC;AACT,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM;AACjC,QAAQ,UAAU,GAAG,WAAW,CAAC,MAAM;AACvC,UAAU,OAAO,EAAE,CAAC;AACpB,SAAS,EAAE,QAAQ,CAAC,CAAC;AACrB,OAAO,EAAE,KAAK,CAAC,CAAC;AAChB,KAAK,CAAC,CAAC;AACP,GAAG;AACH;;;;;;"}

package/lib/index.js

@@ -412,12 +412,18 @@ exports.ElPagination = index$C.ElPagination;
 exports.popconfirmProps = popconfirm.popconfirmProps;
 exports.ElPopconfirm = index$D.ElPopconfirm;
 exports.Effect = popper.Effect;
+exports.popperProps = popper.popperProps;
 exports.roleTypes = popper.roleTypes;
 exports.usePopperProps = popper.usePopperProps;
+exports.popperTriggerProps = trigger$1.popperTriggerProps;
 exports.usePopperTriggerProps = trigger$1.usePopperTriggerProps;
+exports.popperContentEmits = content$1.popperContentEmits;
+exports.popperContentProps = content$1.popperContentProps;
+exports.popperCoreConfigProps = content$1.popperCoreConfigProps;
 exports.usePopperContentEmits = content$1.usePopperContentEmits;
 exports.usePopperContentProps = content$1.usePopperContentProps;
 exports.usePopperCoreConfigProps = content$1.usePopperCoreConfigProps;
+exports.popperArrowProps = arrow$1.popperArrowProps;
 exports.usePopperArrowProps = arrow$1.usePopperArrowProps;
 exports.ElPopperArrow = arrow["default"];
 exports.ElPopperTrigger = trigger["default"];
@@ -585,7 +591,7 @@ exports.INSTALLED_KEY = key.INSTALLED_KEY;
 exports.componentSizeMap = size.componentSizeMap;
 exports.componentSizes = size.componentSizes;
 exports.ClickOutside = index$19["default"];
-exports.RepeatClick = index$1a["default"];
+exports.vRepeatClick = index$1a.vRepeatClick;
 exports.TrapFocus = index$1b["default"];
 exports.Mousewheel = index$1c["default"];
 exports.useAttrs = index$1d.useAttrs;

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../packages/element-plus/index.ts"],"sourcesContent":["import installer from './defaults'\nexport * from '@element-plus/components'\nexport * from '@element-plus/constants'\nexport * from '@element-plus/directives'\nexport * from '@element-plus/hooks'\nexport * from '@element-plus/tokens'\nexport * from './make-installer'\n\nexport const install = installer.install\nexport const version = installer.version\nexport default installer\n\nexport { default as dayjs } from 'dayjs'\n"],"names":["installer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOY,MAAC,OAAO,GAAGA,mBAAS,CAAC,QAAQ;AAC7B,MAAC,OAAO,GAAGA,mBAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../packages/element-plus/index.ts"],"sourcesContent":["import installer from './defaults'\nexport * from '@element-plus/components'\nexport * from '@element-plus/constants'\nexport * from '@element-plus/directives'\nexport * from '@element-plus/hooks'\nexport * from '@element-plus/tokens'\nexport * from './make-installer'\n\nexport const install = installer.install\nexport const version = installer.version\nexport default installer\n\nexport { default as dayjs } from 'dayjs'\n"],"names":["installer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOY,MAAC,OAAO,GAAGA,mBAAS,CAAC,QAAQ;AAC7B,MAAC,OAAO,GAAGA,mBAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.0.20220920";
+export declare const version = "0.0.20220922";

package/lib/version.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const version = "0.0.20220920";
+const version = "0.0.20220922";
 
 exports.version = version;
 //# sourceMappingURL=version.js.map