bri-components 1.3.98 → 1.4.1

package/src/components/list/mixins/DshCascaderTableMixin.js

@@ -2,16 +2,6 @@ export default {
     mixins: [],
     components: {},
     props: {
-        tableDataObj: {
-            type: Object,
-            default () {
-                return {
-                    tree: [],
-                    list: [],
-                    _treeForm: []
-                };
-            }
-        },
         treeColumns: {
             type: Array,
             default () {
@@ -21,54 +11,44 @@ export default {
     },
     data () {
         return {
-            boxWidth: 0,
-
-            baseOperationMap: {
-                canCreateCol: {
-                    name: "添加一列",
-                    type: "canCreateCol",
-                    icon: "md-add",
-                    event: "clickCreateCol"
-                },
-                canDeleteCol: {
-                    name: "删除该列",
-                    type: "canDeleteCol",
-                    icon: "md-trash",
-                    color: "red",
-                    event: "clickDeleteCol"
-                }
-            },
-            otherOperationMap: {
-                canChangeNode: {
-                    name: "改变节点值",
-                    type: "canChangeNode",
-                    event: "changeNode"
-                },
-                canClickNode: {
-                    name: "点击节点",
-                    type: "canClickNode",
-                    event: "clickNode"
-                },
-                canBlurNode: {
-                    name: "节点失去焦点",
-                    type: "canBlurNode",
-                    event: "blurNode"
-                }
-            }
+            boxWidth: 0
+            // baseOperationMap: {
+            //     canCreateCol: {
+            //         name: "添加一列",
+            //         type: "canCreateCol",
+            //         icon: "md-add",
+            //         event: "clickCreateCol"
+            //     },
+            //     canDeleteCol: {
+            //         name: "删除该列",
+            //         type: "canDeleteCol",
+            //         icon: "md-trash",
+            //         color: "red",
+            //         event: "clickDeleteCol"
+            //     }
+            // }
         };
     },
     computed: {
-        typePropsObj () {
+        selfBasePropsObj () {
             return {
+                ...this.treeTableBasePropsObj,
                 _dftReadonlyTreeColKeys: [], // 默认的数据只读的表头列
                 _oldReadonlyTreeColKeys: [] // 保存的数据只读的表头列
             };
         },
         dftReadonlyTreeColKeys () {
-            return this.isDftSet ? [] : this.selfPropsObj._dftReadonlyTreeColKeys || []; // 配置端有问题，高级以依赖时候值成undefined了
+            return this.isDftSet ? [] : this.selfPropsObj._dftReadonlyTreeColKeys || []; // 配置端有问题，高级依赖时值成undefined了
         },
         oldReadonlyTreeColKeys () {
-            return this.isDftSet ? [] : this.selfPropsObj._oldReadonlyTreeColKeys || []; // 配置端有问题，高级以依赖时候值成undefined了
+            return this.isDftSet ? [] : this.selfPropsObj._oldReadonlyTreeColKeys || []; // 配置端有问题，高级依赖时值成undefined了
+        },
+        // 替换tableBaseMixin里的
+        showCreateBtnColKeys () {
+            return [
+                ...this.treeFormKeys,
+                ...(this.selfPropsObj._showCreateBtnColKeys || [])
+            ];
         },
 
         allTreeData () {
@@ -105,72 +85,34 @@ export default {
         init () {
             this.treeColumns.forEach((treeFormItem, treeFormIndex) => {
                 this.$set(treeFormItem, "level", treeFormIndex + 1);
-                this.$set(treeFormItem, "canDelete", true);
+                // this.$set(treeFormItem, "canDelete", true);
             });
         },
 
-        /* ----------- 操作 ---------- */
-        // 表头操作 -树形表头-添加一列
-        clickCreateCol (operationItem, col, colIndex) {
-            if (col.colType === "tree" && col.level === this.treeColumns.length) {
-                this.treeColumns.push({
-                    _id: this.$ObjectID().str,
-                    _key: this.$randomB36("Field"),
-                    _type: "textarea",
-                    _name: `${this.$numToChinese(this.treeColumns.length + 1)}级表头`,
-                    level: this.treeColumns.length + 1,
-                    canDelete: true,
-                    _treeSubForm: []
-                });
-                this.tableDataObj._treeForm = this.treeColumns;
+        // /* ----------- 操作 ---------- */
+        // // 表头操作 -树形表头-添加一列
+        // clickCreateCol (operationItem, col, colIndex) {
+        //     this.treeColumns.push({
+        //         _id: this.$ObjectID().str,
+        //         _key: this.$randomB36("Field"),
+        //         _type: "textarea",
+        //         _name: `${this.$numToChinese(this.treeColumns.length + 1)}级表头`,
+        //         level: this.treeColumns.length + 1,
+        //         canDelete: true,
+        //         _treeSubForm: []
+        //     });
+        //     this.tableDataObj._treeForm = this.treeColumns;
 
-                this.change("createCol", col);
-            }
-        },
-        // 表头操作 -树形表头-删除一列
-        clickDeleteCol (operationItem, col, colIndex) {
-            if (col.colType === "tree" && col.canDelete !== false) {
-                this.isDeleteColStatus = true; // isDeleteStatus不用在data中定义
-                this.treeColumns.pop();
-                this.tableDataObj._treeForm = this.treeColumns;
+        //     this.change("createCol", null, null, col);
+        // },
+        // // 表头操作 -树形表头-删除一列
+        // clickDeleteCol (operationItem, col, colIndex) {
+        //     this.isDeleteColStatus = true; // isDeleteStatus不用在data中定义
+        //     this.treeColumns.pop();
+        //     this.tableDataObj._treeForm = this.treeColumns;
 
-                this.change("deleteCol", col);
-            }
-        },
-
-        // 树形、汇总节点操作 -点击
-        clickNode (operationItem, row, rowIndex, col) {
-            if (col.colType === "tree") {
-                if (
-                    (this.getIsDftRow(row) ? !this.dftReadonlyTreeColKeys.includes(col._key) : true) && // 默认行的某列是否可编辑
-                    (row.__old__ === true ? !this.oldReadonlyTreeColKeys.includes(col._key) : true) // 老数据行里某些列不可编辑
-                ) {
-                    row.isEdit = true;
-                    this.$nextTick(() => {
-                        this.$refs[`${col._id}${row._id}`] && this.$refs[`${col._id}${row._id}`].focus();
-                    });
-                }
-            }
-            else if (col.colType === "summary") {
-                this.$Modal.warning({
-                    title: "该汇总单元格自动计算，不准手动输入！",
-                    closable: true,
-                    onOk: () => { },
-                    onCancel: () => { }
-                });
-            }
-        },
-        // 树形节点操作 -失去焦点
-        blurNode (operationItem, row, rowIndex, col) {
-            row.isEdit = false;
-        },
-        // 树形节点操作 -值改变
-        changeNode (operationItem, row, rowIndex, col) {
-            this.change("changeNode", row, rowIndex, col);
-        },
-        change (eventType, row, rowIndex, col, ...params) {
-            this.$emit("change", this.tableDataObj, eventType, col, row, rowIndex, ...params);
-        },
+        //     this.change("deleteCol", null, null, col);
+        // },
 
         /* ----------- 渲染函数（声明：为了代码更加规范清晰，return的是h相关的函数，则函数名get开头；return的是h的直接调用，函数名不要get开头）---------- */
         // 表格表头渲染函数
@@ -196,19 +138,12 @@ export default {
                                 "tr",
                                 {},
                                 this.showColumns.map((column, colIndex) => {
-                                    return h("th", {
-                                        key: column._id,
-                                        class: "bri-table-th",
-                                        style: this.getThStyle(column)
-                                    }, [
-                                        // 表头单元格
-                                        this.thRender(h, { column, colIndex })
-                                        // h("dsh-render", {
-                                        //     props: {
-                                        //         render: this.thRender(h, { column, colIndex })
-                                        //     }
-                                        // })
-                                    ]);
+                                    return this.thRender(h, { column, colIndex });
+                                    // return h("dsh-render", {
+                                    //     props: {
+                                    //         render: this.thRender(h, { column, colIndex })
+                                    //     }
+                                    // })
                                 })
                             )
                         ])
@@ -244,30 +179,20 @@ export default {
                                             class: ""
                                         },
                                         this.rowColumnsArr[rowIndex].map(column => {
-                                            return ["tree", "summary"].includes(column.colType)
-                                                // 树节点单元格、汇总单元格
-                                                ? this.treeTdRender(h, { row: mixedRow[column.nodeKey || column._key], rowIndex, column })
-                                                // 普通单元格
-                                                : this.contentTdRender(h, { row: mixedRow[column.nodeKey || column._key], rowIndex, column });
+                                            return this.tdRender(h, { row: mixedRow[column.nodeKey || column._key], rowIndex, column });
                                         })
                                     );
                                 })
                                 // 无数据
-                                : h("tr", {
-                                    class: "bri-table-nodata"
-                                }, [
-                                    h("td", {
-                                        style: {
-                                            width: `${this.boxWidth}px`,
-                                            minWidth: `${this.boxWidth}px`,
-                                            maxWidth: `${this.boxWidth}px`
-                                        },
-                                        attrs: {
-                                            rowspan: 1,
-                                            colspan: this.showColumns.length
-                                        }
-                                    }, "暂无数据…")
-                                ])
+                                : h(
+                                    "tr",
+                                    {
+                                        class: "bri-table-nodata"
+                                    },
+                                    [
+                                        this.emptyTdRender(h, {})
+                                    ]
+                                )
                         ])
                     ])
                 ])
@@ -275,204 +200,141 @@ export default {
         },
         // 表头单元格渲染函数 （无法共用contentColumns的renderHeaderCell，因为级联老版表头的无renderHeaderCell）
         thRender (h, { column, colIndex }) {
-            return h("div", [
-                this.contentThCellRender(h, { column, colIndex }),
+            return h(
+                "th",
+                {
+                    key: column._id,
+                    class: "bri-table-th",
+                    style: this.getThStyle(column)
+                },
+                [
+                    this.contentThCellRender(h, { column, colIndex })
 
-                // 级联最末级表头的下拉
-                this.treeDropOperationRender(h, { column, colIndex }, "th")
+                    // this.treeThDropOperationRender(h, { column, colIndex })
             ]);
         },
-        // 树节点单元格、汇总单元格渲染函数
-        treeTdRender (h, { row, rowIndex, column }) {
+        emptyTdRender (h, { row, rowIndex, column }) {
             return h("td", {
-                class: {
-                    "bri-table-td": true, // 可以不要，为了position: relative，下面有
-                    [`bri-table-td-${column.colType}`]: true,
-                    "bri-table-td-edit": this.canEdit
+                style: {
+                    width: `${this.boxWidth}px`,
+                    minWidth: `${this.boxWidth}px`,
+                    maxWidth: `${this.boxWidth}px`
                 },
-                style: this.getTdStyle(row, rowIndex, column),
                 attrs: {
-                    rowspan: this.getTdRowSpan(row, rowIndex, column),
-                    colspan: this.getTdColSpan(row, rowIndex, column)
-                },
-                on: {
-                    click: () => {
-                        this.$dispatchEvent(this.operationMap.canClickNode, row, rowIndex, column);
-                    }
+                    rowspan: 1,
+                    colspan: this.showColumns.length
                 }
-            }, [
-                column.colType === "tree"
-                    // 树节点单元格
-                    ? row.isEdit
-                        // 编辑状态
-                        ? h("Input", {
-                            ref: `${column._id}${row._id}`,
-                            props: {
-                                value: row.name,
-                                type: "textarea",
-                                autosize: {
-                                    minRows: this.getTdRowSpan(row, rowIndex, column) * 3 - 1,
-                                    maxRows: 100
-                                }
-                            },
-                            on: {
-                                input: val => {
-                                    row.name = val;
-                                },
-                                "on-blur": () => {
-                                    this.$dispatchEvent(this.operationMap.canBlurNode, row, rowIndex, column);
-                                },
-                                "on-change": () => {
-                                    this.$dispatchEvent(this.operationMap.canChangeNode, row, rowIndex, column);
-                                }
-                            }
-                        })
-                        // 查看状态
-                        : [
-                            h("bri-tooltip", {
-                                props: {
-                                    content: this.$transformEnterToBr(row.name),
-                                    transfer: true
-                                }
-                            }, [
-                                h("span", {
-                                    domProps: {
-                                        innerHTML: this.$transformEnterToBr(row.name)
-                                    }
-                                })
-                            ]),
-
-                            // 操作下拉
-                            this.treeDropOperationRender(h, { row, rowIndex, column }, "td")
-                        ]
-                    // 汇总单元格
-                    : h("span", this.getSummaryTdVal(row, rowIndex, column))
-            ]);
+            }, "暂无数据…");
         },
-        // 普通单元格渲染函数
-        contentTdRender (h, { row, rowIndex, column }) {
+        // 内容单元格渲染函数
+        tdRender (h, { row, rowIndex, column }) {
             return h(
                 "td",
                 {
-                    class: this.tablePropsObj.cellStyleOption.bodyCellClass({ row, rowIndex, column }),
+                    class: this.bodyCellClass({ row, rowIndex, column }) +
+                        `${["tree"].includes(column.colType) ? " bri-table-td-merge" : ""}`,
                     style: this.getTdStyle(row, rowIndex, column),
+                    attrs: {
+                        rowspan: this.getTdRowSpan(row, rowIndex, column),
+                        colspan: this.getTdColSpan(row, rowIndex, column)
+                    },
                     on: {
                         mouseenter: (event) => {
-                            this.$set(this.hoverRecordMap, `${row._id}dsh${column._key}`, true);
+                            this.$set(this.hoverRecordMap, `${row._id}`, true);
+                            // this.$set(this.hoverRecordMap, `${row._id}dsh${column._key}`, true);
                         },
                         mouseleave: (event) => {
-                            this.$set(this.hoverRecordMap, `${row._id}dsh${column._key}`, false);
+                            this.$set(this.hoverRecordMap, `${row._id}`, false);
+                            // this.$set(this.hoverRecordMap, `${row._id}dsh${column._key}`, false);
                         }
                     }
                 },
-                this.contentTdCellRender(h, { row, rowIndex, column })
+                column.colType === "summary"
+                    ? h("span", this.getSummaryTdVal(row, rowIndex, column))
+                    : column.colType === "operation"
+                        ? this.operationTdCellRender(h, { row, rowIndex, column })
+                        : this.contentTdCellRender(h, { row, rowIndex, column })
             );
         },
-        // 下拉渲染函数
-        treeDropOperationRender (h, { row, rowIndex, column, colIndex }, position = "th") {
-            const list = this.$getOperationList(
-                position === "th"
-                    ? [
-                        ...(column.level < this.maxLevel ? ["canCreateCol"] : []), // 限制最大添加到几级
-                        ...(column.level > 1 && column.canDelete === true ? ["canDeleteCol"] : []) // 只有一级和最后两级节点数不一致时，不能删
-                    ]
-                    : row.isLeaf === true
-                        ? [
-                            "canCreate",
-                            ...(this.getRowBtnCanEdit(row, rowIndex) ? ["canDelete"] : [])
-                        ]
-                        : [
-                            "canCreate",
-                            "canCreateChild",
-                            ...(this.getRowBtnCanEdit(row, rowIndex) ? ["canDelete", "canDeleteChilds"] : [])
-                        ]
-            );
+        // // 树形表头最末级列的下拉渲染函数
+        // treeThDropOperationRender (h, { column, colIndex }) {
+        //     const list = this.$getOperationList(
+        //         column.colType === "tree" && column.level === this.treeColumns.length
+        //             ? [
+        //                 ...(column.level < this.maxLevel ? ["canCreateCol"] : []), // 限制最大添加到几级
+        //                 ...(column.canDelete === true ? ["canDeleteCol"] : []) // 只有一级和最后两级节点数不一致时，不能删
+        //             ]
+        //             : []
+        //     );
 
-            return !this.isSearching &&
-                list.length &&
-                (
-                    position === "th"
-                        ? column.colType === "tree" && column.level === this.treeColumns.length
-                        : true
-                )
-                ? h("dsh-dropdown", {
-                    class: "bri-table-dropdown",
-                    props: {
-                        menuClass: "bri-table-dropdown-list",
-                        trigger: "hover",
-                        list: list
-                    },
-                    on: {
-                        click: (operationItem) => {
-                            position === "th"
-                                ? this.$dispatchEvent(operationItem, column, colIndex)
-                                : this.$dispatchEvent(operationItem, row, rowIndex, column);
-                        }
-                    },
-                    nativeOn: {
-                        click: (e) => {
-                            e.stopPropagation();
-                        }
-                    }
-                }, [
-                    h("a", {
-                        style: {
-                            fontWeight: "500",
-                            color: this.appColor
-                        },
-                        attrs: {
-                            href: "javascript:void(0)"
-                        }
-                    }, [
-                        h("Icon", {
-                            props: {
-                                type: "md-arrow-dropdown-circle",
-                                size: "16"
-                            }
-                        })
-                    ])
-                ])
-                : undefined;
-        },
+        //     return !this.isSearching &&
+        //         list.length
+        //         ? h("dsh-dropdown", {
+        //             class: "bri-table-dropdown",
+        //             props: {
+        //                 menuClass: "bri-table-dropdown-list",
+        //                 trigger: "hover",
+        //                 list: list
+        //             },
+        //             on: {
+        //                 click: (operationItem) => {
+        //                     this.$dispatchEvent(operationItem, column, colIndex);
+        //                 }
+        //             },
+        //             nativeOn: {
+        //                 click: (e) => {
+        //                     e.stopPropagation();
+        //                 }
+        //             }
+        //         }, [
+        //             h("a", {
+        //                 style: {
+        //                     fontWeight: "500",
+        //                     color: this.appColor
+        //                 },
+        //                 attrs: {
+        //                     href: "javascript:void(0)"
+        //                 }
+        //             }, [
+        //                 h("Icon", {
+        //                     props: {
+        //                         type: "md-arrow-dropdown-circle",
+        //                         size: "16"
+        //                     }
+        //                 })
+        //             ])
+        //         ])
+        //         : undefined;
+        // },
 
         /* ----------- 方法 ---------- */
         // 表头 -获取样式
-        getThStyle (col, position = "th") {
+        getThStyle (col) {
+            const typeData = this.$modFieldMap[col._type] || {};
             const boxColWidth = this.boxWidth / this.showColumns.length;
             const calcWidth = (col._name ? col._name.length * 12 : 48) + (col._type === "reference" ? 200 : 32);
             const dftWidth = Math.max(boxColWidth, this.widthMap[col._type], calcWidth);
             const width = col._width || dftWidth;
 
-            const selfStyle = col.colType === "tree"
-                ? {
-                    textAlign: col._align || "left",
-                    fontSize: "14px"
-                }
-                : col.colType === "summary"
-                    ? {
-                        textAlign: col._align || "right"
-                    }
-                    : {
-                        textAlign: col._align || "left"
-            };
-
             return {
                 width: `${width}px`,
                 minWidth: `${width}px`,
                 maxWidth: `${width}px`,
-                paddingTop: position === "th" && !this.headHeightAuto ? "10px" : undefined,
-                paddingBottom: position === "th" && !this.headHeightAuto ? "10px" : undefined,
+                paddingTop: !this.headHeightAuto ? "10px" : undefined,
+                paddingBottom: !this.headHeightAuto ? "10px" : undefined,
+                textAlign: col._align || typeData.align,
                 "word-break": "break-all",
-                cursor: "pointer",
-                ...selfStyle
+                cursor: "pointer"
             };
         },
 
         // 单元格 -获取样式
         getTdStyle (row, rowIndex, col) {
             return {
-                ...this.getThStyle(col, "td"),
-                backgroundColor: ["tree"].includes(col.colType) ? "#fbfbfb" : "#ffffff"
+                ...this.getThStyle(col),
+                paddingTop: undefined,
+                paddingBottom: undefined,
+                backgroundColor: "#ffffff"
             };
         },
         // 单元格 -获取行合并数
@@ -513,12 +375,29 @@ export default {
                         : "未选择算法";
             }
         },
+        // 列本身是否可编辑 -针对表头列
+        getTypeColCanEdit (row, rowIndex, col) {
+            return (this.getIsDftRow(row) ? !this.dftReadonlyTreeColKeys.includes(col._key) : true) && // 默认行的某列是否可编辑
+            (row.__old__ === true ? !this.oldReadonlyTreeColKeys.includes(col._key) : true); // 老数据行里某些列不可编辑
+        },
+        // getNewRowData时，额外补充的行相关的数据（针对层级属性的列）
+        getRowOtherDft (level, list) {
+            const column = this.treeForm[level - 1];
+            const dftVal = column._default;
+            const initDftVal = this.initDftValMap[column._type];
+
+            return {
+                name: this.$isEmptyData(dftVal)
+                    ? initDftVal
+                    : dftVal
+            };
+        },
 
         /* ----------- 工具方法 ---------- */
         // 合并表头
         mergeColumns (treeForm = [], subForm = this.showContentColumns) {
-            return treeForm
-                .reduce((arr, treeFormItem, treeFormIndex) => {
+            return [
+                ...treeForm.reduce((arr, treeFormItem) => {
                     return arr.concat(
                         {
                             ...treeFormItem,
@@ -532,68 +411,80 @@ export default {
                             }
                         ))
                     );
-                }, [])
-                .concat(
-                    subForm.map(subFormItem => (
-                        {
-                            ...subFormItem,
+                }, []),
+                ...subForm.map(subFormItem => ({
+                    ...subFormItem,
+                    nodeKey: treeForm[treeForm.length - 1]._key,
+                    colType: "data"
+                })),
+                ...(
+                    !this.isSearching && this.$getOperationList(["canDelete"]).length
+                        ? [{
+                            ...this.operationColumn,
                             nodeKey: treeForm[treeForm.length - 1]._key,
-                            colType: "data"
-                        }
-                    ))
-            );
+                            colType: "operation"
+                        }]
+                        : []
+                )
+            ];
         },
         // 转化树数据
         getCalcuedTree (nodes = [], treeForm = [], subForm = []) {
             treeForm.forEach((treeFormItem, treeFormIndex) => {
-                treeFormItem.canDelete = true; // 每次计算，重置一下
+                // treeFormItem.canDelete = true; // 每次计算，重置一下
                 treeFormItem.level = treeFormIndex + 1; // treeColumns更新,缺少level
             });
 
             // 循环遍树节点
-            const loop = (nodes = []) => {
+            const loop = (nodes = [], parentNodes = []) => {
                 nodes.forEach(rowItem => {
                     // 初始化树节点的数据，给节点加上一些属性并监测，注入到节点对象中
                     let curCol = treeForm[rowItem.level - 1];
                     this.$setObj(rowItem, {
                         _key: curCol._key,
                         level: curCol.level,
-                        isEdit: false,
                         isLeaf: false,
                         total: 1
                     });
 
                     // 最后一列（根节点）
                     if (rowItem.level === treeForm.length) {
-                        // 处理删除了最后一列后，把根节点上的subForm属性值全部给上级节点
-                        if (this.isDeleteColStatus) {
-                            let subNode = rowItem.children[0];
-                            subForm.forEach(subFormItem => {
-                                // 用$set也可以
-                                rowItem[subFormItem._key] = subNode[subFormItem._key];
-                            });
-                        }
+                        // // 处理删除了最后一列后，把根节点上的subForm属性值全部给上级节点
+                        // if (this.isDeleteColStatus) {
+                        //     let subNode = rowItem.children[0];
+                        //     subForm.forEach(subFormItem => {
+                        //         // 用$set也可以
+                        //         rowItem[subFormItem._key] = subNode[subFormItem._key];
+                        //     });
+                        // }
 
                         rowItem.children = [];
                         rowItem.isLeaf = true;
+
+                        // TODO：特殊处理-叶子节点上注入对应表头列们的name值
+                        const treeNodes = [...parentNodes, rowItem];
+                        treeForm.forEach((treeFormItem, treeFormIndex) => {
+                            rowItem[treeFormItem._key] = treeNodes[treeFormIndex].name;
+                        });
                     }
                     // 非最后一列（最后一列前的列，非根节点），需继续向下循环
                     else {
-                        // 判断是否能删除最后一列（1.判断条件：判断根节点列的前一列的所有节点 都必须只有一个子结点 2.canDelete放在表头treeForm最后一项，默认true）
-                        if (rowItem.level === treeForm.length - 1) {
-                            if (rowItem.children.length > 1) {
-                                treeForm[rowItem.level].canDelete = false;
-                            }
-                        }
+                        // // 判断是否能删除最后一列（1.判断条件：判断根节点列的前一列的所有节点 都必须只有一个子结点 2.canDelete放在表头treeForm最后一项，默认true）
+                        // if (rowItem.level === treeForm.length - 1) {
+                        //     if (rowItem.children.length > 1) {
+                        //         treeForm[rowItem.level].canDelete = false;
+                        //     }
+                        // }
 
                         // 非最后一列的 正常的非根节点
                         if (rowItem.children && rowItem.children.length) {
-                            loop(rowItem.children);
+                            loop(rowItem.children, [...parentNodes, rowItem]);
                         }
                         // 非最后一列的 新增的非根节点(此时是新增一列或新增非根节点行) -添加一个子节点，并把该节点上的subForm属性值全部给下级节点
                         // 特别提示：新增的是根节点行，不会走此处代码
                         else {
                             const newNode = this.getNewRowData(rowItem.level + 1, rowItem.children);
+
                             subForm.forEach(subFormItem => {
                                 // 用$set也可以
                                 newNode[subFormItem._key] = rowItem[subFormItem._key];
@@ -601,7 +492,7 @@ export default {
                             });
                             rowItem.children.push(newNode);
 
-                            loop(rowItem.children);
+                            loop(rowItem.children, [...parentNodes, rowItem]);
                         }
                     }
 
@@ -616,7 +507,7 @@ export default {
         },
         // 转化渲染使用的columns数组
         transformRowColumnsArr (nodes = [], treeForm = []) {
-            let loop = (nodes, rowColumnsArr) => {
+            const loop = (nodes = [], rowColumnsArr = []) => {
                 nodes = this.getFilteredNodes(nodes);
 
                 return nodes.reduce((rowColumnsArr, node, nodeIndex) => {
@@ -634,11 +525,11 @@ export default {
                 }, rowColumnsArr);
             };
 
-            return loop(nodes, []);
+            return loop(nodes);
         },
         // 转化表格数据
         transformRows (nodes = [], treeForm = []) {
-            const loop = (nodes, rows) => {
+            const loop = (nodes = [], rows = []) => {
                 nodes = this.getFilteredNodes(nodes);
 
                 return nodes.reduce((rows, node, nodeIndex) => {
@@ -661,12 +552,16 @@ export default {
                     }
                 }, rows);
             };
-            return loop(nodes, []);
+            return loop(nodes);
         },
         getFilteredNodes (nodes = []) {
             const loop = (nodes = []) => {
                 return nodes.filter(rowItem => {
                     if (rowItem.children && rowItem.children.length) {
+                        if (this.isSearching) {
+                            rowItem.__isSearchShow__ = true;
+                        }
+
                         const children = loop(rowItem.children);
                         return !!children.length;
                     } else {