naive-ui 2.23.2 → 2.24.3

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;

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

@@ -21,24 +21,21 @@ declare const _default: import("vue").DefineComponent<{
     renderSuffix: import("vue").Ref<(({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined>;
     labelField: import("vue").Ref<string>;
     handleClick: (e: MouseEvent) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    disabled?: unknown;
-    checked?: unknown;
-    selected?: unknown;
-    onClick?: unknown;
-    onDragstart?: unknown;
-    tmNode?: unknown;
-} & {
-    disabled: boolean;
-    checked: boolean;
-    selected: boolean;
-    clsPrefix: string;
-    tmNode: TmNode;
-} & {
-    onDragstart?: ((e: DragEvent) => void) | undefined;
-    onClick?: ((e: MouseEvent) => 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;
+    };
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    selected: BooleanConstructor;
+    onClick: PropType<(e: MouseEvent) => void>;
+    onDragstart: PropType<(e: DragEvent) => void>;
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}>>, {
     disabled: boolean;
     checked: boolean;
     selected: boolean;

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

@@ -8,20 +8,16 @@ declare const _default: import("vue").DefineComponent<{
     hide: BooleanConstructor;
     loading: BooleanConstructor;
     onClick: PropType<(e: MouseEvent) => void>;
-}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    clsPrefix?: unknown;
-    expanded?: unknown;
-    hide?: unknown;
-    loading?: unknown;
-    onClick?: unknown;
-} & {
-    hide: boolean;
-    expanded: boolean;
-    loading: boolean;
-    clsPrefix: string;
-} & {
-    onClick?: ((e: MouseEvent) => void) | undefined;
-}>, {
+}, () => JSX.Element, 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;
+    };
+    expanded: BooleanConstructor;
+    hide: BooleanConstructor;
+    loading: BooleanConstructor;
+    onClick: PropType<(e: MouseEvent) => void>;
+}>>, {
     hide: boolean;
     expanded: boolean;
     loading: boolean;

package/es/tree/src/TreeNodeSwitcher.js

@@ -1,6 +1,7 @@
-import { h, defineComponent } from 'vue';
+import { h, defineComponent, inject } from 'vue';
 import { SwitcherIcon } from '../../_internal/icons';
 import { NIconSwitchTransition, NBaseLoading, NBaseIcon } from '../../_internal';
+import { treeInjectionKey } from './interface';
 export default defineComponent({
     name: 'NTreeSwitcher',
     props: {
@@ -13,18 +14,28 @@ export default defineComponent({
         loading: Boolean,
         onClick: Function
     },
-    render() {
-        const { clsPrefix } = this;
-        return (h("span", { "data-switcher": true, class: [
-                `${clsPrefix}-tree-node-switcher`,
-                {
-                    [`${clsPrefix}-tree-node-switcher--expanded`]: this.expanded,
-                    [`${clsPrefix}-tree-node-switcher--hide`]: this.hide
-                }
-            ], onClick: this.onClick },
-            h("div", { class: `${clsPrefix}-tree-node-switcher__icon` },
-                h(NIconSwitchTransition, null, {
-                    default: () => !this.loading ? (h(NBaseIcon, { clsPrefix: clsPrefix, key: "switcher" }, { default: () => h(SwitcherIcon, null) })) : (h(NBaseLoading, { clsPrefix: clsPrefix, key: "loading", radius: 85, strokeWidth: 20 }))
-                }))));
+    setup(props) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const { renderSwitcherIconRef } = inject(treeInjectionKey, null);
+        return () => {
+            const { clsPrefix } = props;
+            return (h("span", { "data-switcher": true, class: [
+                    `${clsPrefix}-tree-node-switcher`,
+                    {
+                        [`${clsPrefix}-tree-node-switcher--expanded`]: props.expanded,
+                        [`${clsPrefix}-tree-node-switcher--hide`]: props.hide
+                    }
+                ], onClick: props.onClick },
+                h("div", { class: `${clsPrefix}-tree-node-switcher__icon` },
+                    h(NIconSwitchTransition, null, {
+                        default: () => {
+                            if (props.loading) {
+                                return (h(NBaseLoading, { clsPrefix: clsPrefix, key: "loading", radius: 85, strokeWidth: 20 }));
+                            }
+                            const { value: renderSwitcherIcon } = renderSwitcherIconRef;
+                            return renderSwitcherIcon ? (renderSwitcherIcon()) : (h(NBaseIcon, { clsPrefix: clsPrefix, key: "switcher" }, { default: () => h(SwitcherIcon, null) }));
+                        }
+                    }))));
+        };
     }
 });

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

@@ -1,5 +1,5 @@
 import { CheckStrategy, TreeNode } from 'treemate';
-import { InjectionKey, Ref, VNodeChild } from 'vue';
+import { Ref, VNodeChild } from 'vue';
 import type { MergedTheme } from '../../_mixins';
 import type { TreeTheme } from '../styles';
 export declare type Key = string | number;
@@ -51,6 +51,7 @@ export interface InternalDropInfo {
     node: TmNode;
     dropPosition: DropPosition;
 }
+export declare type RenderSwitcherIcon = () => VNodeChild;
 export interface TreeInjection {
     loadingKeysRef: Ref<Set<Key>>;
     highlightKeySetRef: Ref<Set<Key>>;
@@ -81,6 +82,7 @@ export interface TreeInjection {
     renderLabelRef: Ref<RenderLabel | undefined>;
     renderPrefixRef: Ref<RenderPrefix | undefined>;
     renderSuffixRef: Ref<RenderSuffix | undefined>;
+    renderSwitcherIconRef: Ref<RenderSwitcherIcon | undefined>;
     labelFieldRef: Ref<string>;
     handleSwitcherClick: (node: TreeNode<TreeOption>) => void;
     handleSelect: (node: TreeNode<TreeOption>) => void;
@@ -92,7 +94,7 @@ export interface TreeInjection {
     handleDragOver: (info: InternalDragInfo) => void;
     handleDrop: (info: InternalDropInfo) => void;
 }
-export declare const treeInjectionKey: InjectionKey<TreeInjection>;
+export declare const treeInjectionKey: import("vue").InjectionKey<TreeInjection>;
 export declare type TmNode = TreeNode<TreeOption>;
 export interface MotionData {
     __motion: true;

package/es/tree/src/interface.js

@@ -1 +1,2 @@
-export const treeInjectionKey = Symbol('tree');
+import { createInjectionKey } from '../../_utils';
+export const treeInjectionKey = createInjectionKey('n-tree');

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

@@ -98,7 +98,9 @@ export default cB('tree', `
  align-items: center;
  justify-content: center;
  margin-right: 4px;
- `), cB('tree-node-content', `
+ `), cM('checkable', [cB('tree-node-content', `
+ padding: 0 6px;
+ `)]), cB('tree-node-content', `
  position: relative;
  display: inline-flex;
  align-items: center;
@@ -106,7 +108,7 @@ export default cB('tree', `
  box-sizing: border-box;
  line-height: 1.5;
  vertical-align: bottom;
- padding: 0 6px;
+ padding: 0 6px 0 4px;
  cursor: default;
  border-radius: var(--n-node-border-radius);
  text-decoration-color: #0000;