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

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

@@ -4,8 +4,22 @@ 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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
-    buttonTexts: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
+    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>;
@@ -13,26 +27,75 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    leftDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    rightDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
+    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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    format: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat) | ((new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat))[], unknown, unknown, () => {}, boolean>;
+    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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias) | ((new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias))[], unknown, unknown, () => import('element-plus/es/utils/typescript').Mutable<{
-        readonly label: "label";
-        readonly key: "key";
-        readonly disabled: "disabled";
-    }>, boolean>;
-    targetOrder: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;
-    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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: () => void;
+    reloadOptions: (params?: any) => void;
     transferRef: import('vue').Ref<ElTransferInstance, ElTransferInstance>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: import('element-plus').TransferKey[]) => void;
@@ -41,8 +104,22 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     "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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
-    buttonTexts: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
+    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>;
@@ -50,24 +127,73 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
-    leftDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    rightDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
+    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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    format: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat) | ((new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat))[], unknown, unknown, () => {}, boolean>;
+    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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias) | ((new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias))[], unknown, unknown, () => import('element-plus/es/utils/typescript').Mutable<{
-        readonly label: "label";
-        readonly key: "key";
-        readonly disabled: "disabled";
-    }>, boolean>;
-    targetOrder: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;
-    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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;
@@ -76,14 +202,14 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
 }>, {
     modelValue: import('element-plus').TransferKey[];
     filterable: boolean;
-    validateEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    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: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "push" | "unshift" | "original", unknown>;
+    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;

package/es/ele-transfer/index.js

@@ -1,8 +1,8 @@
-import { defineComponent, ref, openBlock, createBlock, unref, mergeProps, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { defineComponent, ref, createBlock, openBlock, unref, mergeProps, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
 import { ElTransfer } from "element-plus";
-import { omit } from "../utils/core";
+import { omit } from "../utils/common";
 import { useComponentEvents, useProOptions } from "../utils/hook";
-import { transferProps, transferEmits } from "./props";
+import { transferEmits, transferProps } from "./props";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{ name: "EleTransfer" },
   __name: "index",

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

@@ -8,32 +8,95 @@ export { transferEmits } from 'element-plus';
 export declare const transferProps: {
     /** 数据 */
     data: PropType<TransferDataItem[] | TransferDataFunction>;
-    titles: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
-    buttonTexts: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;
+    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: import('vue').PropType<(query: string, item: import('element-plus').TransferDataItem) => boolean>;
+        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[];
     };
-    leftDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    rightDefaultChecked: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
     renderContent: {
-        readonly type: import('vue').PropType<import('element-plus').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: () => {};
     };
-    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]) | ((new (...args: any[]) => import('element-plus').TransferKey[]) | (() => import('element-plus').TransferKey[]))[], unknown, unknown, () => never[], boolean>;
-    format: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat) | ((new (...args: any[]) => import('element-plus').TransferFormat) | (() => import('element-plus').TransferFormat))[], unknown, unknown, () => {}, boolean>;
     filterable: BooleanConstructor;
-    props: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias) | ((new (...args: any[]) => import('element-plus').TransferPropsAlias) | (() => import('element-plus').TransferPropsAlias))[], unknown, unknown, () => import('element-plus/es/utils/typescript').Mutable<{
-        readonly label: "label";
-        readonly key: "key";
-        readonly disabled: "disabled";
-    }>, boolean>;
-    targetOrder: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;
-    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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/es/ele-tree-select/index.d.ts

@@ -4,10 +4,8 @@ import { SelectValue, SingleValue, SelectedItem } from '../ele-basic-select/type
 
 declare function __VLS_template(): {
     default?(_: any): any;
-    maxTagPlaceholder?(_: {
-        omittedValues: SelectedItem[];
-        omittedSize: number;
-    }): any;
+    empty?(_: any): any;
+    maxTagPlaceholder?(_: any): any;
 };
 declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     modelValue: {
@@ -57,7 +55,7 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
     selectTagsStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
 }>, {
-    reloadOptions: () => void;
+    reloadOptions: (params?: any) => void;
     selectRef: import('vue').Ref<EleBasicSelectInstance, EleBasicSelectInstance>;
     treeRef: import('vue').Ref<ElTreeV2Instance, ElTreeV2Instance>;
     selectedItems: import('vue').Ref<{
@@ -74,77 +72,14 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     selectedLabel: import('vue').ComputedRef<string>;
     updatePopover: () => void;
     updateVisible: (visible: boolean) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    blur: (_e: FocusEvent) => void;
-    change: (_value: SelectValue) => void;
-    focus: (_e: FocusEvent) => void;
-    clear: () => void;
-    "update:modelValue": (_value: SelectValue) => void;
-    visibleChange: (_visible: boolean) => void;
-    removeTag: (_value: SingleValue) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    modelValue: {
-        type: import('vue').PropType<SelectValue>;
-        default: () => null;
-    };
-    multiple: BooleanConstructor;
-    disabled: BooleanConstructor;
-    size: import('vue').PropType<import('../ele-app/el').ElInputProps["size"]>;
-    clearable: BooleanConstructor;
-    placeholder: StringConstructor;
-    cacheData: import('vue').PropType<import('./types').TreeData>;
-    treeProps: {
-        type: import('vue').PropType<import('./types').TreeProps>;
-        required: boolean;
-    };
-    showCheckedStrategy: import('vue').PropType<import('./types').ShowCheckedStrategy>;
-    checkedValueStrategy: BooleanConstructor;
-    maxTagCount: NumberConstructor;
-    maxTagTextLength: NumberConstructor;
-    tagType: {
-        type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
-        default: string;
-    };
-    automaticDropdown: BooleanConstructor;
-    filterable: BooleanConstructor;
-    teleported: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    persistent: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    placement: {
-        type: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["placement"]>;
-        default: string;
-    };
-    transition: {
-        type: StringConstructor;
-        default: string;
-    };
-    popperOptions: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["popperOptions"]>;
-    popperClass: StringConstructor;
-    popperWidth: (StringConstructor | NumberConstructor)[];
-    selectStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
-    inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
-    selectTagsStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
-}>> & Readonly<{
-    onBlur?: ((_e: FocusEvent) => any) | undefined;
-    onChange?: ((_value: SelectValue) => any) | undefined;
-    onFocus?: ((_e: FocusEvent) => any) | undefined;
-    onClear?: (() => any) | undefined;
-    "onUpdate:modelValue"?: ((_value: SelectValue) => any) | undefined;
-    onVisibleChange?: ((_visible: boolean) => any) | undefined;
-    onRemoveTag?: ((_value: SingleValue) => any) | undefined;
-}>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, any, string, import('vue').PublicProps, any, {
     modelValue: SelectValue;
-    placement: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, import('element-plus').Placement, unknown> | undefined;
+    placement: import('element-plus').Placement | undefined;
     teleported: boolean;
     clearable: boolean;
     disabled: boolean;
     filterable: boolean;
-    tagType: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown> | undefined;
+    tagType: ("primary" | "success" | "warning" | "info" | "danger") | undefined;
     persistent: boolean;
     transition: string;
     automaticDropdown: boolean;

package/es/ele-tree-select/index.js

@@ -1,11 +1,11 @@
-import { defineComponent, ref, computed, watch, onMounted, openBlock, createBlock, createSlots, withCtx, createVNode, unref, mergeProps, createElementVNode, normalizeClass, renderSlot, normalizeProps, guardReactiveProps, createTextVNode, toDisplayString, nextTick } from "vue";
+import { defineComponent, ref, computed, watch, onMounted, createBlock, openBlock, createSlots, withCtx, createVNode, unref, mergeProps, createElementVNode, normalizeClass, renderSlot, normalizeProps, guardReactiveProps, createTextVNode, toDisplayString, nextTick } from "vue";
 import { ElTreeV2 } from "element-plus";
-import { omit, findTree } from "../utils/core";
+import { omit, findTree } from "../utils/common";
 import { useProOptions } from "../utils/hook";
 import EleBasicSelect from "../ele-basic-select/index";
 import { useFormValidate, isEmptyValue, valueIsChanged } from "../ele-basic-select/util";
 import { getModelValue, getNormalSelectedItems, checkSelectedItems, getTreeSelectedItems, isCheckAll } from "./util";
-import { treeSelectProps, treeSelectEmits } from "./props";
+import { treeSelectEmits, treeSelectProps } from "./props";
 const _hoisted_1 = ["title"];
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{ name: "EleTreeSelect" },
@@ -401,7 +401,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             onNodeClick: handleTreeClick,
             onNodeExpand: handleTreeExpand,
             onNodeCollapse: handleTreeCollapse
-          }), {
+          }), createSlots({
             default: withCtx((slotProps) => [
               createElementVNode("span", {
                 class: normalizeClass([
@@ -415,8 +415,16 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 ])
               ], 10, _hoisted_1)
             ]),
-            _: 3
-          }, 16, ["data", "props", "highlightCurrent", "showCheckbox", "defaultCheckedKeys"])
+            _: 2
+          }, [
+            _ctx.$slots.empty ? {
+              name: "empty",
+              fn: withCtx((slotProps) => [
+                renderSlot(_ctx.$slots, "empty", normalizeProps(guardReactiveProps(slotProps || {})))
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1040, ["data", "props", "highlightCurrent", "showCheckbox", "defaultCheckedKeys"])
         ]),
         _: 2
       }, [

package/es/ele-tree-select/util.js

@@ -1,4 +1,4 @@
-import { eachTree } from "../utils/core";
+import { eachTree } from "../utils/common";
 import { isEmptyValue } from "../ele-basic-select/util";
 function getKeysAndList(data, valueKey, childrenKey) {
   const keys = [];

package/es/ele-tree-table/components/table-body.js

@@ -1,4 +1,4 @@
-import { defineComponent, resolveComponent, openBlock, createElementBlock, Fragment, renderList, createBlock, withCtx, normalizeStyle, normalizeClass, renderSlot, createTextVNode, toDisplayString, createSlots, mergeProps, createCommentVNode } from "vue";
+import { defineComponent, resolveComponent, createElementBlock, openBlock, Fragment, renderList, createBlock, withCtx, createCommentVNode, createSlots, renderSlot, mergeProps, normalizeClass, normalizeStyle, createTextVNode, toDisplayString } from "vue";
 import TableRow from "./table-row";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{ name: "TableBody" },

package/es/ele-tree-table/components/table-row.js

@@ -1,6 +1,6 @@
-import { defineComponent, ref, openBlock, createElementBlock, normalizeClass, createElementVNode, normalizeStyle, toDisplayString, Fragment, renderList, createVNode, unref, withCtx, createCommentVNode, renderSlot } from "vue";
+import { defineComponent, ref, createElementBlock, openBlock, normalizeClass, createElementVNode, normalizeStyle, toDisplayString, renderSlot, Fragment, renderList, createCommentVNode, createVNode, unref, withCtx } from "vue";
 import { ElIcon } from "element-plus";
-import { ArrowDown } from "../../icons";
+import { ArrowDown } from "../../icons/index";
 const _hoisted_1 = { class: "ele-tree-table-row-body" };
 const _hoisted_2 = { class: "ele-tree-table-cells" };
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/es/ele-tree-table/index.js

@@ -1,4 +1,4 @@
-import { defineComponent, ref, watch, nextTick, onMounted, openBlock, createElementBlock, normalizeClass, createElementVNode, normalizeStyle, Fragment, renderList, renderSlot, createTextVNode, toDisplayString, createBlock, createSlots, withCtx, normalizeProps, guardReactiveProps } from "vue";
+import { defineComponent, ref, watch, nextTick, onMounted, createElementBlock, openBlock, normalizeClass, createElementVNode, normalizeStyle, createBlock, Fragment, renderList, renderSlot, createTextVNode, toDisplayString, createSlots, withCtx, normalizeProps, guardReactiveProps } from "vue";
 import TableBody from "./components/table-body";
 import { treeTableProps } from "./props";
 const _hoisted_1 = { class: "ele-tree-table-row" };

package/es/ele-tree-table/types.d.ts

@@ -5,7 +5,7 @@ import type { StyleValue } from '../ele-app/types';
  */
 export interface TreeTableDataItem extends Record<string, any> {
   /** key */
-  key: any;
+  key?: any;
   /** 子级 */
   children?: TreeTableDataItem[];
 }

package/es/ele-upload-list/components/list-item.d.ts

@@ -42,8 +42,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         required: true;
     };
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    retry: (_item: UploadItem) => void;
     remove: (_item: UploadItem) => void;
+    retry: (_item: UploadItem) => void;
     preview: (_item: UploadItem) => void;
     edit: (_item: UploadItem) => void;
     itemClick: (_item: UploadItem) => void;
@@ -75,8 +75,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         required: true;
     };
 }>> & Readonly<{
-    onRetry?: ((_item: UploadItem) => any) | undefined;
     onRemove?: ((_item: UploadItem) => any) | undefined;
+    onRetry?: ((_item: UploadItem) => any) | undefined;
     onPreview?: ((_item: UploadItem) => any) | undefined;
     onEdit?: ((_item: UploadItem) => any) | undefined;
     onItemClick?: ((_item: UploadItem) => any) | undefined;

package/es/ele-upload-list/components/list-item.js

@@ -1,6 +1,6 @@
-import { defineComponent, computed, openBlock, createElementBlock, renderSlot, createVNode, unref, withCtx, createElementVNode, toDisplayString, createBlock, mergeProps, withModifiers, createCommentVNode } from "vue";
+import { defineComponent, computed, createElementBlock, openBlock, renderSlot, createCommentVNode, createBlock, createVNode, createElementVNode, unref, withCtx, toDisplayString, mergeProps, withModifiers } from "vue";
 import { ElIcon, ElImage, ElProgress } from "element-plus";
-import { FileOutlined, SyncOutlined, EyeOutlined, EditOutlined, CloseOutlined } from "../../icons";
+import { FileOutlined, SyncOutlined, EyeOutlined, EditOutlined, CloseOutlined } from "../../icons/index";
 const _hoisted_1 = ["title"];
 const _hoisted_2 = {
   key: 0,

package/es/ele-upload-list/index.d.ts

@@ -2,6 +2,7 @@ import { UploadItem, UploadLocale } from './types';
 
 declare function __VLS_template(): Partial<Record<string, (_: any) => any>> & {
     icon?(_: {}): any;
+    extra?(_: {}): any;
 };
 declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     modelValue: import('vue').PropType<UploadItem[]>;
@@ -40,8 +41,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     openImagePreview: (urls: string[], index: number) => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (_value: UploadItem[]) => void;
-    itemClick: (_item: UploadItem) => void;
     remove: (_item: UploadItem) => void;
+    itemClick: (_item: UploadItem) => void;
     upload: (_item: UploadItem) => void;
     preview: (_item: UploadItem) => void;
     retry: (_item: UploadItem) => void;
@@ -81,8 +82,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     locale: import('vue').PropType<Partial<UploadLocale>>;
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((_value: UploadItem[]) => any) | undefined;
-    onItemClick?: ((_item: UploadItem) => any) | undefined;
     onRemove?: ((_item: UploadItem) => any) | undefined;
+    onItemClick?: ((_item: UploadItem) => any) | undefined;
     onUpload?: ((_item: UploadItem) => any) | undefined;
     onPreview?: ((_item: UploadItem) => any) | undefined;
     onRetry?: ((_item: UploadItem) => any) | undefined;