naive-ui 2.23.1 → 2.24.2

package/es/transfer/src/styles/index.cssr.js

@@ -30,7 +30,7 @@ const animation = c([c('@keyframes transfer-slide-in-from-left', `
  }
  `), c('@keyframes transfer-height-collapse', `
  0% {
- max-height: var(--item-height);
+ max-height: var(--n-item-height);
  }
  100% {
  max-height: 0;
@@ -40,21 +40,21 @@ const animation = c([c('@keyframes transfer-slide-in-from-left', `
  max-height: 0;
  }
  100% {
- max-height: var(--item-height);
+ max-height: var(--n-item-height);
  }
  `)]);
 export default c([cB('transfer', `
  display: flex;
- width: var(--width);
- font-size: var(--font-size);
+ width: var(--n-width);
+ font-size: var(--n-font-size);
  height: 240px;
  display: flex;
  flex-wrap: nowrap;
  `, [cB('transfer-icon', `
- color: var(--icon-color);
- transition: color .3s var(--bezier);
+ color: var(--n-icon-color);
+ transition: color .3s var(--n-bezier);
  `), cM('disabled', [cB('transfer-icon', {
-  color: 'var(--icon-color-disabled)'
+  color: 'var(--n-icon-color-disabled)'
 })]), cB('transfer-list', `
  height: inherit;
  display: flex;
@@ -62,12 +62,12 @@ export default c([cB('transfer', `
  background-clip: padding-box;
  width: calc(50% - 36px);
  position: relative;
- transition: background-color .3s var(--bezier);
- border-radius: var(--border-radius);
- background-color: var(--list-color);
+ transition: background-color .3s var(--n-bezier);
+ border-radius: var(--n-border-radius);
+ background-color: var(--n-list-color);
  `, [cE('border', `
- border: 1px solid var(--border-color);
- transition: border-color .3s var(--bezier);
+ border: 1px solid var(--n-border-color);
+ transition: border-color .3s var(--n-bezier);
  pointer-events: none;
  border-radius: inherit;
  position: absolute;
@@ -76,7 +76,7 @@ export default c([cB('transfer', `
  top: 0;
  bottom: 0;
  `), cB('transfer-list-header', `
- height: calc(var(--item-height) + 4px);
+ height: calc(var(--n-item-height) + 4px);
  box-sizing: border-box;
  display: flex;
  align-items: center;
@@ -84,10 +84,10 @@ export default c([cB('transfer', `
  border-radius: inherit;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
- background-color: var(--header-color);
+ background-color: var(--n-header-color);
  transition:
- border-color .3s var(--bezier),
- background-color .3s var(--bezier);
+ border-color .3s var(--n-bezier),
+ background-color .3s var(--n-bezier);
  `, [cE('checkbox', `
  display: flex;
  align-items: center;
@@ -96,18 +96,18 @@ export default c([cB('transfer', `
  `), cE('header', `
  flex: 1;
  line-height: 1;
- font-weight: var(--header-font-weight);
- transition: color .3s var(--bezier);
- color: var(--header-text-color);
+ font-weight: var(--n-header-font-weight);
+ transition: color .3s var(--n-bezier);
+ color: var(--n-header-text-color);
  `, [cM('disabled', {
-  color: 'var(--header-text-color-disabled)'
+  color: 'var(--n-header-text-color-disabled)'
 })]), cE('extra', `
- transition: color .3s var(--bezier);
- font-size: var(--extra-font-size);
+ transition: color .3s var(--n-bezier);
+ font-size: var(--n-extra-font-size);
  justify-self: flex-end;
  margin-right: 14px;
  white-space: nowrap;
- color: var(--header-extra-text-color);
+ color: var(--n-header-extra-text-color);
  `)]), cB('transfer-list-body', `
  flex-basis: 0;
  flex-grow: 1;
@@ -122,11 +122,11 @@ export default c([cB('transfer', `
  `, [cB('transfer-filter', `
  padding: 0 8px 8px 8px;
  box-sizing: border-box;
- background-color: var(--header-color);
+ background-color: var(--n-header-color);
  transition:
- border-color .3s var(--bezier),
- background-color .3s var(--bezier);
- border-bottom: 1px solid var(--filter-divider-color);
+ border-color .3s var(--n-bezier),
+ background-color .3s var(--n-bezier);
+ border-bottom: 1px solid var(--n-filter-divider-color);
  `), cB('transfer-list-flex-container', `
  flex: 1;
  position: relative;
@@ -151,18 +151,18 @@ export default c([cB('transfer', `
  `, [cM('transition-disabled', [cB('transfer-list-item', {
   animation: 'none !important'
 })]), cB('transfer-list-item', `
- height: var(--item-height);
- max-height: var(--item-height);
+ height: var(--n-item-height);
+ max-height: var(--n-item-height);
  transition:
- background-color .3s var(--bezier),
- color .3s var(--bezier);
+ background-color .3s var(--n-bezier),
+ color .3s var(--n-bezier);
  position: relative;
  cursor: pointer;
  display: flex;
  align-items: center;
- color: var(--item-text-color);
+ color: var(--n-item-text-color);
  `, [cNotM('disabled', [c('&:hover', {
-  backgroundColor: 'var(--item-color-pending)'
+  backgroundColor: 'var(--n-item-color-pending)'
 })]), cE('extra', `
  text-overflow: ellipsis;
  overflow: hidden;
@@ -176,19 +176,19 @@ export default c([cB('transfer', `
  `), cM('disabled', `
  cursor: not-allowed
  background-color: #0000;
- color: var(--item-text-color-disabled);
+ color: var(--n-item-text-color-disabled);
  `), cM('source', {
   animationFillMode: 'forwards'
 }, [c('&.item-enter-active', `
  transform: translateX(150%);
  animation-duration: .25s, .25s;
- animation-timing-function: var(--bezier), var(--bezier-ease-out);
+ animation-timing-function: var(--n-bezier), var(--n-bezier-ease-out);
  animation-delay: 0s, .25s;
  animation-name: transfer-height-expand, transfer-slide-in-from-right;
  `), c('&.item-leave-active', `
  transform: translateX(-150%);
  animation-duration: .25s, .25s;
- animation-timing-function: var(--bezier), var(--bezier-ease-in);
+ animation-timing-function: var(--n-bezier), var(--n-bezier-ease-in);
  animation-delay: .25s, 0s;
  animation-name: transfer-height-collapse, transfer-slide-out-to-right;
  `)]), cM('target', {
@@ -196,13 +196,13 @@ export default c([cB('transfer', `
 }, [c('&.item-enter-active', `
  transform: translateX(-150%);
  animation-duration: .25s, .25s;
- animation-timing-function: var(--bezier), var(--bezier-ease-out);
+ animation-timing-function: var(--n-bezier), var(--n-bezier-ease-out);
  animation-delay: 0s, .25s;
  animation-name: transfer-height-expand, transfer-slide-in-from-left;
  `), c('&.item-leave-active', `
  transform: translateX(150%);
  animation-duration: .25s, .25s;
- animation-timing-function: var(--bezier), var(--bezier-ease-in);
+ animation-timing-function: var(--n-bezier), var(--n-bezier-ease-in);
  animation-delay: .25s, 0s;
  animation-name: transfer-height-collapse, transfer-slide-out-to-left;
  `)])])])])])]), cB('transfer-gap', {

package/es/tree/src/MotionWrapper.d.ts

@@ -18,18 +18,23 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<() => void>;
         required: true;
     };
-}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    height?: unknown;
-    nodes?: unknown;
-    mode?: unknown;
-    onAfterEnter?: unknown;
-} & {
-    mode: "collapse" | "expand";
-    onAfterEnter: () => void;
-    clsPrefix: string;
-    nodes: TmNode[];
-} & {
-    height?: number | undefined;
-}>, {}>;
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    height: NumberConstructor;
+    nodes: {
+        type: PropType<TmNode[]>;
+        required: true;
+    };
+    mode: {
+        type: PropType<"collapse" | "expand">;
+        required: true;
+    };
+    onAfterEnter: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>>, {}>;
 export default _default;

package/es/tree/src/Tree.d.ts

@@ -1,7 +1,7 @@
 import { PropType } from 'vue';
 import { TreeMate, TreeMateOptions, CheckStrategy } from 'treemate';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import { TreeDragInfo, TreeDropInfo, TreeOptions, Key, TreeOption, AllowDrop } from './interface';
+import { TreeDragInfo, TreeDropInfo, TreeOptions, Key, TreeOption, AllowDrop, RenderSwitcherIcon } from './interface';
 import { defaultAllowDrop } from './dnd';
 export declare function createTreeMateOptions<T>(keyField: string, childrenField: string): TreeMateOptions<T, T, T>;
 declare type OnUpdateKeys = (value: Key[], option: Array<TreeOption | null>) => void;
@@ -133,6 +133,7 @@ declare const treeProps: {
     readonly renderLabel: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
     readonly renderPrefix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
     readonly renderSuffix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSwitcherIcon: PropType<RenderSwitcherIcon>;
     readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
@@ -381,6 +382,7 @@ declare const _default: import("vue").DefineComponent<{
     readonly renderLabel: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
     readonly renderPrefix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
     readonly renderSuffix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSwitcherIcon: PropType<RenderSwitcherIcon>;
     readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
@@ -947,11 +949,14 @@ declare const _default: import("vue").DefineComponent<{
         scrollTo: import("vueuc/lib/virtual-list/src/VirtualList").ScrollTo;
     } | null>;
     scrollbarInstRef: import("vue").Ref<{
-        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
-        sync: () => void;
         containerRef: HTMLElement | null;
         contentRef: HTMLElement | null;
         containerScrollTop: number;
+        syncUnifiedContainer: () => void;
+        scrollTo: import("../../_internal/scrollbar/src/ScrollBar").ScrollTo;
+        sync: () => void;
+        handleMouseEnterWrapper: () => void;
+        handleMouseLeaveWrapper: () => void;
     } | null>;
     handleFocusout: (e: FocusEvent) => void;
     handleDragLeaveTree: (e: DragEvent) => void;
@@ -973,111 +978,119 @@ declare const _default: import("vue").DefineComponent<{
         '--n-node-text-color-disabled': string;
         '--n-drop-mark-color': string;
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly internalScrollable?: unknown;
-    readonly internalScrollablePadding?: unknown;
-    readonly internalDataTreeMate?: unknown;
-    readonly internalDisplayTreeMate?: unknown;
-    readonly internalHighlightKeySet?: unknown;
-    readonly internalUnifySelectCheck?: unknown;
-    readonly internalHideFilteredNode?: unknown;
-    readonly internalCheckboxFocusable?: unknown;
-    readonly internalFocusable?: unknown;
-    readonly checkStrategy?: unknown;
-    readonly filter?: unknown;
-    readonly defaultExpandAll?: unknown;
-    readonly expandedKeys?: unknown;
-    readonly keyField?: unknown;
-    readonly labelField?: unknown;
-    readonly childrenField?: unknown;
-    readonly defaultExpandedKeys?: unknown;
-    readonly indeterminateKeys?: unknown;
-    readonly onUpdateIndeterminateKeys?: unknown;
-    readonly 'onUpdate:indeterminateKeys'?: unknown;
-    readonly onUpdateExpandedKeys?: unknown;
-    readonly 'onUpdate:expandedKeys'?: unknown;
-    readonly data?: unknown;
-    readonly expandOnDragenter?: unknown;
-    readonly cancelable?: unknown;
-    readonly checkable?: unknown;
-    readonly draggable?: unknown;
-    readonly blockNode?: unknown;
-    readonly blockLine?: unknown;
-    readonly disabled?: unknown;
-    readonly checkedKeys?: unknown;
-    readonly defaultCheckedKeys?: unknown;
-    readonly selectedKeys?: unknown;
-    readonly defaultSelectedKeys?: unknown;
-    readonly remote?: unknown;
-    readonly leafOnly?: unknown;
-    readonly multiple?: unknown;
-    readonly pattern?: unknown;
-    readonly onLoad?: unknown;
-    readonly cascade?: unknown;
-    readonly selectable?: unknown;
-    readonly indent?: unknown;
-    readonly allowDrop?: unknown;
-    readonly animated?: unknown;
-    readonly virtualScroll?: unknown;
-    readonly watchProps?: unknown;
-    readonly renderLabel?: unknown;
-    readonly renderPrefix?: unknown;
-    readonly renderSuffix?: unknown;
-    readonly onDragenter?: unknown;
-    readonly onDragleave?: unknown;
-    readonly onDragend?: unknown;
-    readonly onDragstart?: unknown;
-    readonly onDragover?: unknown;
-    readonly onDrop?: unknown;
-    readonly onUpdateCheckedKeys?: unknown;
-    readonly 'onUpdate:checkedKeys'?: unknown;
-    readonly onUpdateSelectedKeys?: unknown;
-    readonly 'onUpdate:selectedKeys'?: unknown;
-    readonly theme?: unknown;
-    readonly themeOverrides?: unknown;
-    readonly builtinThemeOverrides?: unknown;
-} & {
-    pattern: string;
-    data: TreeOptions;
-    multiple: boolean;
-    disabled: boolean;
-    draggable: boolean;
-    keyField: string;
-    virtualScroll: boolean;
-    checkable: boolean;
-    animated: boolean;
-    remote: boolean;
-    cascade: boolean;
-    indent: number;
-    labelField: string;
-    childrenField: string;
-    internalScrollable: boolean;
-    checkStrategy: CheckStrategy;
-    leafOnly: boolean;
-    defaultExpandedKeys: Key[];
-    defaultExpandAll: boolean;
-    cancelable: boolean;
-    blockLine: boolean;
-    selectable: boolean;
-    defaultCheckedKeys: Key[];
-    defaultSelectedKeys: Key[];
-    internalUnifySelectCheck: boolean;
-    internalHideFilteredNode: boolean;
-    internalCheckboxFocusable: boolean;
-    internalFocusable: boolean;
-    expandOnDragenter: boolean;
-    blockNode: boolean;
-    allowDrop: AllowDrop;
-} & {
-    filter?: ((pattern: string, node: TreeOption) => boolean) | undefined;
-    onDragend?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragenter?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragleave?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragover?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDragstart?: MaybeArray<(e: TreeDragInfo) => void> | undefined;
-    onDrop?: MaybeArray<(e: TreeDropInfo) => void> | undefined;
-    onLoad?: OnLoad | undefined;
-    theme?: import("../../_mixins").Theme<"Tree", {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly internalScrollable: BooleanConstructor;
+    readonly internalScrollablePadding: StringConstructor;
+    readonly internalDataTreeMate: PropType<TreeMate<TreeOption, TreeOption, TreeOption>>;
+    readonly internalDisplayTreeMate: PropType<TreeMate<TreeOption, TreeOption, TreeOption>>;
+    readonly internalHighlightKeySet: PropType<Set<Key>>;
+    readonly internalUnifySelectCheck: BooleanConstructor;
+    readonly internalHideFilteredNode: BooleanConstructor;
+    readonly internalCheckboxFocusable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly internalFocusable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly checkStrategy: {
+        readonly type: PropType<CheckStrategy>;
+        readonly default: "all";
+    };
+    readonly filter: PropType<(pattern: string, node: TreeOption) => boolean>;
+    readonly defaultExpandAll: BooleanConstructor;
+    readonly expandedKeys: PropType<Key[]>;
+    readonly keyField: {
+        readonly type: StringConstructor;
+        readonly default: "key";
+    };
+    readonly labelField: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly childrenField: {
+        readonly type: StringConstructor;
+        readonly default: "children";
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly indeterminateKeys: PropType<Key[]>;
+    readonly onUpdateIndeterminateKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:indeterminateKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly onUpdateExpandedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:expandedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly data: {
+        readonly type: PropType<TreeOptions>;
+        readonly default: () => never[];
+    };
+    readonly expandOnDragenter: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly cancelable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly checkable: BooleanConstructor;
+    readonly draggable: BooleanConstructor;
+    readonly blockNode: BooleanConstructor;
+    readonly blockLine: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly checkedKeys: PropType<Key[]>;
+    readonly defaultCheckedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly selectedKeys: PropType<Key[]>;
+    readonly defaultSelectedKeys: {
+        readonly type: PropType<Key[]>;
+        readonly default: () => never[];
+    };
+    readonly remote: BooleanConstructor;
+    readonly leafOnly: BooleanConstructor;
+    readonly multiple: BooleanConstructor;
+    readonly pattern: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onLoad: PropType<OnLoad>;
+    readonly cascade: BooleanConstructor;
+    readonly selectable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly indent: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly allowDrop: {
+        readonly type: PropType<AllowDrop>;
+        readonly default: typeof defaultAllowDrop;
+    };
+    readonly animated: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly virtualScroll: BooleanConstructor;
+    readonly watchProps: PropType<("defaultExpandedKeys" | "defaultCheckedKeys" | "defaultSelectedKeys")[]>;
+    readonly renderLabel: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderPrefix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSuffix: PropType<({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild>;
+    readonly renderSwitcherIcon: PropType<RenderSwitcherIcon>;
+    readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragstart: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDragover: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
+    readonly onDrop: PropType<MaybeArray<(e: TreeDropInfo) => void>>;
+    readonly onUpdateCheckedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:checkedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly onUpdateSelectedKeys: PropType<MaybeArray<OnUpdateKeys>>;
+    readonly 'onUpdate:selectedKeys': PropType<MaybeArray<OnUpdateKeys>>;
+    readonly theme: PropType<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1121,8 +1134,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }> | undefined;
-    themeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
+    }>>;
+    readonly themeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1166,8 +1179,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }>> | undefined;
-    builtinThemeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
+    }>>>;
+    readonly builtinThemeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Tree", {
         fontSize: string;
         nodeBorderRadius: string;
         nodeColorHover: string;
@@ -1211,28 +1224,8 @@ declare const _default: import("vue").DefineComponent<{
             color: string;
             colorHover: string;
         }, any>;
-    }>> | undefined;
-    renderLabel?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    checkedKeys?: Key[] | undefined;
-    expandedKeys?: Key[] | undefined;
-    watchProps?: ("defaultExpandedKeys" | "defaultCheckedKeys" | "defaultSelectedKeys")[] | undefined;
-    "onUpdate:expandedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    onUpdateExpandedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    renderPrefix?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    renderSuffix?: (({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined;
-    internalScrollablePadding?: string | undefined;
-    internalDataTreeMate?: TreeMate<TreeOption, TreeOption, TreeOption> | undefined;
-    internalDisplayTreeMate?: TreeMate<TreeOption, TreeOption, TreeOption> | undefined;
-    internalHighlightKeySet?: Set<Key> | undefined;
-    indeterminateKeys?: Key[] | undefined;
-    onUpdateIndeterminateKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:indeterminateKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    selectedKeys?: Key[] | undefined;
-    onUpdateCheckedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:checkedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-    onUpdateSelectedKeys?: MaybeArray<OnUpdateKeys> | undefined;
-    "onUpdate:selectedKeys"?: MaybeArray<OnUpdateKeys> | undefined;
-}>, {
+    }>>>;
+}>>, {
     pattern: string;
     data: TreeOptions;
     multiple: boolean;

package/es/tree/src/Tree.js

@@ -97,7 +97,7 @@ const treeProps = Object.assign(Object.assign(Object.assign(Object.assign({}, us
     }, animated: {
         type: Boolean,
         default: true
-    }, virtualScroll: Boolean, watchProps: Array, renderLabel: Function, renderPrefix: Function, renderSuffix: Function, onDragenter: [Function, Array], onDragleave: [Function, Array], onDragend: [Function, Array], onDragstart: [Function, Array], onDragover: [Function, Array], onDrop: [Function, Array], onUpdateCheckedKeys: [Function, Array], 'onUpdate:checkedKeys': [Function, Array], onUpdateSelectedKeys: [Function, Array], 'onUpdate:selectedKeys': [Function, Array] }), treeSharedProps), { 
+    }, virtualScroll: Boolean, watchProps: Array, renderLabel: Function, renderPrefix: Function, renderSuffix: Function, renderSwitcherIcon: Function, onDragenter: [Function, Array], onDragleave: [Function, Array], onDragend: [Function, Array], onDragstart: [Function, Array], onDragover: [Function, Array], onDrop: [Function, Array], onUpdateCheckedKeys: [Function, Array], 'onUpdate:checkedKeys': [Function, Array], onUpdateSelectedKeys: [Function, Array], 'onUpdate:selectedKeys': [Function, Array] }), treeSharedProps), { 
     // internal props for tree-select
     internalScrollable: Boolean, internalScrollablePadding: String, 
     // use it to do check
@@ -954,6 +954,7 @@ export default defineComponent({
             renderLabelRef: toRef(props, 'renderLabel'),
             renderPrefixRef: toRef(props, 'renderPrefix'),
             renderSuffixRef: toRef(props, 'renderSuffix'),
+            renderSwitcherIconRef: toRef(props, 'renderSwitcherIcon'),
             labelFieldRef: toRef(props, 'labelField'),
             handleSwitcherClick,
             handleDragEnd,
@@ -996,11 +997,12 @@ export default defineComponent({
             }) }, exposedMethods);
     },
     render() {
-        const { mergedClsPrefix, blockNode, blockLine, draggable, disabled, internalFocusable, handleKeyup, handleKeydown, handleFocusout } = this;
+        const { mergedClsPrefix, blockNode, blockLine, draggable, disabled, internalFocusable, checkable, handleKeyup, handleKeydown, handleFocusout } = this;
         const mergedFocusable = internalFocusable && !disabled;
         const tabindex = mergedFocusable ? '0' : undefined;
         const treeClass = [
             `${mergedClsPrefix}-tree`,
+            checkable && `${mergedClsPrefix}-tree--checkable`,
             (blockLine || blockNode) && `${mergedClsPrefix}-tree--block-node`,
             blockLine && `${mergedClsPrefix}-tree--block-line`
         ];

package/es/tree/src/TreeNode.d.ts

@@ -43,11 +43,14 @@ declare const TreeNode: import("vue").DefineComponent<{
     handleDragLeave: (e: DragEvent) => void;
     handleContentClick: (e: MouseEvent) => void;
     handleSwitcherClick: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    tmNode?: unknown;
-} & {
-    clsPrefix: string;
-    tmNode: TmNode;
-} & {}>, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}>>, {}>;
 export default TreeNode;

package/es/tree/src/TreeNodeCheckbox.d.ts

@@ -174,22 +174,17 @@ declare const _default: import("vue").DefineComponent<{
             } | undefined;
         };
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    focusable?: unknown;
-    disabled?: unknown;
-    checked?: unknown;
-    indeterminate?: unknown;
-    onCheck?: unknown;
-} & {
-    disabled: boolean;
-    checked: boolean;
-    focusable: boolean;
-    clsPrefix: string;
-    indeterminate: boolean;
-} & {
-    onCheck?: ((value: boolean) => void) | undefined;
-}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    focusable: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    indeterminate: BooleanConstructor;
+    onCheck: PropType<(value: boolean) => void>;
+}>>, {
     disabled: boolean;
     checked: boolean;
     focusable: boolean;