@aifuxi/semi-ui-vue 2.0.0 → 2.0.2

package/dist/_shared/32e609ebc394.js

@@ -1,497 +0,0 @@
-import { createCommentVNode, useSlots, markRaw, shallowRef, inject, onBeforeUnmount, unref, Fragment, renderList, provide, mergeProps, nextTick, useId, createElementBlock, createBlock, useTemplateRef, createElementVNode, getCurrentInstance, normalizeClass, openBlock, renderSlot, normalizeStyle, createVNode, watch, withCtx, computed, defineComponent } from "./d5f901a8f22e.js";
-import "./a7e0eab4d4b0.js";
-import { dropdownContextKey } from "./da4fa43e7fac.js";
-import { semiGlobal as semi_global } from "./7d608cdc8674.js";
-import { Tooltip } from "./2e8179a1a44a.js";
-import { DropdownNodeRenderer } from "./f6a0b7dfef47.js";
-import { DropdownMenu } from "./c0c0837a7eba.js";
-import { DropdownTitle } from "./e7d83c2f88f0.js";
-import { DropdownItem } from "./66d3cee2a97c.js";
-import { DropdownDivider } from "./4c4877d1c415.js";
-import { DropdownTriggerRenderer } from "./a0aeaf76cc6d.js";
-import { DropdownFoundation } from "./33b938eec364.js";
-const Dropdownvue_type_script_setup_true_lang_ts = /*@__PURE__*/ defineComponent({
-    name: 'Dropdown',
-    inheritAttrs: false,
-    __name: 'Dropdown',
-    props: {
-        class: {
-            type: [
-                Boolean,
-                null,
-                String,
-                Object,
-                Array
-            ]
-        },
-        contentClassName: {
-            type: [
-                Boolean,
-                null,
-                String,
-                Object,
-                Array
-            ]
-        },
-        menu: {},
-        mouseLeaveDelay: {},
-        position: {},
-        prefixCls: {},
-        render: {
-            type: [
-                Object,
-                String,
-                Number,
-                Boolean,
-                null,
-                Array,
-                Function
-            ]
-        },
-        returnFocusOnClose: {
-            type: Boolean
-        },
-        role: {},
-        showArrow: {
-            type: [
-                Boolean,
-                Object,
-                String,
-                Number,
-                null,
-                Array
-            ]
-        },
-        showTick: {
-            type: Boolean
-        },
-        spacing: {},
-        style: {
-            type: [
-                Boolean,
-                null,
-                String,
-                Object,
-                Array
-            ]
-        },
-        trigger: {},
-        visible: {
-            type: Boolean
-        },
-        arrowBounding: {},
-        arrowPointAtCenter: {
-            type: Boolean
-        },
-        autoAdjustOverflow: {
-            type: Boolean
-        },
-        clickToHide: {
-            type: Boolean
-        },
-        clickTriggerToHide: {
-            type: Boolean
-        },
-        closeOnEsc: {
-            type: Boolean
-        },
-        condition: {
-            type: Boolean
-        },
-        disableArrowKeyDown: {
-            type: Boolean
-        },
-        disableFocusListener: {
-            type: Boolean
-        },
-        getPopupContainer: {
-            type: Function
-        },
-        guardFocus: {
-            type: Boolean
-        },
-        keepDOM: {
-            type: Boolean
-        },
-        margin: {},
-        motion: {
-            type: Boolean
-        },
-        mouseEnterDelay: {},
-        preventScroll: {
-            type: Boolean
-        },
-        rePosKey: {},
-        stopPropagation: {
-            type: Boolean
-        },
-        transformFromCenter: {
-            type: Boolean
-        },
-        wrapWhenSpecial: {
-            type: Boolean
-        },
-        wrapperId: {},
-        zIndex: {}
-    },
-    emits: [
-        "afterClose",
-        "clickOutside",
-        "escKeydown",
-        "visibleChange",
-        "update:visible"
-    ],
-    setup (__props, { expose: __expose, emit: __emit }) {
-        const props = __props;
-        const emit = __emit;
-        const slots = useSlots();
-        const instance = getCurrentInstance();
-        const parentContext = inject(dropdownContextKey, void 0);
-        const tooltipRef = useTemplateRef('tooltip');
-        const triggerElement = shallowRef(null);
-        const popVisible = shallowRef(hasRawProp('visible') ? props.visible : void 0);
-        const generatedPopupId = `semi-dropdown-${useId()}`;
-        const pendingUpdate = shallowRef(void 0);
-        let enterTimer;
-        let leaveTimer;
-        function hasRawProp(key) {
-            const kebabKey = String(key).replace(/[A-Z]/g, (letter)=>`-${letter.toLowerCase()}`);
-            const rawProps = instance?.vnode.props;
-            return Boolean(rawProps && (Object.prototype.hasOwnProperty.call(rawProps, key) || Object.prototype.hasOwnProperty.call(rawProps, kebabKey)));
-        }
-        function resolveProp(key, fallback) {
-            if (hasRawProp(key) && void 0 !== props[key]) return props[key];
-            const globalValue = semi_global.config.overrideDefaultProps?.Dropdown?.[key];
-            return void 0 === globalValue ? fallback : globalValue;
-        }
-        function resolveOptional(key) {
-            if (hasRawProp(key)) return props[key];
-            const globalValue = semi_global.config.overrideDefaultProps?.Dropdown?.[key];
-            return void 0 === globalValue ? props[key] : globalValue;
-        }
-        const runtimeTrigger = computed(()=>resolveProp('trigger', 'hover'));
-        const runtimeShowTick = computed(()=>resolveProp('showTick', false));
-        const runtimePrefixCls = computed(()=>resolveProp('prefixCls', 'semi-dropdown'));
-        const runtimeVisible = computed(()=>hasRawProp('visible') ? Boolean(props.visible) : Boolean(popVisible.value));
-        const runtimePopupId = computed(()=>resolveOptional('wrapperId') ?? generatedPopupId);
-        const runtimeSpacing = computed(()=>{
-            const explicit = resolveOptional('spacing');
-            if (void 0 !== explicit) return explicit;
-            return (parentContext?.level ?? 0) > 0 ? 2 : 4;
-        });
-        provide(dropdownContextKey, {
-            level: (parentContext?.level ?? 0) + 1,
-            showTick: runtimeShowTick,
-            trigger: runtimeTrigger
-        });
-        const adapter = {
-            getPopupId: ()=>tooltipRef.value?.getPopupId() ?? '',
-            getProps: ()=>({
-                    trigger: runtimeTrigger.value
-                }),
-            getStates: ()=>({
-                    visible: runtimeVisible.value
-                }),
-            notifyVisibleChange: (visible)=>{
-                emit('visibleChange', visible);
-                if (pendingUpdate.value === visible) {
-                    pendingUpdate.value = void 0;
-                    return;
-                }
-                emit('update:visible', visible);
-            },
-            setPopVisible: (visible)=>{
-                popVisible.value = visible;
-            }
-        };
-        const foundation = markRaw(new DropdownFoundation(adapter));
-        const tooltipBindings = computed(()=>{
-            const bindings = {
-                closeOnEsc: false,
-                motion: resolveProp('motion', true),
-                mouseEnterDelay: resolveProp('mouseEnterDelay', 50),
-                mouseLeaveDelay: resolveProp('mouseLeaveDelay', 100),
-                position: resolveProp('position', 'bottom'),
-                prefixCls: runtimePrefixCls.value,
-                returnFocusOnClose: resolveProp('returnFocusOnClose', true),
-                role: resolveProp('role', 'tooltip'),
-                showArrow: resolveProp('showArrow', false),
-                spacing: runtimeSpacing.value,
-                trigger: 'custom',
-                visible: runtimeVisible.value,
-                zIndex: resolveProp('zIndex', 1060)
-            };
-            const optional = {
-                arrowBounding: resolveOptional('arrowBounding'),
-                arrowPointAtCenter: resolveOptional('arrowPointAtCenter'),
-                autoAdjustOverflow: resolveOptional('autoAdjustOverflow'),
-                class: props.class,
-                clickToHide: resolveOptional('clickToHide'),
-                clickTriggerToHide: resolveOptional('clickTriggerToHide'),
-                condition: resolveOptional('condition'),
-                disableArrowKeyDown: resolveOptional('disableArrowKeyDown'),
-                disableFocusListener: resolveOptional('disableFocusListener'),
-                getPopupContainer: resolveOptional('getPopupContainer'),
-                guardFocus: resolveOptional('guardFocus'),
-                keepDOM: resolveOptional('keepDOM'),
-                margin: resolveOptional('margin'),
-                preventScroll: resolveOptional('preventScroll'),
-                rePosKey: resolveOptional('rePosKey'),
-                stopPropagation: resolveOptional('stopPropagation'),
-                transformFromCenter: resolveOptional('transformFromCenter'),
-                wrapWhenSpecial: resolveOptional('wrapWhenSpecial'),
-                wrapperId: runtimePopupId.value
-            };
-            for (const [key, value] of Object.entries(optional))if (void 0 !== value) bindings[key] = value;
-            return bindings;
-        });
-        watch(()=>props.visible, (visible)=>{
-            if (hasRawProp('visible')) popVisible.value = Boolean(visible);
-        });
-        function handleVisibleChange(visible) {
-            foundation.handleVisibleChange(visible);
-            if (visible && 'click' === runtimeTrigger.value) nextTick(()=>{
-                const id = tooltipRef.value?.getPopupId();
-                if (id) foundation.setFocusToFirstMenuItem(id);
-            });
-            else if (!visible) clearEnterTimer();
-        }
-        function handleTriggerKeydown(event) {
-            rememberTrigger(event);
-            if ('Escape' === event.key && runtimeVisible.value && resolveProp('closeOnEsc', true)) {
-                emit('escKeydown', event);
-                if ('custom' !== runtimeTrigger.value && resolveProp('returnFocusOnClose', true)) resolveCurrentTrigger()?.focus();
-                requestVisible(false);
-                return;
-            }
-            foundation.handleKeyDown(event);
-        }
-        function clearEnterTimer() {
-            if (enterTimer) clearTimeout(enterTimer);
-            enterTimer = void 0;
-        }
-        function clearLeaveTimer() {
-            if (leaveTimer) clearTimeout(leaveTimer);
-            leaveTimer = void 0;
-        }
-        function requestVisible(visible) {
-            if (!visible) clearEnterTimer();
-            if (runtimeVisible.value === visible) return;
-            popVisible.value = visible;
-            pendingUpdate.value = visible;
-            emit('update:visible', visible);
-        }
-        function delayVisible(visible) {
-            if (visible) {
-                clearLeaveTimer();
-                clearEnterTimer();
-                enterTimer = setTimeout(()=>requestVisible(true), resolveProp('mouseEnterDelay', 50));
-            } else {
-                clearEnterTimer();
-                clearLeaveTimer();
-                leaveTimer = setTimeout(()=>requestVisible(false), resolveProp('mouseLeaveDelay', 100));
-            }
-        }
-        const triggerEventSet = computed(()=>{
-            const events = {
-                onKeydown: (event)=>handleTriggerKeydown(event)
-            };
-            if ('click' === runtimeTrigger.value) events.onClick = (event)=>{
-                rememberTrigger(event);
-                requestVisible(!runtimeVisible.value);
-            };
-            else if ('hover' === runtimeTrigger.value) {
-                events.onMouseenter = (event)=>{
-                    rememberTrigger(event);
-                    delayVisible(true);
-                };
-                events.onMouseleave = ()=>delayVisible(false);
-                if (!resolveProp('disableFocusListener', false)) {
-                    events.onFocus = (event)=>{
-                        rememberTrigger(event);
-                        delayVisible(true);
-                    };
-                    events.onBlur = ()=>delayVisible(false);
-                }
-            } else if ('focus' === runtimeTrigger.value) {
-                events.onFocus = (event)=>{
-                    rememberTrigger(event);
-                    delayVisible(true);
-                };
-                events.onBlur = ()=>delayVisible(false);
-            } else if ('contextMenu' === runtimeTrigger.value) events.onContextmenu = (event)=>{
-                rememberTrigger(event);
-                event.preventDefault();
-                requestVisible(true);
-            };
-            return events;
-        });
-        function handlePopupInserted() {
-            nextTick(()=>{
-                if ('hover' === runtimeTrigger.value && runtimeVisible.value && !resolveCurrentTrigger()?.matches(':hover')) requestVisible(false);
-            });
-        }
-        function handlePopupEnter() {
-            if ('hover' === runtimeTrigger.value || 'focus' === runtimeTrigger.value) clearLeaveTimer();
-        }
-        function handlePopupFocus() {
-            if ('focus' === runtimeTrigger.value || 'hover' === runtimeTrigger.value && !resolveProp('disableFocusListener', false)) clearLeaveTimer();
-        }
-        function handlePopupBlur() {
-            if ('focus' === runtimeTrigger.value || 'hover' === runtimeTrigger.value && !resolveProp('disableFocusListener', false)) delayVisible(false);
-        }
-        function handlePopupLeave() {
-            if ('hover' === runtimeTrigger.value || 'focus' === runtimeTrigger.value) delayVisible(false);
-        }
-        function handlePopupKeydown(event) {
-            if ('Escape' !== event.key || !resolveProp('closeOnEsc', true)) return;
-            emit('escKeydown', event);
-            if (resolveProp('returnFocusOnClose', true)) resolveCurrentTrigger()?.focus();
-            requestVisible(false);
-        }
-        function handleAfterClose() {
-            emit('afterClose');
-        }
-        function handleClickOutside(event) {
-            const trigger = runtimeTrigger.value;
-            const clickTriggerToHide = Boolean(resolveOptional('clickTriggerToHide'));
-            if ('click' === trigger || 'contextMenu' === trigger || 'custom' === trigger || clickTriggerToHide) emit('clickOutside', event);
-            if ('click' === trigger || 'contextMenu' === trigger || clickTriggerToHide) requestVisible(false);
-        }
-        function menuItemKey(item, index) {
-            return item.key ?? `${item.node}-${index}`;
-        }
-        function menuItemBindings(item) {
-            return Object.fromEntries(Object.entries(item).filter(([key])=>![
-                    'key',
-                    'name',
-                    'node'
-                ].includes(key)));
-        }
-        function focusTrigger() {
-            resolveCurrentTrigger()?.focus();
-        }
-        function resolveCurrentTrigger() {
-            if ("u" < typeof document) return triggerElement.value;
-            return document.querySelector(`[data-popupid="${runtimePopupId.value}"]`) ?? triggerElement.value;
-        }
-        function rememberTrigger(event) {
-            if (event.currentTarget instanceof HTMLElement) triggerElement.value = event.currentTarget;
-        }
-        function setTriggerElement(element) {
-            if (element) triggerElement.value = element;
-        }
-        function getPopupId() {
-            return tooltipRef.value?.getPopupId() ?? runtimePopupId.value;
-        }
-        function rePosition() {
-            return tooltipRef.value?.rePosition() ?? {};
-        }
-        __expose({
-            focusTrigger,
-            getPopupId,
-            rePosition
-        });
-        onBeforeUnmount(()=>{
-            clearEnterTimer();
-            clearLeaveTimer();
-        });
-        return (_ctx, _cache)=>(openBlock(), createBlock(Tooltip, mergeProps({
-                ref: "tooltip"
-            }, tooltipBindings.value, {
-                onAfterClose: handleAfterClose,
-                onClickOutside: handleClickOutside,
-                onEscKeydown: _cache[0] || (_cache[0] = ($event)=>emit('escKeydown', $event)),
-                onVisibleChange: handleVisibleChange
-            }), {
-                content: withCtx(()=>[
-                        createElementVNode("div", {
-                            class: normalizeClass([
-                                runtimePrefixCls.value,
-                                props.contentClassName
-                            ]),
-                            style: normalizeStyle(props.style),
-                            onVnodeMounted: handlePopupInserted,
-                            onMouseenter: handlePopupEnter,
-                            onMouseleave: handlePopupLeave,
-                            onFocusin: handlePopupFocus,
-                            onFocusout: handlePopupBlur,
-                            onKeydownCapture: handlePopupKeydown
-                        }, [
-                            createElementVNode("div", {
-                                class: normalizeClass(`${runtimePrefixCls.value}-content`),
-                                "x-semi-prop": "render"
-                            }, [
-                                slots.content ? renderSlot(_ctx.$slots, "content", {}, void 0, void 0, 0) : props.render ? (openBlock(), createBlock(unref(DropdownNodeRenderer), {
-                                    key: 1,
-                                    content: props.render
-                                }, null, 8, [
-                                    "content"
-                                ])) : Array.isArray(props.menu) ? (openBlock(), createBlock(DropdownMenu, {
-                                    key: 2
-                                }, {
-                                    default: withCtx(()=>[
-                                            (openBlock(true), createElementBlock(Fragment, null, renderList(props.menu, (item, index)=>(openBlock(), createElementBlock(Fragment, {
-                                                    key: menuItemKey(item, index)
-                                                }, [
-                                                    'title' === item.node ? (openBlock(), createBlock(DropdownTitle, mergeProps({
-                                                        key: 0,
-                                                        ref_for: true
-                                                    }, menuItemBindings(item)), {
-                                                        default: withCtx(()=>[
-                                                                createVNode(unref(DropdownNodeRenderer), {
-                                                                    content: item.name
-                                                                }, null, 8, [
-                                                                    "content"
-                                                                ])
-                                                            ]),
-                                                        _: 2
-                                                    }, 1040)) : 'item' === item.node ? (openBlock(), createBlock(DropdownItem, mergeProps({
-                                                        key: 1,
-                                                        ref_for: true
-                                                    }, menuItemBindings(item)), {
-                                                        default: withCtx(()=>[
-                                                                createVNode(unref(DropdownNodeRenderer), {
-                                                                    content: item.name
-                                                                }, null, 8, [
-                                                                    "content"
-                                                                ])
-                                                            ]),
-                                                        _: 2
-                                                    }, 1040)) : (openBlock(), createBlock(DropdownDivider, mergeProps({
-                                                        key: 2,
-                                                        ref_for: true
-                                                    }, menuItemBindings(item)), null, 16))
-                                                ], 64))), 128))
-                                        ]),
-                                    _: 1
-                                })) : createCommentVNode("", true)
-                            ], 2)
-                        ], 38)
-                    ]),
-                default: withCtx(()=>[
-                        createVNode(unref(DropdownTriggerRenderer), {
-                            "event-set": triggerEventSet.value,
-                            expanded: hasRawProp('visible') ? props.visible : popVisible.value,
-                            "popup-id": runtimePopupId.value,
-                            "prefix-cls": runtimePrefixCls.value,
-                            "set-trigger-element": setTriggerElement,
-                            visible: runtimeVisible.value
-                        }, {
-                            default: withCtx(()=>[
-                                    renderSlot(_ctx.$slots, "default")
-                                ]),
-                            _: 3
-                        }, 8, [
-                            "event-set",
-                            "expanded",
-                            "popup-id",
-                            "prefix-cls",
-                            "visible"
-                        ])
-                    ]),
-                _: 3
-            }, 16));
-    }
-});
-export { Dropdownvue_type_script_setup_true_lang_ts };