fix(comp:tree): tree node disabled should be cascade

packages/components/tree/src/composables/useDataSource.ts

@@ -15,6 +15,8 @@ import { computed } from 'vue'
 
 import { isNil } from 'lodash-es'
 
+import { CascaderStrategy } from '@idux/components/cascader'
+
 export interface MergedNode {
   children?: MergedNode[]
   label: string
@@ -87,10 +89,11 @@ export function convertMergeNodes(
   labelKey: string,
   parentKey?: VKey,
   parentLevel?: number,
+  parentDisabled?: TreeNodeDisabled,
 ): MergedNode[] {
-  const { disabled, loadChildren } = props
-
+  const { cascaderStrategy, disabled, loadChildren } = props
   const level = isNil(parentLevel) ? -1 : parentLevel
+
   return nodes.map((node, index) =>
     convertMergeNode(
       node,
@@ -102,6 +105,8 @@ export function convertMergeNodes(
       index === 0,
       index === nodes.length - 1,
       level,
+      cascaderStrategy,
+      parentDisabled ? [parentDisabled] : [],
       parentKey,
     ),
   )
@@ -117,10 +122,12 @@ function convertMergeNode(
   isFirst: boolean,
   isLast: boolean,
   level: number,
+  cascaderStrategy: CascaderStrategy,
+  parentsDisabled: TreeNodeDisabled[],
   parentKey?: VKey,
 ): MergedNode {
   const key = getKey(rawNode)
-  const { check, drag, drop, select } = convertDisabled(rawNode, disabled)
+  const nodeDisabled = convertDisabled(rawNode, disabled)
   const subNodes = (rawNode as Record<string, unknown>)[childrenKey] as TreeNode[] | undefined
   const label = rawNode[labelKey] as string
 
@@ -137,24 +144,39 @@ function convertMergeNode(
       index === 0,
       index === subNodes.length - 1,
       level,
+      cascaderStrategy,
+      [nodeDisabled, ...parentsDisabled],
       key,
     ),
   )
+
+  const mergedDisabled = mergeDisabled(
+    nodeDisabled,
+    parentsDisabled,
+    children?.map(child => ({
+      check: child.checkDisabled,
+      drag: child.dragDisabled,
+      drop: child.dropDisabled,
+      select: child.selectDisabled,
+    })) ?? [],
+    cascaderStrategy !== 'off',
+  )
+
   return {
-    children,
     label,
     key,
+    children,
     isFirst,
-    isLeaf: rawNode.isLeaf ?? !(children?.length || hasLoad),
+    isLeaf: rawNode.isLeaf ?? !(subNodes?.length || hasLoad),
     isLast,
     parentKey,
     expanded: false,
     level,
     rawNode,
-    checkDisabled: check,
-    dragDisabled: drag,
-    dropDisabled: drop,
-    selectDisabled: select,
+    checkDisabled: mergedDisabled.check,
+    dragDisabled: mergedDisabled.drag,
+    dropDisabled: mergedDisabled.drop,
+    selectDisabled: mergedDisabled.select,
   }
 }
 
@@ -176,6 +198,28 @@ function convertDisabled(node: TreeNode, disabled?: (node: TreeNode) => boolean
   }
   return { check, drag, drop, select }
 }
+function mergeDisabled(
+  nodeDisabled: TreeNodeDisabled,
+  parentsDisabled: TreeNodeDisabled[],
+  childrenDisabled: TreeNodeDisabled[],
+  cascade: boolean,
+): TreeNodeDisabled {
+  const _mergeDisabled = (name: keyof TreeNodeDisabled) => {
+    return (
+      nodeDisabled[name] ||
+      (cascade &&
+        (parentsDisabled.some(disabled => !!disabled[name]) ||
+          (!!childrenDisabled.length && childrenDisabled.every(disabled => !!disabled[name]))))
+    )
+  }
+
+  return {
+    check: _mergeDisabled('check'),
+    drag: _mergeDisabled('drag'),
+    drop: _mergeDisabled('drop'),
+    select: _mergeDisabled('drag'),
+  }
+}
 
 export function convertMergedNodeMap(mergedNodes: MergedNode[], map: Map<VKey, MergedNode>): void {
   mergedNodes.forEach(item => {

packages/components/tree/src/composables/useExpandable.ts

@@ -100,6 +100,12 @@ export function useExpandable(
           mergedLabelKey.value,
           key,
           level,
+          {
+            check: !!currNode.checkDisabled,
+            drag: !!currNode.dragDisabled,
+            drop: !!currNode.dropDisabled,
+            select: !!currNode.selectDisabled,
+          },
         )
         convertMergedNodeMap(mergedChildren, nodeMap)
         currNode.rawNode[childrenKey] = childrenNodes