@fangzhongya/fang-ui 0.0.11 → 0.0.13

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

@@ -0,0 +1,573 @@
+declare const Popover: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        refEl: import('vue').Ref<any, any>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {} | {
+        [x: string]: any;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        refEl: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly disabled: boolean;
+                readonly width: string | number;
+                readonly content: string;
+                readonly offset: number;
+                readonly visible: boolean | null;
+                readonly placement: any;
+                readonly effect: import('element-plus/es/index').PopperEffect;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly tabindex: string | number;
+                readonly trigger: import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[];
+                readonly popperOptions: Partial<Options>;
+                readonly enterable: boolean;
+                readonly triggerKeys: string[];
+                readonly teleported: boolean;
+                readonly persistent: boolean;
+                readonly showArrow: boolean;
+            }> & Omit<{
+                readonly width: string | number;
+                readonly visible: boolean | null;
+                readonly disabled: boolean;
+                readonly tabindex: string | number;
+                readonly teleported: boolean;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly effect: import('element-plus/es/index').PopperEffect;
+                readonly persistent: boolean;
+                readonly trigger: import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[];
+                readonly triggerKeys: string[];
+                readonly placement: any;
+                readonly popperOptions: any;
+                readonly content: string;
+                readonly enterable: boolean;
+                readonly showArrow: boolean;
+                readonly title?: string | undefined;
+                readonly appendTo?: (string | HTMLElement) | undefined;
+                readonly transition?: string | undefined;
+                readonly popperClass?: (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 | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]) | undefined;
+                readonly offset?: number | undefined;
+                readonly popperStyle?: import('vue').StyleValue;
+                "onUpdate:visible"?: (((visible: boolean) => void) & ((value: boolean) => any)) | undefined;
+                "onAfter-enter"?: (() => any) | undefined | undefined;
+                "onAfter-leave"?: (() => any) | undefined | undefined;
+                "onBefore-enter"?: (() => any) | undefined | undefined;
+                "onBefore-leave"?: (() => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "width" | "visible" | "disabled" | "tabindex" | "teleported" | "showAfter" | "hideAfter" | "autoClose" | "effect" | "offset" | "persistent" | "trigger" | "triggerKeys" | "placement" | "popperOptions" | "content" | "enterable" | "showArrow">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "after-enter") => void) & ((event: "after-leave") => void) & ((event: "before-enter") => void) & ((event: "before-leave") => void) & ((event: "update:visible", value: boolean) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly trigger: {
+                    readonly type: import('vue').PropType<import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                readonly triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                readonly placement: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                readonly disabled: BooleanConstructor;
+                readonly visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                readonly transition: StringConstructor;
+                readonly popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                readonly tabindex: {
+                    readonly type: import('vue').PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly popperClass: {
+                    readonly type: import('vue').PropType<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 | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly enterable: {
+                    readonly default: true;
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    readonly __epPropKey: true;
+                };
+                readonly effect: {
+                    readonly default: "light";
+                    readonly type: import('vue').PropType<import('element-plus/es/index').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    readonly __epPropKey: true;
+                };
+                readonly teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly title: StringConstructor;
+                readonly width: {
+                    readonly type: import('vue').PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 150;
+                };
+                readonly offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                readonly autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly persistent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(visible: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+                "onAfter-enter"?: (() => any) | undefined;
+                "onAfter-leave"?: (() => any) | undefined;
+                "onBefore-enter"?: (() => any) | undefined;
+                "onBefore-leave"?: (() => any) | undefined;
+            }, {
+                popperRef: import('vue').ComputedRef<import('element-plus/es/index').PopperInstance | undefined>;
+                hide: () => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "after-enter": () => void;
+                "after-leave": () => void;
+                "before-enter": () => void;
+                "before-leave": () => void;
+                "update:visible": (value: boolean) => void;
+            }, string, {
+                readonly disabled: boolean;
+                readonly width: string | number;
+                readonly content: string;
+                readonly offset: number;
+                readonly visible: boolean | null;
+                readonly placement: any;
+                readonly effect: import('element-plus/es/index').PopperEffect;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly tabindex: string | number;
+                readonly trigger: import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[];
+                readonly popperOptions: Partial<Options>;
+                readonly enterable: boolean;
+                readonly triggerKeys: string[];
+                readonly teleported: boolean;
+                readonly persistent: boolean;
+                readonly showArrow: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            readonly disabled: boolean;
+            readonly width: string | number;
+            readonly content: string;
+            readonly offset: number;
+            readonly visible: boolean | null;
+            readonly placement: any;
+            readonly effect: import('element-plus/es/index').PopperEffect;
+            readonly showAfter: number;
+            readonly hideAfter: number;
+            readonly autoClose: number;
+            readonly tabindex: string | number;
+            readonly trigger: import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[];
+            readonly popperOptions: Partial<Options>;
+            readonly enterable: boolean;
+            readonly triggerKeys: string[];
+            readonly teleported: boolean;
+            readonly persistent: boolean;
+            readonly showArrow: boolean;
+        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            readonly trigger: {
+                readonly type: import('vue').PropType<import('element-plus/es/index').TooltipTriggerType | import('element-plus/es/index').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            readonly triggerKeys: {
+                readonly type: import('vue').PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            readonly placement: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            readonly disabled: BooleanConstructor;
+            readonly visible: {
+                readonly type: import('vue').PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            readonly transition: StringConstructor;
+            readonly popperOptions: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly tabindex: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly content: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly popperStyle: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly popperClass: {
+                readonly type: import('vue').PropType<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 | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly enterable: {
+                readonly default: true;
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                readonly __epPropKey: true;
+            };
+            readonly effect: {
+                readonly default: "light";
+                readonly type: import('vue').PropType<import('element-plus/es/index').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                readonly __epPropKey: true;
+            };
+            readonly teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly appendTo: {
+                readonly type: import('vue').PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly title: StringConstructor;
+            readonly width: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 150;
+            };
+            readonly offset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly showAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly hideAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            readonly autoClose: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly showArrow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly persistent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly "onUpdate:visible": {
+                readonly type: import('vue').PropType<(visible: boolean) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+            "onAfter-enter"?: (() => any) | undefined;
+            "onAfter-leave"?: (() => any) | undefined;
+            "onBefore-enter"?: (() => any) | undefined;
+            "onBefore-leave"?: (() => any) | undefined;
+        }, "width" | "visible" | "disabled" | "tabindex" | "teleported" | "hide" | "showAfter" | "hideAfter" | "autoClose" | "effect" | "offset" | "persistent" | "trigger" | "triggerKeys" | "placement" | "popperOptions" | "content" | "enterable" | "showArrow" | "popperRef"> & import('vue').ShallowUnwrapRef<{
+            popperRef: import('vue').ComputedRef<import('element-plus/es/index').PopperInstance | undefined>;
+            hide: () => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                reference?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        refEl: import('vue').Ref<any, any>;
+    }, {}, {}, {}, {} | {
+        [x: string]: any;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+    refEl: import('vue').Ref<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {} | {
+    [x: string]: any;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {}) => any>>;
+}) & import('vue').Plugin;
+export { Popover, Popover as default };

package/dist/components/popover/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from "../../utils/vues/withInstall.js";
+import _sfc_main from "./src/index.js";
+const Popover = withInstall(_sfc_main, "Popover");
+export {
+  Popover,
+  Popover as default
+};

package/dist/components/popover/src/data.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buildProps = require("../../../utils/vues/buildProps.cjs");
+const dataProps = buildProps.buildProps({});
+const dataEmits = [];
+const dataExpose = {};
+exports.dataEmits = dataEmits;
+exports.dataExpose = dataExpose;
+exports.dataProps = dataProps;

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

@@ -0,0 +1,14 @@
+import { ExtractPropTypes } from 'vue';
+/**
+ * @title {h2} Popover 弹出框
+ * @text 目前完全继承 element-plus 中 el-popover
+ */
+export declare const dataProps: any;
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+export declare const dataEmits: never[];
+export type DataEmits = typeof dataEmits;
+export declare const dataSlot: {};
+/**
+ * @expose refEl 获取当前组件在element-plus中暴露的方法
+ */
+export declare const dataExpose: {};

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

@@ -0,0 +1,9 @@
+import { buildProps } from "../../../utils/vues/buildProps.js";
+const dataProps = buildProps({});
+const dataEmits = [];
+const dataExpose = {};
+export {
+  dataEmits,
+  dataExpose,
+  dataProps
+};

package/dist/components/popover/src/index.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const require$$0 = require("vue");
+const data = require("./data.cjs");
+const index$1 = require("../../../hooks/cssname/index.cjs");
+require("@fangzhongya/utils/basic/string/splitUpper");
+require("@fangzhongya/utils/basic/array/isArray");
+require("@fangzhongya/utils/basic/object/isObject");
+require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+require("@fangzhongya/utils/name/lineToLargeHump");
+require("@fangzhongya/utils/name/lineToSmallHump");
+require("@fangzhongya/utils/name/humpToLine");
+require("@fangzhongya/utils/basic/object/deepCopy");
+require("@fangzhongya/utils/basic/Array/toggleArray");
+require("@fangzhongya/utils/basic/object/objValue");
+require("../../../hooks/global-config/index.cjs");
+const index$2 = require("../../../hooks/locale/index.cjs");
+const index = require("../../../hooks/inherit/index.cjs");
+const elementPlus = require("element-plus");
+const _sfc_main = /* @__PURE__ */ require$$0.defineComponent({
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const refEl = require$$0.ref();
+    const attrs = index.useInherit();
+    const slots = require$$0.useSlots();
+    const cs = index$1.useCssName("popover");
+    index$2.useLocale();
+    __expose({
+      ...data.dataExpose,
+      refEl
+    });
+    return (_ctx, _cache) => {
+      return require$$0.openBlock(), require$$0.createElementBlock("div", require$$0.mergeProps({
+        class: [require$$0.unref(cs).z()]
+      }, require$$0.unref(attrs).root), [
+        require$$0.createVNode(require$$0.unref(elementPlus.ElPopover), require$$0.mergeProps(require$$0.unref(attrs).assem, {
+          ref_key: "refEl",
+          ref: refEl
+        }), require$$0.createSlots({ _: 2 }, [
+          require$$0.renderList(Object.keys(require$$0.unref(slots)), (k) => {
+            return {
+              name: k,
+              fn: require$$0.withCtx(() => [
+                require$$0.renderSlot(_ctx.$slots, k)
+              ])
+            };
+          })
+        ]), 1040)
+      ], 16);
+    };
+  }
+});
+exports.default = _sfc_main;