naive-ui 2.34.4 → 2.36.0

package/es/tree/src/Tree.js

@@ -12,7 +12,7 @@ import { h, ref, toRef, computed, defineComponent, provide, watch, nextTick, wat
 import { createTreeMate, flatten, createIndexGetter } from 'treemate';
 import { useMergedState } from 'vooks';
 import { VVirtualList } from 'vueuc';
-import { getPadding } from 'seemly';
+import { depx, getPadding, pxfy } from 'seemly';
 import { treeSelectInjectionKey } from '../../tree-select/src/interface';
 import { useConfig, useTheme, useThemeClass, useRtl } from '../../_mixins';
 import { call, createDataKey, resolveSlot, warn, warnOnce } from '../../_utils';
@@ -26,10 +26,6 @@ import { treeInjectionKey } from './interface';
 import MotionWrapper from './MotionWrapper';
 import { defaultAllowDrop } from './dnd';
 import style from './styles/index.cssr';
-// TODO:
-// During expanding, some node are mis-applied with :active style
-// Async dnd has bug
-const ITEM_SIZE = 30; // 24 + 3 + 3
 export function createTreeMateOptions(keyField, childrenField, disabledField, getChildren) {
     const settledGetChildren = getChildren ||
         ((node) => {
@@ -92,7 +88,7 @@ export const treeProps = Object.assign(Object.assign(Object.assign(Object.assign
     }, cancelable: {
         type: Boolean,
         default: true
-    }, checkable: Boolean, draggable: Boolean, blockNode: Boolean, blockLine: Boolean, disabled: Boolean, checkedKeys: Array, defaultCheckedKeys: {
+    }, checkable: Boolean, draggable: Boolean, blockNode: Boolean, blockLine: Boolean, showLine: Boolean, disabled: Boolean, checkedKeys: Array, defaultCheckedKeys: {
         type: Array,
         default: () => []
     }, selectedKeys: Array, defaultSelectedKeys: {
@@ -104,9 +100,9 @@ export const treeProps = Object.assign(Object.assign(Object.assign(Object.assign
     }, onLoad: Function, cascade: Boolean, selectable: {
         type: Boolean,
         default: true
-    }, indent: {
+    }, scrollbarProps: Object, indent: {
         type: Number,
-        default: 16
+        default: 24
     }, allowDrop: {
         type: Function,
         default: defaultAllowDrop
@@ -254,11 +250,15 @@ export default defineComponent({
         };
         if (watchProps === null || watchProps === void 0 ? void 0 : watchProps.includes('defaultExpandedKeys')) {
             // if watching defaultExpandedKeys, we use access props.defaultExpandedKeys inside initiator
-            watchEffect(() => { initUncontrolledExpandedKeys(undefined); });
+            watchEffect(() => {
+                initUncontrolledExpandedKeys(undefined);
+            });
         }
         else {
             // We by default watchEffect since if defaultExpandAll is true, we should remain tree expand if data changes
-            watchEffect(() => { initUncontrolledExpandedKeys(props.defaultExpandedKeys); });
+            watchEffect(() => {
+                initUncontrolledExpandedKeys(props.defaultExpandedKeys);
+            });
         }
         const controlledExpandedKeysRef = toRef(props, 'expandedKeys');
         const mergedExpandedKeysRef = useMergedState(controlledExpandedKeysRef, uncontrolledExpandedKeysRef);
@@ -404,6 +404,7 @@ export default defineComponent({
                 void nextTick(syncScrollbar);
                 return;
             }
+            const nodeHeight = depx(themeRef.value.self.nodeHeight);
             const prevVSet = new Set(prevValue);
             let addedKey = null;
             let removedKey = null;
@@ -429,7 +430,7 @@ export default defineComponent({
             }
             const { virtualScroll } = props;
             const viewportHeight = (virtualScroll ? virtualListInstRef.value.listElRef : selfElRef.value).offsetHeight;
-            const viewportItemCount = Math.ceil(viewportHeight / ITEM_SIZE) + 1;
+            const viewportItemCount = Math.ceil(viewportHeight / nodeHeight) + 1;
             // play add animation
             let baseExpandedKeys;
             if (addedKey !== null) {
@@ -458,7 +459,7 @@ export default defineComponent({
                             __motion: true,
                             mode: 'expand',
                             height: virtualScroll
-                                ? expandedChildren.length * ITEM_SIZE
+                                ? expandedChildren.length * nodeHeight
                                 : undefined,
                             nodes: virtualScroll
                                 ? expandedChildren.slice(0, viewportItemCount)
@@ -482,7 +483,7 @@ export default defineComponent({
                         __motion: true,
                         mode: 'collapse',
                         height: virtualScroll
-                            ? collapsedChildren.length * ITEM_SIZE
+                            ? collapsedChildren.length * nodeHeight
                             : undefined,
                         nodes: virtualScroll
                             ? collapsedChildren.slice(0, viewportItemCount)
@@ -1122,6 +1123,7 @@ export default defineComponent({
             droppingOffsetLevelRef,
             fNodesRef,
             pendingNodeKeyRef,
+            showLineRef: toRef(props, 'showLine'),
             disabledFieldRef: toRef(props, 'disabledField'),
             internalScrollableRef: toRef(props, 'internalScrollable'),
             internalCheckboxFocusableRef: toRef(props, 'internalCheckboxFocusable'),
@@ -1169,7 +1171,10 @@ export default defineComponent({
             }
         };
         const cssVarsRef = computed(() => {
-            const { common: { cubicBezierEaseInOut }, self: { fontSize, nodeBorderRadius, nodeColorHover, nodeColorPressed, nodeColorActive, arrowColor, loadingColor, nodeTextColor, nodeTextColorDisabled, dropMarkColor } } = themeRef.value;
+            const { common: { cubicBezierEaseInOut }, self: { fontSize, nodeBorderRadius, nodeColorHover, nodeColorPressed, nodeColorActive, arrowColor, loadingColor, nodeTextColor, nodeTextColorDisabled, dropMarkColor, nodeWrapperPadding, nodeHeight, lineHeight, lineColor } } = themeRef.value;
+            const lineOffsetTop = getPadding(nodeWrapperPadding, 'top');
+            const lineOffsetBottom = getPadding(nodeWrapperPadding, 'bottom');
+            const nodeContentHeight = pxfy(depx(nodeHeight) - depx(lineOffsetTop) - depx(lineOffsetBottom));
             return {
                 '--n-arrow-color': arrowColor,
                 '--n-loading-color': loadingColor,
@@ -1181,7 +1186,13 @@ export default defineComponent({
                 '--n-node-color-pressed': nodeColorPressed,
                 '--n-node-text-color': nodeTextColor,
                 '--n-node-text-color-disabled': nodeTextColorDisabled,
-                '--n-drop-mark-color': dropMarkColor
+                '--n-drop-mark-color': dropMarkColor,
+                '--n-node-wrapper-padding': nodeWrapperPadding,
+                '--n-line-offset-top': `-${lineOffsetTop}`,
+                '--n-line-offset-bottom': `-${lineOffsetBottom}`,
+                '--n-node-content-height': nodeContentHeight,
+                '--n-line-height': lineHeight,
+                '--n-line-color': lineColor
             };
         });
         const themeClassHandle = inlineThemeDisabled
@@ -1204,7 +1215,7 @@ export default defineComponent({
         if (!fNodes.length && internalRenderEmpty) {
             return internalRenderEmpty();
         }
-        const { mergedClsPrefix, blockNode, blockLine, draggable, disabled, internalFocusable, checkable, handleKeydown, rtlEnabled, handleFocusout } = this;
+        const { mergedClsPrefix, blockNode, blockLine, draggable, disabled, internalFocusable, checkable, handleKeydown, rtlEnabled, handleFocusout, scrollbarProps } = this;
         const mergedFocusable = internalFocusable && !disabled;
         const tabindex = mergedFocusable ? '0' : undefined;
         const treeClass = [
@@ -1220,11 +1231,13 @@ export default defineComponent({
         if (this.virtualScroll) {
             const { mergedTheme, internalScrollablePadding } = this;
             const padding = getPadding(internalScrollablePadding || '0');
-            return (h(NxScrollbar, { ref: "scrollbarInstRef", onDragleave: draggable ? this.handleDragLeaveTree : undefined, container: this.getScrollContainer, content: this.getScrollContent, class: treeClass, theme: mergedTheme.peers.Scrollbar, themeOverrides: mergedTheme.peerOverrides.Scrollbar, tabindex: tabindex, onKeydown: mergedFocusable ? handleKeydown : undefined, onFocusout: mergedFocusable ? handleFocusout : undefined }, {
+            return (h(NxScrollbar, Object.assign({}, scrollbarProps, { ref: "scrollbarInstRef", onDragleave: draggable ? this.handleDragLeaveTree : undefined, container: this.getScrollContainer, content: this.getScrollContent, class: treeClass, theme: mergedTheme.peers.Scrollbar, themeOverrides: mergedTheme.peerOverrides.Scrollbar, tabindex: tabindex, onKeydown: mergedFocusable ? handleKeydown : undefined, onFocusout: mergedFocusable ? handleFocusout : undefined }), {
                 default: () => {
                     var _a;
                     (_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
-                    return (h(VVirtualList, { ref: "virtualListInstRef", items: this.fNodes, itemSize: ITEM_SIZE, ignoreItemResize: this.aip, paddingTop: padding.top, paddingBottom: padding.bottom, class: this.themeClass, style: [
+                    return !fNodes.length ? (resolveSlot(this.$slots.empty, () => [
+                        h(NEmpty, { class: `${mergedClsPrefix}-tree__empty`, theme: this.mergedTheme.peers.Empty, themeOverrides: this.mergedTheme.peerOverrides.Empty })
+                    ])) : (h(VVirtualList, { ref: "virtualListInstRef", items: this.fNodes, itemSize: depx(mergedTheme.self.nodeHeight), ignoreItemResize: this.aip, paddingTop: padding.top, paddingBottom: padding.bottom, class: this.themeClass, style: [
                             this.cssVars,
                             {
                                 paddingLeft: padding.left,
@@ -1240,7 +1253,7 @@ export default defineComponent({
         treeClass.push(this.themeClass);
         (_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
         if (internalScrollable) {
-            return (h(NxScrollbar, { class: treeClass, tabindex: tabindex, onKeydown: mergedFocusable ? handleKeydown : undefined, onFocusout: mergedFocusable ? handleFocusout : undefined, style: this.cssVars, contentStyle: { padding: this.internalScrollablePadding } }, {
+            return (h(NxScrollbar, Object.assign({}, scrollbarProps, { class: treeClass, tabindex: tabindex, onKeydown: mergedFocusable ? handleKeydown : undefined, onFocusout: mergedFocusable ? handleFocusout : undefined, style: this.cssVars, contentStyle: { padding: this.internalScrollablePadding } }), {
                 default: () => (h("div", { onDragleave: draggable ? this.handleDragLeaveTree : undefined, ref: "selfElRef" }, this.fNodes.map(createNode)))
             }));
         }

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

@@ -1,4 +1,4 @@
-import { type PropType, type ComponentPublicInstance } from 'vue';
+import { type PropType, type ComponentPublicInstance, type VNode } from 'vue';
 import { type TmNode } from './interface';
 declare const TreeNode: import("vue").DefineComponent<{
     clsPrefix: {
@@ -34,10 +34,14 @@ declare const TreeNode: import("vue").DefineComponent<{
     droppingOffsetLevel: import("vue").Ref<number>;
     indent: import("vue").Ref<number>;
     checkboxPlacement: "left" | "right";
+    showLine: import("vue").Ref<boolean>;
     contentInstRef: import("vue").Ref<ComponentPublicInstance | null>;
     contentElRef: {
         value: HTMLElement | null;
     };
+    indentNodes: import("vue").ComputedRef<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[]>;
     handleCheck: (checked: boolean) => void;
     handleDrop: (e: DragEvent) => void;
     handleDragStart: (e: DragEvent) => void;
@@ -57,5 +61,5 @@ declare const TreeNode: import("vue").DefineComponent<{
         type: PropType<TmNode>;
         required: true;
     };
-}>>, {}>;
+}>>, {}, {}>;
 export default TreeNode;

package/es/tree/src/TreeNode.js

@@ -23,7 +23,7 @@ const TreeNode = defineComponent({
     setup(props) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const NTree = inject(treeInjectionKey);
-        const { droppingNodeParentRef, droppingMouseNodeRef, draggingNodeRef, droppingPositionRef, droppingOffsetLevelRef, nodePropsRef, indentRef, blockLineRef, checkboxPlacementRef, checkOnClickRef, disabledFieldRef } = NTree;
+        const { droppingNodeParentRef, droppingMouseNodeRef, draggingNodeRef, droppingPositionRef, droppingOffsetLevelRef, nodePropsRef, indentRef, blockLineRef, checkboxPlacementRef, checkOnClickRef, disabledFieldRef, showLineRef, renderSwitcherIconRef } = NTree;
         const checkboxDisabledRef = useMemo(() => !!props.tmNode.rawNode.checkboxDisabled);
         const nodeIsDisabledRef = useMemo(() => {
             return isNodeDisabled(props.tmNode, disabledFieldRef.value);
@@ -44,29 +44,40 @@ const TreeNode = defineComponent({
             contentElRef.value = contentInstRef.value.$el;
         });
         function handleSwitcherClick() {
-            const { tmNode } = props;
-            if (!tmNode.isLeaf && !tmNode.shallowLoaded) {
-                if (!NTree.loadingKeysRef.value.has(tmNode.key)) {
-                    NTree.loadingKeysRef.value.add(tmNode.key);
+            const callback = () => {
+                const { tmNode } = props;
+                if (!tmNode.isLeaf && !tmNode.shallowLoaded) {
+                    if (!NTree.loadingKeysRef.value.has(tmNode.key)) {
+                        NTree.loadingKeysRef.value.add(tmNode.key);
+                    }
+                    else {
+                        return;
+                    }
+                    const { onLoadRef: { value: onLoad } } = NTree;
+                    if (onLoad) {
+                        void onLoad(tmNode.rawNode)
+                            .then((value) => {
+                            if (value !== false) {
+                                NTree.handleSwitcherClick(tmNode);
+                            }
+                        })
+                            .finally(() => {
+                            NTree.loadingKeysRef.value.delete(tmNode.key);
+                        });
+                    }
                 }
                 else {
-                    return;
-                }
-                const { onLoadRef: { value: onLoad } } = NTree;
-                if (onLoad) {
-                    void onLoad(tmNode.rawNode)
-                        .then((value) => {
-                        if (value !== false) {
-                            NTree.handleSwitcherClick(tmNode);
-                        }
-                    })
-                        .finally(() => {
-                        NTree.loadingKeysRef.value.delete(tmNode.key);
-                    });
+                    NTree.handleSwitcherClick(tmNode);
                 }
+            };
+            if (renderSwitcherIconRef.value) {
+                // if renderSwitcherIcon is set, icon dom may be altered before event
+                // bubbles to parent dom, so that target check fails. Call it in next
+                // event loop so that event bubble phase is finishes.
+                setTimeout(callback, 0);
             }
             else {
-                NTree.handleSwitcherClick(tmNode);
+                callback();
             }
         }
         const selectableRef = useMemo(() => !nodeIsDisabledRef.value &&
@@ -86,8 +97,9 @@ const TreeNode = defineComponent({
             if (!checkable)
                 return false;
             const { value: checkOnClick } = checkOnClickRef;
+            const { tmNode } = props;
             if (typeof checkOnClick === 'boolean') {
-                return checkOnClick;
+                return !tmNode.disabled && checkOnClick;
             }
             return checkOnClick(props.tmNode.rawNode);
         });
@@ -178,6 +190,33 @@ const TreeNode = defineComponent({
                 });
             }
         }
+        const indentNodes = computed(() => {
+            const { clsPrefix } = props;
+            const { value: indent } = indentRef;
+            if (showLineRef.value) {
+                const indentNodes = [];
+                let cursor = props.tmNode.parent;
+                while (cursor) {
+                    if (cursor.isLastChild) {
+                        indentNodes.push(h("div", { class: `${clsPrefix}-tree-node-indent` },
+                            h("div", { style: { width: `${indent}px` } })));
+                    }
+                    else {
+                        indentNodes.push(h("div", { class: [
+                                `${clsPrefix}-tree-node-indent`,
+                                `${clsPrefix}-tree-node-indent--show-line`
+                            ] },
+                            h("div", { style: { width: `${indent}px` } })));
+                    }
+                    cursor = cursor.parent;
+                }
+                return indentNodes.reverse();
+            }
+            else {
+                return repeat(props.tmNode.level, h("div", { class: `${props.clsPrefix}-tree-node-indent` },
+                    h("div", { style: { width: `${indent}px` } })));
+            }
+        });
         return {
             showDropMark: useMemo(() => {
                 const { value: draggingNode } = draggingNodeRef;
@@ -231,8 +270,10 @@ const TreeNode = defineComponent({
             droppingOffsetLevel: droppingOffsetLevelRef,
             indent: indentRef,
             checkboxPlacement: checkboxPlacementRef,
+            showLine: showLineRef,
             contentInstRef,
             contentElRef,
+            indentNodes,
             handleCheck,
             handleDrop,
             handleDragStart,
@@ -246,7 +287,7 @@ const TreeNode = defineComponent({
         };
     },
     render() {
-        const { tmNode, clsPrefix, checkable, expandOnClick, selectable, selected, checked, highlight, draggable, blockLine, indent, disabled, pending, internalScrollable, nodeProps, checkboxPlacement } = this;
+        const { tmNode, clsPrefix, checkable, expandOnClick, selectable, selected, checked, highlight, draggable, blockLine, indent, indentNodes, disabled, pending, internalScrollable, nodeProps, checkboxPlacement } = this;
         // drag start not inside
         // it need to be append to node itself, not wrapper
         const dragEventHandlers = draggable && !disabled
@@ -262,7 +303,7 @@ const TreeNode = defineComponent({
         // scrolled to, so we need data-key to query the target element.
         const dataKey = internalScrollable ? createDataKey(tmNode.key) : undefined;
         const checkboxOnRight = checkboxPlacement === 'right';
-        const checkboxNode = checkable ? (h(NTreeNodeCheckbox, { right: checkboxOnRight, focusable: this.checkboxFocusable, disabled: disabled || this.checkboxDisabled, clsPrefix: clsPrefix, checked: this.checked, indeterminate: this.indeterminate, onCheck: this.handleCheck })) : null;
+        const checkboxNode = checkable ? (h(NTreeNodeCheckbox, { indent: indent, right: checkboxOnRight, focusable: this.checkboxFocusable, disabled: disabled || this.checkboxDisabled, clsPrefix: clsPrefix, checked: this.checked, indeterminate: this.indeterminate, onCheck: this.handleCheck })) : null;
         return (h("div", Object.assign({ class: `${clsPrefix}-tree-node-wrapper` }, dragEventHandlers),
             h("div", Object.assign({}, (blockLine ? nodeProps : undefined), { class: [
                     `${clsPrefix}-tree-node`,
@@ -279,9 +320,15 @@ const TreeNode = defineComponent({
                 ], "data-key": dataKey, draggable: draggable && blockLine, onClick: this.handleLineClick, onDragstart: draggable && blockLine && !disabled
                     ? this.handleDragStart
                     : undefined }),
-                repeat(tmNode.level, h("div", { class: `${clsPrefix}-tree-node-indent` },
-                    h("div", { style: { width: `${indent}px` } }))),
-                h(NTreeNodeSwitcher, { clsPrefix: clsPrefix, expanded: this.expanded, selected: selected, loading: this.loading, hide: tmNode.isLeaf, onClick: this.handleSwitcherClick }),
+                indentNodes,
+                tmNode.isLeaf && this.showLine ? (h("div", { class: [
+                        `${clsPrefix}-tree-node-indent`,
+                        `${clsPrefix}-tree-node-indent--show-line`,
+                        tmNode.isLeaf && `${clsPrefix}-tree-node-indent--is-leaf`,
+                        tmNode.isLastChild &&
+                            `${clsPrefix}-tree-node-indent--last-child`
+                    ] },
+                    h("div", { style: { width: `${indent}px` } }))) : (h(NTreeNodeSwitcher, { clsPrefix: clsPrefix, expanded: this.expanded, selected: selected, loading: this.loading, hide: tmNode.isLeaf, tmNode: this.tmNode, indent: indent, onClick: this.handleSwitcherClick })),
                 !checkboxOnRight ? checkboxNode : null,
                 h(NTreeNodeContent, { ref: "contentInstRef", clsPrefix: clsPrefix, checked: checked, selected: selected, onClick: this.handleContentClick, nodeProps: blockLine ? undefined : nodeProps, onDragstart: draggable && !blockLine && !disabled
                         ? this.handleDragStart

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

@@ -4,6 +4,10 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
+    indent: {
+        type: NumberConstructor;
+        required: true;
+    };
     right: BooleanConstructor;
     focusable: BooleanConstructor;
     disabled: BooleanConstructor;
@@ -120,6 +124,9 @@ declare const _default: import("vue").DefineComponent<{
         };
         self: {
             fontSize: string;
+            lineHeight: string;
+            nodeHeight: string;
+            nodeWrapperPadding: string;
             nodeBorderRadius: string;
             nodeColorHover: string;
             nodeColorPressed: string;
@@ -129,6 +136,7 @@ declare const _default: import("vue").DefineComponent<{
             nodeTextColorDisabled: string;
             loadingColor: string;
             dropMarkColor: string;
+            lineColor: string;
         };
         peers: {
             Checkbox: import("../../_mixins").Theme<"Checkbox", {
@@ -202,6 +210,10 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
+    indent: {
+        type: NumberConstructor;
+        required: true;
+    };
     right: BooleanConstructor;
     focusable: BooleanConstructor;
     disabled: BooleanConstructor;
@@ -214,5 +226,5 @@ declare const _default: import("vue").DefineComponent<{
     checked: boolean;
     indeterminate: boolean;
     focusable: boolean;
-}>;
+}, {}>;
 export default _default;

package/es/tree/src/TreeNodeCheckbox.js

@@ -8,6 +8,10 @@ export default defineComponent({
             type: String,
             required: true
         },
+        indent: {
+            type: Number,
+            required: true
+        },
         right: Boolean,
         focusable: Boolean,
         disabled: Boolean,
@@ -25,12 +29,7 @@ export default defineComponent({
             }
         }
         function handleUpdateValue(value) {
-            if (props.indeterminate) {
-                doCheck(false);
-            }
-            else {
-                doCheck(value);
-            }
+            doCheck(value);
         }
         return {
             handleUpdateValue,
@@ -38,11 +37,13 @@ export default defineComponent({
         };
     },
     render() {
-        const { clsPrefix, mergedTheme, checked, indeterminate, disabled, focusable, handleUpdateValue } = this;
+        const { clsPrefix, mergedTheme, checked, indeterminate, disabled, focusable, indent, handleUpdateValue } = this;
         return (h("span", { class: [
                 `${clsPrefix}-tree-node-checkbox`,
                 this.right && `${clsPrefix}-tree-node-checkbox--right`
-            ], "data-checkbox": true },
+            ], style: {
+                width: `${indent}px`
+            }, "data-checkbox": true },
             h(NCheckbox, { focusable: focusable, disabled: disabled, theme: mergedTheme.peers.Checkbox, themeOverrides: mergedTheme.peerOverrides.Checkbox, checked: checked, indeterminate: indeterminate, onUpdateChecked: handleUpdateValue })));
     }
 });

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

@@ -41,5 +41,5 @@ declare const _default: import("vue").DefineComponent<{
     disabled: boolean;
     checked: boolean;
     selected: boolean;
-}>;
+}, {}>;
 export default _default;

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

@@ -1,28 +1,45 @@
 import { type PropType } from 'vue';
+import { type TmNode } from './interface';
 declare const _default: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;
         required: true;
     };
+    indent: {
+        type: NumberConstructor;
+        required: true;
+    };
     expanded: BooleanConstructor;
     selected: BooleanConstructor;
     hide: BooleanConstructor;
     loading: BooleanConstructor;
     onClick: PropType<(e: MouseEvent) => void>;
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     clsPrefix: {
         type: StringConstructor;
         required: true;
     };
+    indent: {
+        type: NumberConstructor;
+        required: true;
+    };
     expanded: BooleanConstructor;
     selected: BooleanConstructor;
     hide: BooleanConstructor;
     loading: BooleanConstructor;
     onClick: PropType<(e: MouseEvent) => void>;
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
 }>>, {
     hide: boolean;
     expanded: boolean;
-    selected: boolean;
     loading: boolean;
-}>;
+    selected: boolean;
+}, {}>;
 export default _default;

package/es/tree/src/TreeNodeSwitcher.js

@@ -9,22 +9,27 @@ export default defineComponent({
             type: String,
             required: true
         },
+        indent: { type: Number, required: true },
         expanded: Boolean,
         selected: Boolean,
         hide: Boolean,
         loading: Boolean,
-        onClick: Function
+        onClick: Function,
+        tmNode: {
+            type: Object,
+            required: true
+        }
     },
     setup(props) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const { renderSwitcherIconRef } = inject(treeInjectionKey, null);
         return () => {
-            const { clsPrefix } = props;
+            const { clsPrefix, expanded, hide, indent, onClick } = props;
             return (h("span", { "data-switcher": true, class: [
                     `${clsPrefix}-tree-node-switcher`,
-                    props.expanded && `${clsPrefix}-tree-node-switcher--expanded`,
-                    props.hide && `${clsPrefix}-tree-node-switcher--hide`
-                ], onClick: props.onClick },
+                    expanded && `${clsPrefix}-tree-node-switcher--expanded`,
+                    hide && `${clsPrefix}-tree-node-switcher--hide`
+                ], style: { width: `${indent}px` }, onClick: onClick },
                 h("div", { class: `${clsPrefix}-tree-node-switcher__icon` },
                     h(NIconSwitchTransition, null, {
                         default: () => {
@@ -34,7 +39,8 @@ export default defineComponent({
                             const { value: renderSwitcherIcon } = renderSwitcherIconRef;
                             return renderSwitcherIcon ? (renderSwitcherIcon({
                                 expanded: props.expanded,
-                                selected: props.selected
+                                selected: props.selected,
+                                option: props.tmNode.rawNode
                             })) : (h(NBaseIcon, { clsPrefix: clsPrefix, key: "switcher" }, { default: () => h(SwitcherIcon, null) }));
                         }
                     }))));

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

@@ -56,6 +56,7 @@ export interface InternalDropInfo {
 export type RenderSwitcherIcon = (props: {
     expanded: boolean;
     selected: boolean;
+    option: TreeOption;
 }) => VNodeChild;
 export type CheckOnClick = (option: TreeOption) => boolean;
 export interface TreeInjection {
@@ -96,6 +97,7 @@ export interface TreeInjection {
     internalTreeSelect: boolean;
     checkOnClickRef: Ref<boolean | CheckOnClick>;
     disabledFieldRef: Ref<string>;
+    showLineRef: Ref<boolean>;
     handleSwitcherClick: (node: TreeNode<TreeOption>) => void;
     handleSelect: (node: TreeNode<TreeOption>) => void;
     handleCheck: (node: TreeNode<TreeOption>, checked: boolean) => void;