@aifuxi/semi-ui-vue 1.2.0 → 2.0.2

package/dist/_shared/27cb24c06002.js

@@ -0,0 +1,1174 @@
+import { createCommentVNode, useSlots, shallowReactive, shallowRef, inject, onBeforeUnmount, unref, mergeProps, createElementBlock, createElementVNode, createVNode, getCurrentInstance, normalizeClass, openBlock, watch, createTextVNode, markRaw, toDisplayString, Fragment, onMounted, renderList, nextTick, useAttrs, h, createBlock, useTemplateRef, normalizeStyle, withCtx, computed, defineComponent } from "./3c3f971d069b.js";
+import "./a7e0eab4d4b0.js";
+import { IconClear, IconChevronDown } from "./314aa25cbb32.js";
+import { configContextKey } from "./650465d64194.js";
+import { useRenderComputed } from "./b843d2864038.js";
+import { Tag } from "./b691baed09ae.js";
+import { Popover } from "./013361e2e75c.js";
+import { CascaderNodeRenderer } from "./6399526924ef.js";
+import { CascaderPanel } from "./ac0c1340ae4d.js";
+import { TagInput } from "./02673229975a.js";
+import { Input } from "./116e4b06bf76.js";
+import { calcMergeType, getValueOrKey, convertDataToEntities, getKeyByValuePath } from "./c6e6b76fdc11.js";
+import { calcCheckedKeys, calcDisabledKeys, normalizeKeyList } from "./b4a7e548f2b7.js";
+import { strings } from "./29bb03a65f6e.js";
+import { CascaderFoundation } from "./3fa9dd4877a8.js";
+const _hoisted_1 = [
+    "id",
+    "aria-describedby",
+    "aria-disabled",
+    "aria-errormessage",
+    "aria-invalid",
+    "aria-label",
+    "aria-labelledby",
+    "aria-required",
+    "tabindex"
+];
+const _hoisted_2 = [
+    "id"
+];
+const _hoisted_3 = {
+    class: "semi-cascader-selection-n"
+};
+const _hoisted_4 = {
+    key: 1,
+    class: "semi-cascader-selection-n"
+};
+const _hoisted_5 = {
+    key: 3,
+    class: "semi-cascader-selection-placeholder"
+};
+const _hoisted_6 = {
+    key: 1,
+    class: "semi-cascader-suffix",
+    "x-semi-prop": "suffix"
+};
+const _hoisted_7 = {
+    key: 3,
+    class: "semi-cascader-arrow",
+    "x-semi-prop": "arrowIcon"
+};
+const Cascadervue_type_script_setup_true_lang_ts = /*@__PURE__*/ defineComponent({
+    name: 'Cascader',
+    inheritAttrs: false,
+    __name: 'Cascader',
+    props: {
+        ariaDescribedby: {},
+        ariaErrormessage: {},
+        ariaInvalid: {
+            type: [
+                Boolean,
+                String
+            ]
+        },
+        ariaLabel: {
+            default: 'Cascader'
+        },
+        ariaLabelledby: {},
+        ariaRequired: {
+            type: [
+                Boolean,
+                String
+            ]
+        },
+        arrowIcon: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        autoAdjustOverflow: {
+            type: Boolean,
+            default: true
+        },
+        autoClearSearchValue: {
+            type: Boolean,
+            default: true
+        },
+        autoMergeValue: {
+            type: Boolean,
+            default: true
+        },
+        borderless: {
+            type: Boolean,
+            default: false
+        },
+        bottomSlot: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        changeOnSelect: {
+            type: Boolean,
+            default: false
+        },
+        checkRelation: {
+            default: 'related'
+        },
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        className: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        clearIcon: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        clickToSelect: {
+            type: Boolean,
+            default: false
+        },
+        defaultOpen: {
+            type: Boolean,
+            default: false
+        },
+        defaultValue: {},
+        disabled: {
+            type: Boolean,
+            default: false
+        },
+        disableStrictly: {
+            type: Boolean,
+            default: false
+        },
+        displayProp: {
+            default: 'label'
+        },
+        displayRender: {},
+        dropdownClassName: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        dropdownMargin: {},
+        dropdownStyle: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        emptyContent: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        enableLeafClick: {
+            type: Boolean,
+            default: false
+        },
+        expandIcon: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        filterLeafOnly: {
+            type: Boolean,
+            default: true
+        },
+        filterRender: {},
+        filterSorter: {},
+        filterTreeNode: {
+            type: [
+                Boolean,
+                Function
+            ],
+            default: false
+        },
+        getPopupContainer: {},
+        id: {},
+        insetLabel: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        insetLabelId: {},
+        keyMaps: {
+            default: ()=>({})
+        },
+        leafOnly: {
+            type: Boolean,
+            default: false
+        },
+        loadData: {},
+        loadedKeys: {},
+        max: {},
+        maxTagCount: {},
+        modelValue: {},
+        motion: {
+            type: Boolean,
+            default: true
+        },
+        mouseEnterDelay: {},
+        mouseLeaveDelay: {},
+        multiple: {
+            type: Boolean,
+            default: false
+        },
+        onChangeWithObject: {
+            type: Boolean,
+            default: false
+        },
+        placeholder: {},
+        position: {},
+        prefix: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        preventScroll: {
+            type: Boolean
+        },
+        remote: {
+            type: Boolean,
+            default: false
+        },
+        restTagsPopoverProps: {
+            default: ()=>({})
+        },
+        searchPlaceholder: {},
+        searchPosition: {
+            default: 'trigger'
+        },
+        separator: {
+            default: ' / '
+        },
+        showClear: {
+            type: Boolean,
+            default: false
+        },
+        showNext: {
+            default: 'click'
+        },
+        showRestTagsPopover: {
+            type: Boolean,
+            default: false
+        },
+        size: {
+            default: 'default'
+        },
+        stopPropagation: {
+            type: [
+                Boolean,
+                String
+            ],
+            default: true
+        },
+        style: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        suffix: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        topSlot: {
+            type: [
+                Object,
+                String,
+                Number,
+                Boolean,
+                null,
+                Array
+            ]
+        },
+        treeData: {
+            default: ()=>[]
+        },
+        treeNodeFilterProp: {
+            default: 'label'
+        },
+        triggerRender: {},
+        validateStatus: {
+            default: 'default'
+        },
+        value: {},
+        virtualizeInSearch: {},
+        zIndex: {
+            default: 1030
+        }
+    },
+    emits: [
+        "blur",
+        "change",
+        "clear",
+        "exceed",
+        "focus",
+        "listScroll",
+        "load",
+        "search",
+        "select",
+        "visibleChange",
+        "update:modelValue",
+        "update:value"
+    ],
+    setup (__props, { expose: __expose, emit: __emit }) {
+        const props = __props;
+        const emit = __emit;
+        const attrs = useAttrs();
+        const slots = useSlots();
+        const instance = getCurrentInstance();
+        const triggerRef = useTemplateRef('trigger');
+        const popupRef = useTemplateRef('popup');
+        const inputRef = useTemplateRef('input');
+        const tagInputRef = useTemplateRef('tagInput');
+        const injectedConfig = inject(configContextKey, void 0);
+        const config = computed(()=>injectedConfig ? injectedConfig.value : {
+                direction: 'ltr',
+                locale: {
+                    code: 'zh-CN'
+                },
+                getPopupContainer: void 0
+            });
+        function hasRawProp(name) {
+            const raw = instance?.vnode.props;
+            const kebab = name.replace(/[A-Z]/g, (letter)=>`-${letter.toLowerCase()}`);
+            return Boolean(raw && (Object.prototype.hasOwnProperty.call(raw, name) || Object.prototype.hasOwnProperty.call(raw, kebab)));
+        }
+        function resolvedBoolean(name, fallback) {
+            return hasRawProp(String(name)) ? false !== props[name] : fallback;
+        }
+        const modelControlled = computed(()=>hasRawProp('modelValue'));
+        const valueControlled = computed(()=>hasRawProp('value'));
+        const controlled = computed(()=>modelControlled.value || valueControlled.value);
+        const incomingValue = computed(()=>modelControlled.value ? props.modelValue : valueControlled.value ? props.value : void 0);
+        const runtimeAutoAdjustOverflow = computed(()=>resolvedBoolean('autoAdjustOverflow', true));
+        const runtimeAutoMergeValue = computed(()=>resolvedBoolean('autoMergeValue', true));
+        const runtimeFilterLeafOnly = computed(()=>resolvedBoolean('filterLeafOnly', true));
+        const runtimeMotion = computed(()=>resolvedBoolean('motion', true));
+        const runtimeStopPropagation = computed(()=>resolvedBoolean('stopPropagation', true));
+        const keyMaps = computed(()=>props.keyMaps ?? {});
+        const keyDisabledName = computed(()=>keyMaps.value.disabled ?? 'disabled');
+        const mergeType = computed(()=>calcMergeType(runtimeAutoMergeValue.value, props.leafOnly));
+        const state = shallowReactive({
+            emptyContentMinWidth: null,
+            isOpen: false,
+            rePosKey: 0,
+            keyEntities: {},
+            selectedKeys: new Set(),
+            activeKeys: new Set(),
+            filteredKeys: new Set(),
+            inputValue: '',
+            isSearching: false,
+            inputPlaceHolder: props.searchPlaceholder ?? props.placeholder ?? '',
+            prevProps: {},
+            isHovering: false,
+            checkedKeys: new Set(),
+            halfCheckedKeys: new Set(),
+            resolvedCheckedKeys: new Set(),
+            loadedKeys: new Set(props.loadedKeys ?? []),
+            loadingKeys: new Set(),
+            loading: false,
+            treeData: props.treeData,
+            isFocus: false,
+            isInput: false,
+            disabledKeys: new Set(),
+            showInput: false
+        });
+        const cache = new Map();
+        const loadingKeysRef = shallowRef(new Set());
+        const loadedKeysRef = shallowRef(new Set(props.loadedKeys ?? []));
+        let clickOutsideHandler = null;
+        let mounted = false;
+        function normalizeValuePaths(value) {
+            if (null == value) return [];
+            let paths;
+            paths = Array.isArray(value) ? Array.isArray(value[0]) ? value : [
+                value
+            ] : [
+                [
+                    value
+                ]
+            ];
+            return paths.map((path)=>path.map((item)=>{
+                    if (props.onChangeWithObject && item && 'object' == typeof item) return getValueOrKey(item, keyMaps.value);
+                    return item;
+                })).filter((path)=>path.length > 0);
+        }
+        function valueKeys(value) {
+            return normalizeValuePaths(value).map((path)=>getKeyByValuePath(path)).filter((key)=>Boolean(state.keyEntities[key]));
+        }
+        function syncSingleValue(value) {
+            const keys = valueKeys(value);
+            const key = keys[0];
+            if (!key) {
+                state.selectedKeys = new Set();
+                state.activeKeys = new Set();
+                return;
+            }
+            const entity = state.keyEntities[key];
+            if (!entity) return;
+            const isLeaf = props.loadData ? Boolean(entity.data.isLeaf) : !entity.children?.length;
+            if (!props.changeOnSelect && !isLeaf) {
+                state.selectedKeys = new Set();
+                state.activeKeys = new Set(entity.path);
+                return;
+            }
+            state.selectedKeys = new Set([
+                key
+            ]);
+            state.activeKeys = new Set(entity.path);
+        }
+        function syncMultipleValue(value) {
+            const keys = valueKeys(value);
+            if ('related' === props.checkRelation) {
+                const result = calcCheckedKeys(keys, state.keyEntities);
+                state.checkedKeys = new Set(result.checkedKeys);
+                state.halfCheckedKeys = new Set(result.halfCheckedKeys);
+                const leafOnlyMerge = mergeType.value === strings.LEAF_ONLY_MERGE_TYPE;
+                state.resolvedCheckedKeys = new Set(normalizeKeyList([
+                    ...state.checkedKeys
+                ], state.keyEntities, leafOnlyMerge));
+            } else {
+                state.checkedKeys = new Set(keys);
+                state.halfCheckedKeys = new Set();
+                state.resolvedCheckedKeys = new Set(keys);
+            }
+        }
+        function rebuildData() {
+            state.treeData = props.treeData;
+            state.keyEntities = convertDataToEntities(props.treeData, keyMaps.value);
+            state.disabledKeys = props.disableStrictly && 'related' === props.checkRelation ? new Set(calcDisabledKeys(state.keyEntities, keyMaps.value)) : new Set();
+            const sourceValue = controlled.value ? incomingValue.value : props.defaultValue;
+            if (props.multiple) syncMultipleValue(sourceValue);
+            else syncSingleValue(sourceValue);
+            state.rePosKey += 1;
+        }
+        function getFoundationProps() {
+            const output = {
+                ...props,
+                autoMergeValue: runtimeAutoMergeValue.value,
+                filterLeafOnly: runtimeFilterLeafOnly.value,
+                keyMaps: keyMaps.value,
+                motion: runtimeMotion.value,
+                stopPropagation: runtimeStopPropagation.value,
+                value: incomingValue.value
+            };
+            if (!controlled.value) delete output.value;
+            return output;
+        }
+        const adapter = {
+            getContext: ()=>void 0,
+            getContexts: ()=>void 0,
+            getProp: (key)=>getFoundationProps()[key],
+            getProps: getFoundationProps,
+            getState: (key)=>state[key],
+            getStates: ()=>state,
+            setState: (nextState, callback)=>{
+                Object.assign(state, nextState);
+                callback?.();
+            },
+            getCache: (key)=>cache.get(key),
+            getCaches: ()=>cache,
+            setCache: (key, value)=>cache.set(key, value),
+            stopPropagation: (event)=>event?.stopPropagation?.(),
+            persistEvent: ()=>void 0,
+            updateInputValue: (value)=>{
+                state.inputValue = value;
+            },
+            updateInputPlaceHolder: (value)=>{
+                state.inputPlaceHolder = value;
+            },
+            focusInput: ()=>{
+                inputRef.value?.focus();
+                tagInputRef.value?.focus();
+            },
+            blurInput: ()=>{
+                inputRef.value?.blur();
+                tagInputRef.value?.blur();
+            },
+            registerClickOutsideHandler: (callback)=>{
+                adapter.unregisterClickOutsideHandler();
+                clickOutsideHandler = (event)=>{
+                    const target = event.target;
+                    if (!(target instanceof Node)) return;
+                    const path = event.composedPath?.() ?? [];
+                    const inTrigger = Boolean(triggerRef.value?.contains(target) || path.includes(triggerRef.value));
+                    const inPopup = Boolean(popupRef.value?.contains(target) || path.includes(popupRef.value));
+                    if (!inTrigger && !inPopup) callback(event);
+                };
+                document.addEventListener('mousedown', clickOutsideHandler, false);
+            },
+            unregisterClickOutsideHandler: ()=>{
+                if (!clickOutsideHandler || "u" < typeof document) return;
+                document.removeEventListener('mousedown', clickOutsideHandler, false);
+                clickOutsideHandler = null;
+            },
+            rePositionDropdown: ()=>{
+                state.rePosKey += 1;
+            },
+            updateStates: (nextState)=>Object.assign(state, nextState),
+            openMenu: ()=>{
+                if (state.isOpen) return;
+                state.isOpen = true;
+                emit('visibleChange', true);
+            },
+            closeMenu: (callback)=>{
+                if (!state.isOpen) return;
+                state.isOpen = false;
+                callback?.();
+                emit('visibleChange', false);
+            },
+            updateSelection: (selectedKeys)=>{
+                state.selectedKeys = selectedKeys;
+            },
+            notifyChange: (value)=>{
+                const output = value;
+                emit('change', output);
+                emit('update:value', output);
+                emit('update:modelValue', output);
+            },
+            notifySelect: (value)=>emit('select', value),
+            notifyOnSearch: (input)=>emit('search', input),
+            notifyFocus: (event)=>emit('focus', event),
+            notifyBlur: (event)=>emit('blur', event),
+            notifyDropdownVisibleChange: ()=>void 0,
+            toggleHovering: (hovering)=>{
+                state.isHovering = hovering;
+            },
+            notifyLoadData: (selectedOptions, callback)=>{
+                if (!props.loadData) return;
+                props.loadData(selectedOptions).then(()=>{
+                    setTimeout(()=>{
+                        callback();
+                        state.loading = false;
+                    });
+                });
+            },
+            notifyOnLoad: (loadedKeys, data)=>emit('load', loadedKeys, data),
+            notifyListScroll: (event, panel)=>emit('listScroll', event, panel),
+            notifyOnExceed: (data)=>emit('exceed', data),
+            notifyClear: ()=>emit('clear'),
+            toggleInputShow: (show, callback)=>{
+                state.showInput = show;
+                nextTick(callback);
+            },
+            updateFocusState: (focus)=>{
+                state.isFocus = focus;
+            },
+            updateLoadingKeyRefValue: (keys)=>{
+                loadingKeysRef.value = keys;
+            },
+            getLoadingKeyRefValue: ()=>loadingKeysRef.value,
+            updateLoadedKeyRefValue: (keys)=>{
+                loadedKeysRef.value = keys;
+            },
+            getLoadedKeyRefValue: ()=>loadedKeysRef.value,
+            setEmptyContentMinWidth: (width)=>{
+                state.emptyContentMinWidth = width;
+            },
+            getTriggerWidth: ()=>triggerRef.value?.getBoundingClientRect().width ?? 0
+        };
+        const foundation = markRaw(new CascaderFoundation(adapter));
+        const filterable = computed(()=>Boolean(props.filterTreeNode));
+        const triggerSearch = computed(()=>filterable.value && props.searchPosition === strings.SEARCH_POSITION_TRIGGER);
+        const renderData = computed(()=>foundation.getRenderData());
+        const popupStyle = computed(()=>[
+                0 === renderData.value.length && null != state.emptyContentMinWidth ? {
+                    minWidth: 'number' == typeof state.emptyContentMinWidth ? `${state.emptyContentMinWidth}px` : state.emptyContentMinWidth
+                } : void 0,
+                props.dropdownStyle
+            ]);
+        const displayKeys = computed(()=>{
+            if (!props.multiple) return [
+                ...state.selectedKeys
+            ];
+            if (mergeType.value === strings.NONE_MERGE_TYPE || props.checkRelation === strings.UN_RELATED) return [
+                ...state.checkedKeys
+            ];
+            return [
+                ...state.resolvedCheckedKeys
+            ];
+        });
+        const hasValue = computed(()=>displayKeys.value.length > 0);
+        const dataAttrs = computed(()=>Object.fromEntries(Object.entries(attrs).filter(([name])=>name.startsWith('data-'))));
+        const prefixContent = useRenderComputed(()=>slots.prefix?.() ?? (hasRawProp('prefix') ? props.prefix : void 0));
+        const insetLabelContent = computed(()=>hasRawProp('insetLabel') ? props.insetLabel : void 0);
+        const suffixContent = useRenderComputed(()=>slots.suffix?.() ?? (hasRawProp('suffix') ? props.suffix : void 0));
+        const arrowContent = useRenderComputed(()=>slots.arrowIcon?.() ?? (hasRawProp('arrowIcon') ? props.arrowIcon : void 0) ?? h(IconChevronDown));
+        const clearContent = useRenderComputed(()=>slots.clearIcon?.() ?? (hasRawProp('clearIcon') ? props.clearIcon : void 0) ?? h(IconClear));
+        const expandContent = useRenderComputed(()=>slots.expandIcon?.() ?? (hasRawProp('expandIcon') ? props.expandIcon : void 0));
+        const panelExpandContent = computed(()=>'boolean' == typeof expandContent.value ? null : expandContent.value);
+        const topContent = useRenderComputed(()=>slots.top?.() ?? (hasRawProp('topSlot') ? props.topSlot : void 0));
+        const bottomContent = useRenderComputed(()=>slots.bottom?.() ?? (hasRawProp('bottomSlot') ? props.bottomSlot : void 0));
+        const emptyContent = useRenderComputed(()=>{
+            if (slots.empty) return slots.empty();
+            if (hasRawProp('emptyContent')) return props.emptyContent;
+            const locale = config.value.locale.Cascader;
+            return locale?.emptyText ?? ('en-US' === config.value.locale.code ? 'No Data' : '暂无数据');
+        });
+        const panelEmptyContent = computed(()=>'boolean' == typeof emptyContent.value ? null : emptyContent.value);
+        const popupContainer = computed(()=>props.getPopupContainer ?? config.value.getPopupContainer);
+        const popoverOptionalProps = computed(()=>({
+                ...popupContainer.value ? {
+                    getPopupContainer: popupContainer.value
+                } : {},
+                ...void 0 !== props.dropdownMargin ? {
+                    margin: props.dropdownMargin
+                } : {},
+                ...void 0 !== props.mouseEnterDelay ? {
+                    mouseEnterDelay: props.mouseEnterDelay
+                } : {},
+                ...void 0 !== props.mouseLeaveDelay ? {
+                    mouseLeaveDelay: props.mouseLeaveDelay
+                } : {}
+            }));
+        const panelOptionalProps = computed(()=>({
+                ...void 0 !== panelExpandContent.value ? {
+                    expandIcon: panelExpandContent.value
+                } : {},
+                ...slots.filter || props.filterRender ? {
+                    filterRender: resolveFilterRender
+                } : {},
+                ...props.loadData ? {
+                    loadData: props.loadData
+                } : {},
+                ...props.virtualizeInSearch ? {
+                    virtualize: props.virtualizeInSearch
+                } : {}
+            }));
+        const tagInputOptionalProps = computed(()=>({
+                ...void 0 !== props.maxTagCount ? {
+                    maxTagCount: props.maxTagCount
+                } : {},
+                ...void 0 !== props.preventScroll ? {
+                    preventScroll: props.preventScroll
+                } : {}
+            }));
+        const triggerClasses = computed(()=>[
+                'semi-cascader',
+                props.class,
+                props.className,
+                attrs.class,
+                props.borderless ? 'semi-cascader-borderless' : void 0,
+                state.isFocus || state.isOpen && !state.isInput ? 'semi-cascader-focus' : void 0,
+                props.disabled ? 'semi-cascader-disabled' : void 0,
+                'semi-cascader-single',
+                filterable.value ? 'semi-cascader-filterable' : void 0,
+                'error' === props.validateStatus ? 'semi-cascader-error' : void 0,
+                'warning' === props.validateStatus ? 'semi-cascader-warning' : void 0,
+                'small' === props.size ? 'semi-cascader-small' : void 0,
+                'large' === props.size ? 'semi-cascader-large' : void 0,
+                prefixContent.value || insetLabelContent.value ? 'semi-cascader-with-prefix' : void 0,
+                suffixContent.value ? 'semi-cascader-with-suffix' : void 0
+            ]);
+        const showClearButton = computed(()=>props.showClear && (Boolean(state.inputValue) || hasValue.value) && !props.disabled && (state.isOpen || state.isHovering));
+        const singleDisplay = useRenderComputed(()=>{
+            const key = [
+                ...state.selectedKeys
+            ][0];
+            if (!key) return;
+            const path = foundation.getItemPropPath(key, props.displayProp);
+            const content = path.flatMap((item, index)=>index < path.length - 1 ? [
+                    item,
+                    props.separator
+                ] : [
+                    item
+                ]);
+            return slots.display?.({
+                selected: path
+            }) ?? props.displayRender?.(path) ?? content;
+        });
+        const searchDisplay = computed(()=>singleDisplay.value ?? state.inputPlaceHolder);
+        function entityTagContent(entity, index) {
+            return slots.display?.({
+                selected: entity,
+                index
+            }) ?? props.displayRender?.(entity, index) ?? entity.data[props.displayProp];
+        }
+        function renderTag(key, index) {
+            const entity = state.keyEntities[key];
+            if (!entity) return;
+            const disabled = props.disabled || Boolean(entity.data[keyDisabledName.value]) || props.disableStrictly && state.disabledKeys.has(key);
+            return h(Tag, {
+                key: `cascader-tag-${key}-${index}`,
+                className: [
+                    'semi-cascader-selection-tag',
+                    disabled ? 'semi-cascader-selection-tag-disabled' : void 0
+                ],
+                closable: true,
+                color: 'white',
+                size: 'default' === props.size ? 'large' : props.size,
+                tagKey: key,
+                onClose: (_content, event)=>{
+                    event.preventDefault();
+                    if (!disabled) foundation.handleTagRemoveByKey(key);
+                }
+            }, {
+                default: ()=>entityTagContent(entity, index)
+            });
+        }
+        const visibleTagNodes = computed(()=>{
+            const count = props.maxTagCount ?? 1 / 0;
+            return displayKeys.value.slice(0, count).map(renderTag);
+        });
+        const hiddenTagNodes = computed(()=>{
+            const count = props.maxTagCount ?? 1 / 0;
+            return displayKeys.value.slice(count).map((key, index)=>renderTag(key, index + count));
+        });
+        const triggerRenderProps = computed(()=>{
+            let value;
+            value = props.multiple ? new Set(displayKeys.value.map((key)=>state.keyEntities[key]?.pos).filter((position)=>Boolean(position))) : state.keyEntities[[
+                ...state.selectedKeys
+            ][0] ?? '']?.pos;
+            const output = {
+                componentProps: props,
+                disabled: props.disabled,
+                inputValue: state.inputValue,
+                placeholder: state.inputPlaceHolder,
+                onSearch: search,
+                onChange: search,
+                onClear: (event)=>handleClear(event),
+                onRemove: (position)=>foundation.handleTagRemoveInTrigger(position)
+            };
+            if (void 0 !== value) output.value = value;
+            return output;
+        });
+        const customTrigger = useRenderComputed(()=>slots.trigger?.(triggerRenderProps.value) ?? props.triggerRender?.(triggerRenderProps.value));
+        function resolveFilterRender(filterProps) {
+            return slots.filter?.(filterProps) ?? props.filterRender?.(filterProps);
+        }
+        function handleTriggerClick(event) {
+            foundation.handleClick(event);
+        }
+        function handleTriggerKeypress(event) {
+            foundation.handleSelectionEnterPress(event);
+        }
+        function handleKeydown(event) {
+            foundation.handleKeyDown(event);
+        }
+        function handleClear(event) {
+            event?.stopPropagation?.();
+            foundation.handleClear();
+        }
+        function handleClearKeypress(event) {
+            event.stopPropagation();
+            foundation.handleClearEnterPress(event);
+        }
+        function handlePopoverVisibleChange(visible) {
+            if (visible === state.isOpen) return;
+            if (visible) foundation.open();
+            else foundation.close();
+        }
+        function handleItemClick(event, item) {
+            foundation.handleItemClick(event, item);
+        }
+        function handleItemHover(event, item) {
+            foundation.handleItemHover(event, item);
+        }
+        function handleListScroll(event, panelIndex) {
+            foundation.handleListScroll(event, panelIndex);
+        }
+        function handleCheck(item) {
+            foundation.onItemCheckboxClick(item);
+        }
+        function search(value) {
+            if (!state.isOpen) foundation.open();
+            foundation.handleInputChange(value);
+        }
+        function open() {
+            foundation.open();
+        }
+        function close() {
+            foundation.close();
+        }
+        function focus() {
+            triggerRef.value?.focus({
+                preventScroll: props.preventScroll
+            });
+            foundation.focus();
+        }
+        function blur() {
+            triggerRef.value?.blur();
+            foundation.blur();
+        }
+        __expose({
+            open,
+            close,
+            focus,
+            blur,
+            search
+        });
+        watch(()=>[
+                props.treeData,
+                props.keyMaps,
+                props.multiple,
+                props.disableStrictly
+            ], ()=>{
+            rebuildData();
+            if (!mounted) return;
+            if (props.multiple) foundation.recalculateFilteredKeys();
+            else foundation.collectOptions();
+        }, {
+            deep: true,
+            immediate: true
+        });
+        watch(incomingValue, (value)=>{
+            if (!controlled.value) return;
+            if (props.multiple) syncMultipleValue(value);
+            else foundation.handleValueChange(value);
+        }, {
+            deep: true
+        });
+        watch(()=>[
+                props.checkRelation,
+                props.leafOnly,
+                runtimeAutoMergeValue.value
+            ], ()=>{
+            if (props.multiple) syncMultipleValue(controlled.value ? incomingValue.value : props.defaultValue);
+        });
+        watch(()=>props.loadedKeys, (keys)=>{
+            if (!hasRawProp('loadedKeys')) return;
+            loadedKeysRef.value = new Set(keys ?? []);
+            state.loadedKeys = new Set(keys ?? []);
+        }, {
+            deep: true
+        });
+        watch(()=>props.searchPlaceholder ?? props.placeholder, (placeholder)=>{
+            if (!hasValue.value) state.inputPlaceHolder = placeholder ?? '';
+        });
+        onMounted(()=>{
+            mounted = true;
+            foundation.init();
+        });
+        onBeforeUnmount(()=>foundation.destroy());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(Popover), mergeProps(popoverOptionalProps.value, {
+                "auto-adjust-overflow": runtimeAutoAdjustOverflow.value,
+                motion: runtimeMotion.value,
+                position: __props.position ?? ('rtl' === config.value.direction ? 'bottomRight' : 'bottomLeft'),
+                "re-pos-key": unref(state).rePosKey,
+                "stop-propagation": runtimeStopPropagation.value,
+                trigger: "custom",
+                visible: unref(state).isOpen,
+                "z-index": __props.zIndex,
+                onAfterClose: _cache[2] || (_cache[2] = ($event)=>unref(foundation).updateSearching(false)),
+                onVisibleChange: handlePopoverVisibleChange
+            }), {
+                content: withCtx(()=>[
+                        createElementVNode("div", {
+                            ref: "popup",
+                            role: "listbox",
+                            class: normalizeClass([
+                                'semi-cascader-popover',
+                                __props.dropdownClassName
+                            ]),
+                            style: normalizeStyle(popupStyle.value),
+                            onKeydown: handleKeydown
+                        }, [
+                            null != unref(topContent) ? (openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                                key: 0,
+                                content: unref(topContent)
+                            }, null, 8, [
+                                "content"
+                            ])) : createCommentVNode("", true),
+                            createVNode(CascaderPanel, mergeProps(panelOptionalProps.value, {
+                                "active-keys": unref(state).activeKeys,
+                                "checked-keys": unref(state).checkedKeys,
+                                data: renderData.value,
+                                direction: config.value.direction,
+                                "empty-content": panelEmptyContent.value,
+                                "half-checked-keys": unref(state).halfCheckedKeys,
+                                keyword: unref(state).inputValue,
+                                "loaded-keys": unref(state).loadedKeys,
+                                "loading-keys": unref(state).loadingKeys,
+                                multiple: __props.multiple,
+                                searchable: filterable.value && unref(state).isSearching,
+                                "selected-keys": unref(state).selectedKeys,
+                                separator: __props.separator,
+                                "show-next": __props.showNext,
+                                onCheck: handleCheck,
+                                onItemClick: handleItemClick,
+                                onItemHover: handleItemHover,
+                                onListScroll: handleListScroll
+                            }), null, 16, [
+                                "active-keys",
+                                "checked-keys",
+                                "data",
+                                "direction",
+                                "empty-content",
+                                "half-checked-keys",
+                                "keyword",
+                                "loaded-keys",
+                                "loading-keys",
+                                "multiple",
+                                "searchable",
+                                "selected-keys",
+                                "separator",
+                                "show-next"
+                            ]),
+                            null != unref(bottomContent) ? (openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                                key: 1,
+                                content: unref(bottomContent)
+                            }, null, 8, [
+                                "content"
+                            ])) : createCommentVNode("", true)
+                        ], 38)
+                    ]),
+                default: withCtx(()=>[
+                        null != unref(customTrigger) ? (openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                            key: 0,
+                            content: unref(customTrigger)
+                        }, null, 8, [
+                            "content"
+                        ])) : (openBlock(), createElementBlock("div", mergeProps({
+                            key: 1,
+                            id: __props.id,
+                            ref: "trigger"
+                        }, dataAttrs.value, {
+                            role: "combobox",
+                            "aria-describedby": __props.ariaDescribedby ?? unref(attrs)['aria-describedby'],
+                            "aria-disabled": __props.disabled,
+                            "aria-errormessage": __props.ariaErrormessage ?? unref(attrs)['aria-errormessage'],
+                            "aria-invalid": __props.ariaInvalid ?? unref(attrs)['aria-invalid'],
+                            "aria-label": __props.ariaLabel ?? unref(attrs)['aria-label'] ?? 'Cascader',
+                            "aria-labelledby": __props.ariaLabelledby ?? unref(attrs)['aria-labelledby'],
+                            "aria-required": __props.ariaRequired ?? unref(attrs)['aria-required'],
+                            class: triggerClasses.value,
+                            style: [
+                                __props.style,
+                                unref(attrs).style
+                            ],
+                            tabindex: __props.disabled ? void 0 : 0,
+                            onClick: handleTriggerClick,
+                            onKeydown: handleKeydown,
+                            onKeypress: handleTriggerKeypress,
+                            onMouseenter: _cache[0] || (_cache[0] = ($event)=>__props.showClear ? unref(foundation).toggleHoverState(true) : void 0),
+                            onMouseleave: _cache[1] || (_cache[1] = ($event)=>__props.showClear ? unref(foundation).toggleHoverState(false) : void 0)
+                        }), [
+                            null != unref(prefixContent) || null != insetLabelContent.value ? (openBlock(), createElementBlock("div", {
+                                key: 0,
+                                id: __props.insetLabelId,
+                                class: normalizeClass([
+                                    'semi-cascader-prefix',
+                                    null != insetLabelContent.value ? 'semi-cascader-inset-label' : void 0,
+                                    'string' == typeof (unref(prefixContent) ?? insetLabelContent.value) ? 'semi-cascader-prefix-text' : void 0
+                                ]),
+                                "x-semi-prop": "prefix,insetLabel"
+                            }, [
+                                createVNode(unref(CascaderNodeRenderer), {
+                                    content: unref(prefixContent) ?? insetLabelContent.value
+                                }, null, 8, [
+                                    "content"
+                                ])
+                            ], 10, _hoisted_2)) : createCommentVNode("", true),
+                            createElementVNode("div", {
+                                class: normalizeClass([
+                                    'semi-cascader-selection',
+                                    __props.multiple && hasValue.value ? 'semi-cascader-selection-multiple' : void 0
+                                ])
+                            }, [
+                                triggerSearch.value ? (openBlock(), createElementBlock(Fragment, {
+                                    key: 0
+                                }, [
+                                    __props.multiple ? (openBlock(), createBlock(unref(TagInput), mergeProps({
+                                        key: 0,
+                                        ref: "tagInput"
+                                    }, tagInputOptionalProps.value, {
+                                        "class-name": "semi-cascader-tagInput-wrapper",
+                                        disabled: __props.disabled,
+                                        "expand-rest-tags-on-click": false,
+                                        "input-value": unref(state).inputValue,
+                                        "model-value": displayKeys.value,
+                                        placeholder: unref(state).inputPlaceHolder,
+                                        "render-tag-item": renderTag,
+                                        "rest-tags-popover-props": __props.restTagsPopoverProps,
+                                        "show-rest-tags-popover": __props.showRestTagsPopover,
+                                        size: __props.size,
+                                        onInputChange: search,
+                                        onRemove: unref(foundation).handleTagRemoveByKey
+                                    }), null, 16, [
+                                        "disabled",
+                                        "input-value",
+                                        "model-value",
+                                        "placeholder",
+                                        "rest-tags-popover-props",
+                                        "show-rest-tags-popover",
+                                        "size",
+                                        "onRemove"
+                                    ])) : (openBlock(), createElementBlock("div", {
+                                        key: 1,
+                                        class: normalizeClass([
+                                            'semi-cascader-search-wrapper',
+                                            'default' !== __props.size ? `semi-cascader-search-wrapper-${__props.size}` : void 0
+                                        ])
+                                    }, [
+                                        createElementVNode("span", {
+                                            class: normalizeClass([
+                                                unref(singleDisplay) ? void 0 : 'semi-cascader-selection-placeholder',
+                                                unref(state).showInput && unref(state).inputValue ? 'semi-cascader-selection-text-hide' : void 0,
+                                                unref(state).showInput && !unref(state).inputValue ? 'semi-cascader-selection-text-inactive' : void 0
+                                            ])
+                                        }, [
+                                            '' !== searchDisplay.value ? (openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                                                key: 0,
+                                                content: searchDisplay.value
+                                            }, null, 8, [
+                                                "content"
+                                            ])) : createCommentVNode("", true)
+                                        ], 2),
+                                        unref(state).showInput ? (openBlock(), createBlock(unref(Input), {
+                                            key: 0,
+                                            ref: "input",
+                                            "class-name": "semi-cascader-input",
+                                            disabled: __props.disabled,
+                                            "model-value": unref(state).inputValue,
+                                            "prevent-scroll": __props.preventScroll,
+                                            size: __props.size,
+                                            onChange: search
+                                        }, null, 8, [
+                                            "disabled",
+                                            "model-value",
+                                            "prevent-scroll",
+                                            "size"
+                                        ])) : createCommentVNode("", true)
+                                    ], 2))
+                                ], 64)) : __props.multiple ? hasValue.value ? (openBlock(), createElementBlock(Fragment, {
+                                    key: 2
+                                }, [
+                                    (openBlock(true), createElementBlock(Fragment, null, renderList(visibleTagNodes.value, (tag, index)=>(openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                                            key: index,
+                                            content: tag
+                                        }, null, 8, [
+                                            "content"
+                                        ]))), 128)),
+                                    hiddenTagNodes.value.length && __props.showRestTagsPopover ? (openBlock(), createBlock(unref(Popover), mergeProps({
+                                        key: 0,
+                                        "auto-adjust-overflow": true,
+                                        content: hiddenTagNodes.value,
+                                        position: "top",
+                                        "show-arrow": true,
+                                        trigger: "hover"
+                                    }, __props.restTagsPopoverProps), {
+                                        default: withCtx(()=>[
+                                                createElementVNode("span", _hoisted_3, "+" + toDisplayString(hiddenTagNodes.value.length), 1)
+                                            ]),
+                                        _: 1
+                                    }, 16, [
+                                        "content"
+                                    ])) : hiddenTagNodes.value.length ? (openBlock(), createElementBlock("span", _hoisted_4, " +" + toDisplayString(hiddenTagNodes.value.length), 1)) : createCommentVNode("", true)
+                                ], 64)) : (openBlock(), createElementBlock("span", _hoisted_5, [
+                                    '' !== __props.placeholder ? (openBlock(), createElementBlock(Fragment, {
+                                        key: 0
+                                    }, [
+                                        createTextVNode(toDisplayString(__props.placeholder), 1)
+                                    ], 64)) : createCommentVNode("", true)
+                                ])) : (openBlock(), createElementBlock("span", {
+                                    key: 1,
+                                    class: normalizeClass(unref(singleDisplay) ? void 0 : 'semi-cascader-selection-placeholder')
+                                }, [
+                                    (unref(singleDisplay) ?? __props.placeholder) !== '' ? (openBlock(), createBlock(unref(CascaderNodeRenderer), {
+                                        key: 0,
+                                        content: unref(singleDisplay) ?? __props.placeholder
+                                    }, null, 8, [
+                                        "content"
+                                    ])) : createCommentVNode("", true)
+                                ], 2))
+                            ], 2),
+                            null != unref(suffixContent) ? (openBlock(), createElementBlock("div", _hoisted_6, [
+                                createVNode(unref(CascaderNodeRenderer), {
+                                    content: unref(suffixContent)
+                                }, null, 8, [
+                                    "content"
+                                ])
+                            ])) : createCommentVNode("", true),
+                            showClearButton.value ? (openBlock(), createElementBlock("div", {
+                                key: 2,
+                                role: "button",
+                                tabindex: "0",
+                                "aria-label": "Clear Cascader value",
+                                class: "semi-cascader-clearbtn",
+                                onClick: handleClear,
+                                onKeypress: handleClearKeypress
+                            }, [
+                                createVNode(unref(CascaderNodeRenderer), {
+                                    content: unref(clearContent)
+                                }, null, 8, [
+                                    "content"
+                                ])
+                            ], 32)) : null != unref(arrowContent) ? (openBlock(), createElementBlock("div", _hoisted_7, [
+                                createVNode(unref(CascaderNodeRenderer), {
+                                    content: unref(arrowContent)
+                                }, null, 8, [
+                                    "content"
+                                ])
+                            ])) : createCommentVNode("", true)
+                        ], 16, _hoisted_1))
+                    ]),
+                _: 1
+            }, 16, [
+                "auto-adjust-overflow",
+                "motion",
+                "position",
+                "re-pos-key",
+                "stop-propagation",
+                "visible",
+                "z-index"
+            ]));
+    }
+});
+export { Cascadervue_type_script_setup_true_lang_ts };