naive-ui 2.19.10 → 2.19.11

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

@@ -0,0 +1,53 @@
+import { PropType, ComponentPublicInstance } from 'vue';
+import { TmNode } from './interface';
+declare const TreeNode: import("vue").DefineComponent<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    tmNode: {
+        type: PropType<TmNode>;
+        required: true;
+    };
+}, {
+    showDropMark: import("vue").ComputedRef<boolean | undefined>;
+    showDropMarkAsParent: import("vue").ComputedRef<boolean>;
+    pending: import("vue").ComputedRef<boolean>;
+    loading: import("vue").ComputedRef<boolean>;
+    highlight: import("vue").ComputedRef<boolean>;
+    checked: import("vue").ComputedRef<boolean>;
+    indeterminate: import("vue").ComputedRef<boolean>;
+    selected: import("vue").ComputedRef<boolean>;
+    expanded: import("vue").ComputedRef<boolean>;
+    disabled: import("vue").ComputedRef<boolean>;
+    checkable: import("vue").ComputedRef<boolean>;
+    checkboxDisabled: import("vue").ComputedRef<boolean>;
+    selectable: import("vue").ComputedRef<boolean>;
+    internalScrollable: import("vue").Ref<boolean>;
+    draggable: import("vue").Ref<boolean>;
+    blockLine: import("vue").Ref<boolean>;
+    checkboxFocusable: import("vue").Ref<boolean>;
+    droppingPosition: import("vue").Ref<import("./interface").DropPosition | null>;
+    droppingOffsetLevel: import("vue").Ref<number>;
+    indent: import("vue").Ref<number>;
+    contentInstRef: import("vue").Ref<ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null>;
+    contentElRef: {
+        value: HTMLElement | null;
+    };
+    handleCheck: (checked: boolean) => void;
+    handleDrop: (e: DragEvent) => void;
+    handleDragStart: (e: DragEvent) => void;
+    handleDragEnter: (e: DragEvent) => void;
+    handleDragOver: (e: DragEvent) => void;
+    handleDragEnd: (e: DragEvent) => void;
+    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;
+} & {}>, {}>;
+export default TreeNode;

package/lib/tree/src/TreeNode.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const vue_1 = require("vue");
+const vooks_1 = require("vooks");
+const seemly_1 = require("seemly");
+const _utils_1 = require("../../_utils");
+const TreeNodeSwitcher_1 = require("./TreeNodeSwitcher");
+const TreeNodeCheckbox_1 = require("./TreeNodeCheckbox");
+const TreeNodeContent_1 = require("./TreeNodeContent");
+const interface_1 = require("./interface");
+const dnd_1 = require("./dnd");
+const TreeNode = (0, vue_1.defineComponent)({
+    name: 'TreeNode',
+    props: {
+        clsPrefix: {
+            type: String,
+            required: true
+        },
+        tmNode: {
+            type: Object,
+            required: true
+        }
+    },
+    setup(props) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const NTree = (0, vue_1.inject)(interface_1.treeInjectionKey);
+        const { droppingNodeParentRef, droppingMouseNodeRef, draggingNodeRef, droppingPositionRef, droppingOffsetLevelRef, indentRef } = NTree;
+        // used for drag and drop
+        const contentInstRef = (0, vue_1.ref)(null);
+        // must be non-reactive
+        const contentElRef = { value: null };
+        (0, vue_1.onMounted)(() => {
+            contentElRef.value = contentInstRef.value.$el;
+        });
+        function handleSwitcherClick() {
+            const { tmNode } = props;
+            if (NTree.remoteRef.value && !tmNode.isLeaf && !tmNode.shallowLoaded) {
+                if (!NTree.loadingKeysRef.value.includes(tmNode.key)) {
+                    NTree.loadingKeysRef.value.push(tmNode.key);
+                }
+                const { onLoadRef: { value: onLoad } } = NTree;
+                if (onLoad) {
+                    void onLoad(tmNode.rawNode)
+                        .then(() => {
+                        NTree.handleSwitcherClick(tmNode);
+                    })
+                        .finally(() => {
+                        NTree.loadingKeysRef.value.splice(NTree.loadingKeysRef.value.findIndex((key) => key === tmNode.key), 1);
+                    });
+                }
+            }
+            else {
+                NTree.handleSwitcherClick(tmNode);
+            }
+        }
+        function handleContentClick(e) {
+            if ((0, seemly_1.happensIn)(e, 'checkbox') || (0, seemly_1.happensIn)(e, 'switcher'))
+                return;
+            NTree.handleSelect(props.tmNode);
+        }
+        function handleCheck(checked) {
+            NTree.handleCheck(props.tmNode, checked);
+        }
+        // Dnd
+        function handleDragStart(e) {
+            NTree.handleDragStart({
+                event: e,
+                node: props.tmNode
+            });
+        }
+        function handleDragEnter(e) {
+            if (e.currentTarget !== e.target) {
+                return;
+            }
+            NTree.handleDragEnter({
+                event: e,
+                node: props.tmNode
+            });
+        }
+        function handleDragOver(e) {
+            e.preventDefault(); // if not prevent, drop event won't be fired...
+            NTree.handleDragOver({
+                event: e,
+                node: props.tmNode
+            });
+        }
+        function handleDragEnd(e) {
+            NTree.handleDragEnd({
+                event: e,
+                node: props.tmNode
+            });
+        }
+        function handleDragLeave(e) {
+            if (e.currentTarget !== e.target) {
+                return;
+            }
+            NTree.handleDragLeave({
+                event: e,
+                node: props.tmNode
+            });
+        }
+        function handleDrop(e) {
+            e.preventDefault();
+            if (droppingPositionRef.value !== null) {
+                NTree.handleDrop({
+                    event: e,
+                    node: props.tmNode,
+                    dropPosition: droppingPositionRef.value
+                });
+            }
+        }
+        return {
+            showDropMark: (0, vooks_1.useMemo)(() => {
+                const { value: draggingNode } = draggingNodeRef;
+                if (!draggingNode)
+                    return;
+                const { value: droppingPosition } = droppingPositionRef;
+                if (!droppingPosition)
+                    return;
+                const { value: droppingMouseNode } = droppingMouseNodeRef;
+                if (!droppingMouseNode) {
+                    return;
+                }
+                const { tmNode } = props;
+                if (tmNode.key === droppingMouseNode.key)
+                    return true;
+                return false;
+            }),
+            showDropMarkAsParent: (0, vooks_1.useMemo)(() => {
+                const { value: droppingNodeParent } = droppingNodeParentRef;
+                if (!droppingNodeParent)
+                    return false;
+                const { tmNode } = props;
+                const { value: droppingPosition } = droppingPositionRef;
+                if (droppingPosition === 'before' || droppingPosition === 'after') {
+                    return droppingNodeParent.key === tmNode.key;
+                }
+                return false;
+            }),
+            pending: (0, vooks_1.useMemo)(() => NTree.pendingNodeKeyRef.value === props.tmNode.key),
+            loading: (0, vooks_1.useMemo)(() => NTree.loadingKeysRef.value.includes(props.tmNode.key)),
+            highlight: (0, vooks_1.useMemo)(() => NTree.highlightKeySetRef.value.has(props.tmNode.key)),
+            checked: (0, vooks_1.useMemo)(() => NTree.displayedCheckedKeysRef.value.includes(props.tmNode.key)),
+            indeterminate: (0, vooks_1.useMemo)(() => NTree.displayedIndeterminateKeysRef.value.includes(props.tmNode.key)),
+            selected: (0, vooks_1.useMemo)(() => NTree.mergedSelectedKeysRef.value.includes(props.tmNode.key)),
+            expanded: (0, vooks_1.useMemo)(() => NTree.mergedExpandedKeysRef.value.includes(props.tmNode.key)),
+            disabled: (0, vue_1.computed)(() => NTree.disabledRef.value || props.tmNode.disabled),
+            checkable: (0, vue_1.computed)(() => NTree.checkableRef.value &&
+                (NTree.cascadeRef.value ||
+                    NTree.mergedCheckStrategyRef.value !== 'child' ||
+                    props.tmNode.isLeaf)),
+            checkboxDisabled: (0, vue_1.computed)(() => !!props.tmNode.rawNode.checkboxDisabled),
+            selectable: (0, vue_1.computed)(() => NTree.selectableRef.value &&
+                (NTree.mergedCheckStrategyRef.value === 'child'
+                    ? props.tmNode.isLeaf
+                    : true)),
+            internalScrollable: NTree.internalScrollableRef,
+            draggable: NTree.draggableRef,
+            blockLine: NTree.blockLineRef,
+            checkboxFocusable: NTree.internalCheckboxFocusableRef,
+            droppingPosition: droppingPositionRef,
+            droppingOffsetLevel: droppingOffsetLevelRef,
+            indent: indentRef,
+            contentInstRef,
+            contentElRef,
+            handleCheck,
+            handleDrop,
+            handleDragStart,
+            handleDragEnter,
+            handleDragOver,
+            handleDragEnd,
+            handleDragLeave,
+            handleContentClick,
+            handleSwitcherClick
+        };
+    },
+    render() {
+        const { tmNode, clsPrefix, checkable, selectable, selected, checked, highlight, draggable, blockLine, indent, disabled, pending, internalScrollable } = this;
+        // drag start not inside
+        // it need to be append to node itself, not wrapper
+        const dragEventHandlers = draggable && !disabled
+            ? {
+                onDragenter: this.handleDragEnter,
+                onDragleave: this.handleDragLeave,
+                onDragend: this.handleDragEnd,
+                onDrop: this.handleDrop,
+                onDragover: this.handleDragOver
+            }
+            : undefined;
+        // In non virtual mode, there's no evidence that which element should be
+        // scrolled to, so we need data-key to query the target element.
+        const dataKey = internalScrollable ? (0, _utils_1.createDataKey)(tmNode.key) : undefined;
+        return ((0, vue_1.h)("div", Object.assign({ class: `${clsPrefix}-tree-node-wrapper` }, dragEventHandlers),
+            (0, vue_1.h)("div", { class: [
+                    `${clsPrefix}-tree-node`,
+                    {
+                        [`${clsPrefix}-tree-node--selected`]: selected,
+                        [`${clsPrefix}-tree-node--checkable`]: checkable,
+                        [`${clsPrefix}-tree-node--highlight`]: highlight,
+                        [`${clsPrefix}-tree-node--pending`]: pending,
+                        [`${clsPrefix}-tree-node--disabled`]: disabled,
+                        [`${clsPrefix}-tree-node--selectable`]: selectable
+                    }
+                ], "data-key": dataKey, draggable: draggable && blockLine, onClick: blockLine && !disabled ? this.handleContentClick : undefined, onDragstart: draggable && blockLine && !disabled
+                    ? this.handleDragStart
+                    : undefined },
+                (0, seemly_1.repeat)(tmNode.level, (0, vue_1.h)("div", { class: `${clsPrefix}-tree-node-indent`, style: { flex: `0 0 ${indent}px` } })),
+                (0, vue_1.h)(TreeNodeSwitcher_1.default, { clsPrefix: clsPrefix, expanded: this.expanded, loading: this.loading, hide: tmNode.isLeaf, onClick: this.handleSwitcherClick }),
+                checkable ? ((0, vue_1.h)(TreeNodeCheckbox_1.default, { focusable: this.checkboxFocusable, disabled: disabled || this.checkboxDisabled, clsPrefix: clsPrefix, checked: this.checked, indeterminate: this.indeterminate, onCheck: this.handleCheck })) : null,
+                (0, vue_1.h)(TreeNodeContent_1.default, { ref: "contentInstRef", clsPrefix: clsPrefix, checked: checked, selected: selected, onClick: blockLine || disabled ? undefined : this.handleContentClick, onDragstart: draggable && !blockLine && !disabled
+                        ? this.handleDragStart
+                        : undefined, tmNode: tmNode }),
+                draggable
+                    ? this.showDropMark
+                        ? (0, dnd_1.renderDropMark)({
+                            el: this.contentElRef.value,
+                            position: this.droppingPosition,
+                            offsetLevel: this.droppingOffsetLevel,
+                            indent
+                        })
+                        : this.showDropMarkAsParent
+                            ? (0, dnd_1.renderDropMark)({
+                                el: this.contentElRef.value,
+                                position: 'inside',
+                                offsetLevel: this.droppingOffsetLevel,
+                                indent
+                            })
+                            : null
+                    : null)));
+    }
+});
+exports.default = TreeNode;

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

@@ -0,0 +1,194 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    focusable: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    indeterminate: BooleanConstructor;
+    onCheck: PropType<(value: boolean) => void>;
+}, {
+    handleUpdateValue: (value: boolean) => void;
+    mergedTheme: import("vue").Ref<{
+        common: {
+            baseColor: string;
+            primaryColor: string;
+            primaryColorHover: string;
+            primaryColorPressed: string;
+            primaryColorSuppl: string;
+            infoColor: string;
+            infoColorHover: string;
+            infoColorPressed: string;
+            infoColorSuppl: string;
+            successColor: string;
+            successColorHover: string;
+            successColorPressed: string;
+            successColorSuppl: string;
+            warningColor: string;
+            warningColorHover: string;
+            warningColorPressed: string;
+            warningColorSuppl: string;
+            errorColor: string;
+            errorColorHover: string;
+            errorColorPressed: string;
+            errorColorSuppl: string;
+            textColorBase: string;
+            textColor1: string;
+            textColor2: string;
+            textColor3: string;
+            textColorDisabled: string;
+            placeholderColor: string;
+            placeholderColorDisabled: string;
+            iconColor: string;
+            iconColorHover: string;
+            iconColorPressed: string;
+            iconColorDisabled: string;
+            opacity1: string;
+            opacity2: string;
+            opacity3: string;
+            opacity4: string;
+            opacity5: string;
+            dividerColor: string;
+            borderColor: string;
+            closeColor: string;
+            closeColorHover: string;
+            closeColorPressed: string;
+            closeColorDisabled: string;
+            clearColor: string;
+            clearColorHover: string;
+            clearColorPressed: string;
+            scrollbarColor: string;
+            scrollbarColorHover: string;
+            scrollbarWidth: string;
+            scrollbarHeight: string;
+            scrollbarBorderRadius: string;
+            progressRailColor: string;
+            railColor: string;
+            popoverColor: string;
+            tableColor: string;
+            cardColor: string;
+            modalColor: string;
+            bodyColor: string;
+            tagColor: string;
+            avatarColor: string;
+            invertedColor: string;
+            inputColor: string;
+            codeColor: string;
+            tabColor: string;
+            actionColor: string;
+            tableHeaderColor: string;
+            hoverColor: string;
+            tableColorHover: string;
+            pressedColor: string;
+            opacityDisabled: string;
+            inputColorDisabled: string;
+            boxShadow1: string;
+            boxShadow2: string;
+            boxShadow3: string;
+            fontFamily: string;
+            fontFamilyMono: string;
+            fontWeight: string;
+            fontWeightStrong: string;
+            cubicBezierEaseInOut: string;
+            cubicBezierEaseOut: string;
+            cubicBezierEaseIn: string;
+            borderRadius: string;
+            borderRadiusSmall: string;
+            fontSize: string;
+            fontSizeTiny: string;
+            fontSizeSmall: string;
+            fontSizeMedium: string;
+            fontSizeLarge: string;
+            fontSizeHuge: string;
+            lineHeight: string;
+            heightTiny: string;
+            heightSmall: string;
+            heightMedium: string;
+            heightLarge: string;
+            heightHuge: string;
+            transformDebounceScale: string;
+            name: "common";
+        };
+        self: {
+            fontSize: string;
+            nodeBorderRadius: string;
+            nodeColorHover: string;
+            nodeColorPressed: string;
+            nodeColorActive: string;
+            arrowColor: string;
+            nodeTextColor: string;
+            nodeTextColorDisabled: string;
+            loadingColor: string;
+            dropMarkColor: string;
+        };
+        peers: {
+            Checkbox: import("../../_mixins").Theme<"Checkbox", {
+                fontSizeSmall: string;
+                fontSizeMedium: string;
+                fontSizeLarge: string;
+                borderRadius: string;
+                color: string;
+                colorChecked: string;
+                colorDisabled: string;
+                colorDisabledChecked: string;
+                colorTableHeader: string;
+                colorTableHeaderModal: string;
+                colorTableHeaderPopover: string;
+                checkMarkColor: string;
+                checkMarkColorDisabled: string;
+                checkMarkColorDisabledChecked: string;
+                border: string;
+                borderDisabled: string;
+                borderDisabledChecked: string;
+                borderChecked: string;
+                borderFocus: string;
+                boxShadowFocus: string;
+                textColor: string;
+                textColorDisabled: string;
+                sizeSmall: string;
+                sizeMedium: string;
+                sizeLarge: string;
+                labelPadding: string;
+            }, any>;
+            Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
+                color: string;
+                colorHover: string;
+            }, any>;
+        };
+        peerOverrides: {
+            Checkbox?: {
+                peers?: {
+                    [x: string]: any;
+                } | undefined;
+            } | undefined;
+            Scrollbar?: {
+                peers?: {
+                    [x: string]: any;
+                } | undefined;
+            } | 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;
+}>, {
+    disabled: boolean;
+    checked: boolean;
+    focusable: boolean;
+    indeterminate: boolean;
+}>;
+export default _default;

package/lib/tree/src/TreeNodeCheckbox.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vue_1 = require("vue");
+const checkbox_1 = require("../../checkbox");
+const interface_1 = require("./interface");
+exports.default = (0, vue_1.defineComponent)({
+    name: 'NTreeNodeCheckbox',
+    props: {
+        clsPrefix: {
+            type: String,
+            required: true
+        },
+        focusable: Boolean,
+        disabled: Boolean,
+        checked: Boolean,
+        indeterminate: Boolean,
+        onCheck: Function
+    },
+    setup(props) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const NTree = (0, vue_1.inject)(interface_1.treeInjectionKey);
+        function doCheck(value) {
+            const { onCheck } = props;
+            if (onCheck)
+                return onCheck(value);
+        }
+        function handleUpdateValue(value) {
+            if (props.indeterminate) {
+                doCheck(false);
+            }
+            else {
+                doCheck(value);
+            }
+        }
+        return {
+            handleUpdateValue,
+            mergedTheme: NTree.mergedThemeRef
+        };
+    },
+    render() {
+        const { clsPrefix, mergedTheme, checked, indeterminate, disabled, focusable, handleUpdateValue } = this;
+        return ((0, vue_1.h)("span", { class: `${clsPrefix}-tree-node-checkbox`, "data-checkbox": true },
+            (0, vue_1.h)(checkbox_1.NCheckbox, { focusable: focusable, disabled: disabled, theme: mergedTheme.peers.Checkbox, themeOverrides: mergedTheme.peerOverrides.Checkbox, checked: checked, indeterminate: indeterminate, onUpdateChecked: handleUpdateValue })));
+    }
+});

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

@@ -0,0 +1,46 @@
+import { PropType } from 'vue';
+import { TmNode } from './interface';
+declare const _default: import("vue").DefineComponent<{
+    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;
+    };
+}, {
+    selfRef: import("vue").Ref<HTMLElement | null>;
+    renderLabel: import("vue").Ref<(({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined>;
+    renderPrefix: import("vue").Ref<(({ option, checked, selected }: import("./interface").TreeRenderProps) => import("vue").VNodeChild) | undefined>;
+    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;
+}>, {
+    disabled: boolean;
+    checked: boolean;
+    selected: boolean;
+}>;
+export default _default;

package/lib/tree/src/TreeNodeContent.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vue_1 = require("vue");
+const _utils_1 = require("../../_utils");
+const interface_1 = require("./interface");
+exports.default = (0, vue_1.defineComponent)({
+    name: 'TreeNodeContent',
+    props: {
+        clsPrefix: {
+            type: String,
+            required: true
+        },
+        disabled: Boolean,
+        checked: Boolean,
+        selected: Boolean,
+        onClick: Function,
+        onDragstart: Function,
+        tmNode: {
+            type: Object,
+            required: true
+        }
+    },
+    setup(props) {
+        const { renderLabelRef, renderPrefixRef, renderSuffixRef, labelFieldRef } = 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (0, vue_1.inject)(interface_1.treeInjectionKey);
+        const selfRef = (0, vue_1.ref)(null);
+        function doClick(e) {
+            const { onClick } = props;
+            if (onClick)
+                onClick(e);
+        }
+        function handleClick(e) {
+            doClick(e);
+        }
+        return {
+            selfRef,
+            renderLabel: renderLabelRef,
+            renderPrefix: renderPrefixRef,
+            renderSuffix: renderSuffixRef,
+            labelField: labelFieldRef,
+            handleClick
+        };
+    },
+    render() {
+        const { clsPrefix, labelField, checked = false, selected = false, renderLabel, renderPrefix, renderSuffix, handleClick, onDragstart, tmNode: { rawNode, rawNode: { prefix, suffix, [labelField]: label } } } = this;
+        return ((0, vue_1.h)("span", { ref: "selfRef", class: [`${clsPrefix}-tree-node-content`], onClick: handleClick, draggable: onDragstart === undefined ? undefined : true, onDragstart: onDragstart },
+            renderPrefix || prefix ? ((0, vue_1.h)("div", { class: `${clsPrefix}-tree-node-content__prefix` }, renderPrefix
+                ? renderPrefix({
+                    option: rawNode,
+                    selected,
+                    checked
+                })
+                : (0, _utils_1.render)(prefix))) : null,
+            (0, vue_1.h)("div", { class: `${clsPrefix}-tree-node-content__text` }, renderLabel
+                ? renderLabel({
+                    option: rawNode,
+                    selected,
+                    checked
+                })
+                : (0, _utils_1.render)(label)),
+            renderSuffix || suffix ? ((0, vue_1.h)("div", { class: `${clsPrefix}-tree-node-content__suffix` }, renderSuffix
+                ? renderSuffix({
+                    option: rawNode,
+                    selected,
+                    checked
+                })
+                : (0, _utils_1.render)(suffix))) : null));
+    }
+});

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

@@ -0,0 +1,29 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    clsPrefix: {
+        type: StringConstructor;
+        required: true;
+    };
+    expanded: BooleanConstructor;
+    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;
+    clsPrefix: string;
+    loading: boolean;
+} & {
+    onClick?: ((e: MouseEvent) => void) | undefined;
+}>, {
+    hide: boolean;
+    expanded: boolean;
+    loading: boolean;
+}>;
+export default _default;