ele-admin-plus 1.3.1-beta.1 → 1.4.0

package/lib/ele-transfer/index.d.ts

@@ -0,0 +1,220 @@
+import { ElTransferInstance } from '../ele-app/el';
+import { TransferDataItem } from './types';
+
+declare function __VLS_template(): Partial<Record<string, (_: any) => any>>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    data: import('vue').PropType<TransferDataItem[] | import('./types').TransferDataFunction>;
+    titles: {
+        readonly type: import('vue').PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    buttonTexts: {
+        readonly type: import('vue').PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        readonly type: import('vue').PropType<(query: string, item: import('element-plus').TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    leftDefaultChecked: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    rightDefaultChecked: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    renderContent: {
+        readonly type: import('vue').PropType<import('element-plus').renderContent>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    format: {
+        readonly type: import('vue').PropType<import('element-plus').TransferFormat>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    filterable: BooleanConstructor;
+    props: {
+        readonly type: import('vue').PropType<import('element-plus').TransferPropsAlias>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {
+            label: "label";
+            key: "key";
+            disabled: "disabled";
+        };
+    };
+    targetOrder: {
+        readonly type: import('vue').PropType<"push" | "unshift" | "original">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "original";
+    };
+    validateEvent: {
+        readonly type: import('vue').PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+}>, {
+    reloadOptions: (params?: any) => void;
+    transferRef: import('vue').Ref<ElTransferInstance, ElTransferInstance>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('element-plus').TransferKey[]) => void;
+    change: (value: import('element-plus').TransferKey[], direction: import('element-plus').TransferDirection, movedKeys: import('element-plus').TransferKey[]) => void;
+    "left-check-change": (value: import('element-plus').TransferKey[], movedKeys?: import('element-plus').TransferKey[] | undefined) => void;
+    "right-check-change": (value: import('element-plus').TransferKey[], movedKeys?: import('element-plus').TransferKey[] | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: import('vue').PropType<TransferDataItem[] | import('./types').TransferDataFunction>;
+    titles: {
+        readonly type: import('vue').PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    buttonTexts: {
+        readonly type: import('vue').PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        readonly type: import('vue').PropType<(query: string, item: import('element-plus').TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    leftDefaultChecked: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    rightDefaultChecked: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    renderContent: {
+        readonly type: import('vue').PropType<import('element-plus').renderContent>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    format: {
+        readonly type: import('vue').PropType<import('element-plus').TransferFormat>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    filterable: BooleanConstructor;
+    props: {
+        readonly type: import('vue').PropType<import('element-plus').TransferPropsAlias>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {
+            label: "label";
+            key: "key";
+            disabled: "disabled";
+        };
+    };
+    targetOrder: {
+        readonly type: import('vue').PropType<"push" | "unshift" | "original">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "original";
+    };
+    validateEvent: {
+        readonly type: import('vue').PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('element-plus').TransferKey[]) => any) | undefined;
+    onChange?: ((value: import('element-plus').TransferKey[], direction: import('element-plus').TransferDirection, movedKeys: import('element-plus').TransferKey[]) => any) | undefined;
+    "onLeft-check-change"?: ((value: import('element-plus').TransferKey[], movedKeys?: import('element-plus').TransferKey[] | undefined) => any) | undefined;
+    "onRight-check-change"?: ((value: import('element-plus').TransferKey[], movedKeys?: import('element-plus').TransferKey[] | undefined) => any) | undefined;
+}>, {
+    modelValue: import('element-plus').TransferKey[];
+    filterable: boolean;
+    validateEvent: boolean;
+    props: import('element-plus').TransferPropsAlias;
+    format: import('element-plus').TransferFormat;
+    titles: [string, string];
+    buttonTexts: [string, string];
+    leftDefaultChecked: import('element-plus').TransferKey[];
+    rightDefaultChecked: import('element-plus').TransferKey[];
+    targetOrder: "push" | "unshift" | "original";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-transfer/props.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementPlus = require("element-plus");
+const transferProps = {
+  ...elementPlus.transferProps,
+  /** 数据 */
+  data: [Array, Function]
+};
+Object.defineProperty(exports, "transferEmits", {
+  enumerable: true,
+  get: () => elementPlus.transferEmits
+});
+exports.transferProps = transferProps;

package/lib/ele-transfer/props.d.ts

@@ -0,0 +1,102 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { TransferDataItem, TransferDataFunction } from './types';
+
+export { transferEmits } from 'element-plus';
+/**
+ * 属性
+ */
+export declare const transferProps: {
+    /** 数据 */
+    data: PropType<TransferDataItem[] | TransferDataFunction>;
+    titles: {
+        readonly type: PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    buttonTexts: {
+        readonly type: PropType<[string, string]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    filterPlaceholder: StringConstructor;
+    filterMethod: {
+        readonly type: PropType<(query: string, item: import('element-plus').TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    leftDefaultChecked: {
+        readonly type: PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    rightDefaultChecked: {
+        readonly type: PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    renderContent: {
+        readonly type: PropType<import('element-plus').renderContent>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: {
+        readonly type: PropType<import('element-plus').TransferKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => never[];
+    };
+    format: {
+        readonly type: PropType<import('element-plus').TransferFormat>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    filterable: BooleanConstructor;
+    props: {
+        readonly type: PropType<import('element-plus').TransferPropsAlias>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {
+            label: "label";
+            key: "key";
+            disabled: "disabled";
+        };
+    };
+    targetOrder: {
+        readonly type: PropType<"push" | "unshift" | "original">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "original";
+    };
+    validateEvent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+};
+export type TransferProps = ExtractPropTypes<typeof transferProps>;

package/lib/ele-transfer/style/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+require("element-plus/es/components/transfer/style/index");

package/lib/ele-transfer/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-transfer/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 数据
+ */
+export interface TransferDataItem extends Record<string, any> {
+  /** 值 */
+  key?: any;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+}
+
+/**
+ * 数据请求函数
+ */
+export type TransferDataFunction = () => Promise<TransferDataItem[]>;

package/lib/ele-tree-select/index.cjs

@@ -1,18 +1,26 @@
 "use strict";
 const vue = require("vue");
 const elementPlus = require("element-plus");
-const core = require("../utils/core");
+const common = require("../utils/common");
+const hook = require("../utils/hook");
 const EleBasicSelect = require("../ele-basic-select/index");
 const util = require("../ele-basic-select/util");
 const util$1 = require("./util");
 const props = require("./props");
-const _sfc_main = vue.defineComponent({
-  name: "EleTreeSelect",
-  components: { ElTreeV2: elementPlus.ElTreeV2, EleBasicSelect },
+const _hoisted_1 = ["title"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleTreeSelect" },
+  __name: "index",
   props: props.treeSelectProps,
   emits: props.treeSelectEmits,
-  setup(props2, { emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props2 = __props;
+    const emit = __emit;
     const { validateChange } = util.useFormValidate();
+    const { optionData, reloadOptions } = hook.useProOptions(
+      props2,
+      "treeProps.data"
+    );
     const selectRef = vue.ref(null);
     const treeRef = vue.ref(null);
     const selectVisible = vue.ref(false);
@@ -54,16 +62,16 @@ const _sfc_main = vue.defineComponent({
           return temp;
         }
       }
-      if (props2.treeProps && props2.treeProps.data) {
-        return core.findTree(
-          props2.treeProps.data,
+      if (optionData.value) {
+        return common.findTree(
+          optionData.value,
           (d) => d[valueKey] === value,
           treeOptions.value.children
         );
       }
     };
     const getMultipleSelected = (values) => {
-      var _a, _b, _c;
+      var _a;
       const valueKey = treeOptions.value.value;
       const labelKey = treeOptions.value.label;
       if (
@@ -71,7 +79,7 @@ const _sfc_main = vue.defineComponent({
         ((_a = props2.treeProps) == null ? void 0 : _a.checkStrictly) || props2.showCheckedStrategy === "all"
       ) {
         return util$1.getNormalSelectedItems(
-          (_b = props2.treeProps) == null ? void 0 : _b.data,
+          optionData.value,
           values,
           valueKey,
           labelKey,
@@ -82,7 +90,7 @@ const _sfc_main = vue.defineComponent({
       }
       return util$1.checkSelectedItems(
         util$1.getTreeSelectedItems(
-          (_c = props2.treeProps) == null ? void 0 : _c.data,
+          optionData.value,
           values,
           valueKey,
           labelKey,
@@ -265,10 +273,7 @@ const _sfc_main = vue.defineComponent({
       { deep: true }
     );
     vue.watch(
-      [() => props2.cacheData, () => {
-        var _a;
-        return (_a = props2.treeProps) == null ? void 0 : _a.data;
-      }],
+      [() => props2.cacheData, optionData],
       () => {
         if (!selectedItems.value.length) {
           return;
@@ -305,11 +310,7 @@ const _sfc_main = vue.defineComponent({
             const keys = treeRef.value && treeRef.value.getCheckedKeys() || [];
             selectedItems.value = getMultipleSelected(keys);
             updateModelValue(
-              util$1.getModelValue(
-                keys,
-                selectedItems.value,
-                props2.checkedValueStrategy
-              )
+              util$1.getModelValue(keys, selectedItems.value, props2.checkedValueStrategy)
             );
           }
         }
@@ -340,116 +341,103 @@ const _sfc_main = vue.defineComponent({
         updateSelectedItems(props2.modelValue);
       }
     });
-    return {
+    __expose({
+      reloadOptions,
       selectRef,
       treeRef,
-      selectVisible,
       selectedItems,
       selectedLabel,
-      selectPopperClass,
-      treeOptions,
       updatePopover,
-      treeFilter,
-      updateVisible,
-      updateSelectedItems,
-      handleSelectFilter,
-      handleSelectRemove,
-      handleSelectClear,
-      handleSelectFocus,
-      handleSelectBlur,
-      handleTreeClick,
-      handleTreeCheck,
-      handleTreeExpand,
-      handleTreeCollapse
-    };
-  }
-});
-const _export_sfc = (sfc, props2) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props2) {
-    target[key] = val;
-  }
-  return target;
-};
-const _hoisted_1 = ["title"];
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ElTreeV2 = vue.resolveComponent("ElTreeV2");
-  const _component_EleBasicSelect = vue.resolveComponent("EleBasicSelect");
-  return vue.openBlock(), vue.createBlock(_component_EleBasicSelect, {
-    ref: "selectRef",
-    value: _ctx.modelValue,
-    multiple: _ctx.multiple,
-    disabled: _ctx.disabled,
-    size: _ctx.size,
-    clearable: _ctx.clearable,
-    placeholder: _ctx.placeholder,
-    maxTagCount: _ctx.maxTagCount,
-    maxTagTextLength: _ctx.maxTagTextLength,
-    tagType: _ctx.tagType,
-    automaticDropdown: _ctx.automaticDropdown,
-    filterable: _ctx.filterable,
-    teleported: _ctx.teleported,
-    persistent: _ctx.persistent,
-    placement: _ctx.placement,
-    transition: _ctx.transition,
-    popperWidth: _ctx.popperWidth,
-    popperOptions: _ctx.popperOptions,
-    popperClass: _ctx.selectPopperClass,
-    selectStyle: _ctx.selectStyle,
-    inputStyle: _ctx.inputStyle,
-    selectTagsStyle: _ctx.selectTagsStyle,
-    selectedLabel: _ctx.selectedLabel,
-    selected: _ctx.selectedItems.filter((d) => !d.hide),
-    visible: _ctx.selectVisible,
-    "onUpdate:visible": _ctx.updateVisible,
-    onFilterChange: _ctx.handleSelectFilter,
-    onRemoveTag: _ctx.handleSelectRemove,
-    onClear: _ctx.handleSelectClear,
-    onFocus: _ctx.handleSelectFocus,
-    onBlur: _ctx.handleSelectBlur
-  }, vue.createSlots({
-    default: vue.withCtx(() => [
-      vue.createVNode(_component_ElTreeV2, vue.mergeProps({
-        itemSize: 32,
-        filterMethod: _ctx.treeFilter
-      }, _ctx.treeProps, {
-        ref: "treeRef",
-        props: _ctx.treeOptions,
-        highlightCurrent: _ctx.multiple ? false : true,
-        showCheckbox: !!_ctx.multiple,
-        checkOnClickNode: false,
-        defaultCheckedKeys: _ctx.multiple ? _ctx.modelValue : void 0,
-        onCheck: _ctx.handleTreeCheck,
-        onNodeClick: _ctx.handleTreeClick,
-        onNodeExpand: _ctx.handleTreeExpand,
-        onNodeCollapse: _ctx.handleTreeCollapse
-      }), {
-        default: vue.withCtx((slotProps) => [
-          vue.createElementVNode("span", {
-            class: vue.normalizeClass([
-              "el-tree-node__label",
-              { "is-disabled": slotProps.node.disabled }
+      updateVisible
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(EleBasicSelect, {
+        ref_key: "selectRef",
+        ref: selectRef,
+        value: _ctx.modelValue,
+        multiple: _ctx.multiple,
+        disabled: _ctx.disabled,
+        size: _ctx.size,
+        clearable: _ctx.clearable,
+        placeholder: _ctx.placeholder,
+        maxTagCount: _ctx.maxTagCount,
+        maxTagTextLength: _ctx.maxTagTextLength,
+        tagType: _ctx.tagType,
+        automaticDropdown: _ctx.automaticDropdown,
+        filterable: _ctx.filterable,
+        teleported: _ctx.teleported,
+        persistent: _ctx.persistent,
+        placement: _ctx.placement,
+        transition: _ctx.transition,
+        popperWidth: _ctx.popperWidth,
+        popperOptions: _ctx.popperOptions,
+        popperClass: selectPopperClass.value,
+        selectStyle: _ctx.selectStyle,
+        inputStyle: _ctx.inputStyle,
+        selectTagsStyle: _ctx.selectTagsStyle,
+        selectedLabel: selectedLabel.value,
+        selected: selectedItems.value.filter((d) => !d.hide),
+        visible: selectVisible.value,
+        "onUpdate:visible": updateVisible,
+        onFilterChange: handleSelectFilter,
+        onRemoveTag: handleSelectRemove,
+        onClear: handleSelectClear,
+        onFocus: handleSelectFocus,
+        onBlur: handleSelectBlur
+      }, vue.createSlots({
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(elementPlus.ElTreeV2), vue.mergeProps({
+            itemSize: 32,
+            filterMethod: treeFilter
+          }, vue.unref(common.omit)(_ctx.treeProps, ["data"]), {
+            ref_key: "treeRef",
+            ref: treeRef,
+            data: vue.unref(optionData),
+            props: treeOptions.value,
+            highlightCurrent: _ctx.multiple ? false : true,
+            showCheckbox: !!_ctx.multiple,
+            checkOnClickNode: false,
+            defaultCheckedKeys: _ctx.multiple ? _ctx.modelValue : void 0,
+            onCheck: handleTreeCheck,
+            onNodeClick: handleTreeClick,
+            onNodeExpand: handleTreeExpand,
+            onNodeCollapse: handleTreeCollapse
+          }), vue.createSlots({
+            default: vue.withCtx((slotProps) => [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass([
+                  "el-tree-node__label",
+                  { "is-disabled": slotProps.node.disabled }
+                ]),
+                title: slotProps.node.label
+              }, [
+                vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})), () => [
+                  vue.createTextVNode(vue.toDisplayString(slotProps.node.label), 1)
+                ])
+              ], 10, _hoisted_1)
             ]),
-            title: slotProps.node.label
+            _: 2
           }, [
-            vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})), () => [
-              vue.createTextVNode(vue.toDisplayString(slotProps.node.label), 1)
-            ])
-          ], 10, _hoisted_1)
+            _ctx.$slots.empty ? {
+              name: "empty",
+              fn: vue.withCtx((slotProps) => [
+                vue.renderSlot(_ctx.$slots, "empty", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1040, ["data", "props", "highlightCurrent", "showCheckbox", "defaultCheckedKeys"])
         ]),
-        _: 3
-      }, 16, ["filterMethod", "props", "highlightCurrent", "showCheckbox", "defaultCheckedKeys", "onCheck", "onNodeClick", "onNodeExpand", "onNodeCollapse"])
-    ]),
-    _: 2
-  }, [
-    _ctx.$slots.maxTagPlaceholder ? {
-      name: "maxTagPlaceholder",
-      fn: vue.withCtx((slotProps) => [
-        vue.renderSlot(_ctx.$slots, "maxTagPlaceholder", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
-      ]),
-      key: "0"
-    } : void 0
-  ]), 1032, ["value", "multiple", "disabled", "size", "clearable", "placeholder", "maxTagCount", "maxTagTextLength", "tagType", "automaticDropdown", "filterable", "teleported", "persistent", "placement", "transition", "popperWidth", "popperOptions", "popperClass", "selectStyle", "inputStyle", "selectTagsStyle", "selectedLabel", "selected", "visible", "onUpdate:visible", "onFilterChange", "onRemoveTag", "onClear", "onFocus", "onBlur"]);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = index;
+        _: 2
+      }, [
+        _ctx.$slots.maxTagPlaceholder ? {
+          name: "maxTagPlaceholder",
+          fn: vue.withCtx((slotProps) => [
+            vue.renderSlot(_ctx.$slots, "maxTagPlaceholder", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["value", "multiple", "disabled", "size", "clearable", "placeholder", "maxTagCount", "maxTagTextLength", "tagType", "automaticDropdown", "filterable", "teleported", "persistent", "placement", "transition", "popperWidth", "popperOptions", "popperClass", "selectStyle", "inputStyle", "selectTagsStyle", "selectedLabel", "selected", "visible"]);
+    };
+  }
+});
+module.exports = _sfc_main;