feat(cdk/tree): implement the various expansion-related methods

Author: BobobUnicorn

src/cdk/tree/nested-node.ts

@@ -69,18 +69,15 @@ export class CdkNestedTreeNode<T, K = T>
 
   ngAfterContentInit() {
     this._dataDiffer = this._differs.find([]).create(this._tree.trackBy);
-    if (!this._tree.treeControl?.getChildren && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+    const childrenAccessor = this._tree._getChildrenAccessor();
+    if (!childrenAccessor && (typeof ngDevMode === 'undefined' || ngDevMode)) {
       throw getTreeControlFunctionsMissingError();
-    } else if (this._tree.treeControl?.getChildren) {
-      const childrenNodes = this._tree.treeControl.getChildren(this.data);
-      if (Array.isArray(childrenNodes)) {
-        this.updateChildrenNodes(childrenNodes as T[]);
-      } else if (isObservable(childrenNodes)) {
-        childrenNodes
-          .pipe(takeUntil(this._destroyed))
-          .subscribe(result => this.updateChildrenNodes(result));
-      }
-      this.nodeOutlet.changes
+    }
+    const childrenNodes = childrenAccessor?.(this.data);
+    if (Array.isArray(childrenNodes)) {
+      this.updateChildrenNodes(childrenNodes as T[]);
+    } else if (isObservable(childrenNodes)) {
+      childrenNodes
         .pipe(takeUntil(this._destroyed))
         .subscribe(() => this.updateChildrenNodes());
     }

src/cdk/tree/padding.ts

@@ -81,9 +81,7 @@ export class CdkTreeNodePadding<T, K = T> implements OnDestroy {
   /** The padding indent value for the tree node. Returns a string with px numbers if not null. */
   _paddingIndent(): string | null {
     const nodeLevel =
-      this._treeNode.data && this._tree.treeControl?.getLevel
-        ? this._tree.treeControl.getLevel(this._treeNode.data)
-        : null;
+      (this._treeNode.data && this._tree._getLevelAccessor()?.(this._treeNode.data)) ?? null;
     const level = this._level == null ? nodeLevel : this._level;
     return typeof level === 'number' ? `${level * this._indent}${this.indentUnits}` : null;
   }

src/cdk/tree/toggle.ts

@@ -35,8 +35,8 @@ export class CdkTreeNodeToggle<T, K = T> {
 
   _toggle(event: Event): void {
     this.recursive
-      ? this._tree.treeControl?.toggleDescendants(this._treeNode.data)
-      : this._tree.treeControl?.toggle(this._treeNode.data);
+      ? this._tree.toggleDescendants(this._treeNode.data)
+      : this._tree.toggle(this._treeNode.data);
 
     event.stopPropagation();
   }

src/cdk/tree/tree.ts

@@ -29,24 +29,34 @@ import {
 } from '@angular/core';
 import {
   BehaviorSubject,
+  concat,
   isObservable,
+  merge,
   Observable,
   of as observableOf,
   Subject,
   Subscription,
 } from 'rxjs';
-import {takeUntil} from 'rxjs/operators';
+import {reduce, switchMap, take, takeUntil} from 'rxjs/operators';
 import {TreeControl} from './control/tree-control';
 import {CdkTreeNodeDef, CdkTreeNodeOutletContext} from './node';
 import {CdkTreeNodeOutlet} from './outlet';
 import {
   getMultipleTreeControlsError,
+  getTreeControlFunctionsMissingError,
   getTreeControlMissingError,
   getTreeMissingMatchingNodeDefError,
   getTreeMultipleDefaultNodeDefsError,
   getTreeNoValidDataSourceError,
 } from './tree-errors';
-import {coerceNumberProperty} from '@angular/cdk/coercion';
+import {BooleanInput, coerceNumberProperty} from '@angular/cdk/coercion';
+
+function coerceObservable<T>(data: T | Observable<T>): Observable<T> {
+  if (!isObservable(data)) {
+    return observableOf(data);
+  }
+  return data;
+}
 
 /**
  * CDK tree component that connects with a data source to retrieve data of type `T` and renders
@@ -357,52 +367,111 @@ export class CdkTree<T, K = T> implements AfterContentChecked, CollectionViewer,
 
   /** Whether the data node is expanded or collapsed. Returns true if it's expanded. */
   isExpanded(dataNode: T): boolean {
-    throw new Error('not implemented');
+    return (
+      this.treeControl?.isExpanded(dataNode) ??
+      this._expansionModel?.isSelected(this._trackExpansionKey(dataNode)) ??
+      false
+    );
   }
 
   /** If the data node is currently expanded, collapse it. Otherwise, expand it. */
   toggle(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.toggle(dataNode);
+    } else if (this._expansionModel) {
+      this._expansionModel.toggle(this._trackExpansionKey(dataNode));
+    }
   }
 
   /** Expand the data node. If it is already expanded, does nothing. */
   expand(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.expand(dataNode);
+    } else if (this._expansionModel) {
+      this._expansionModel.select(this._trackExpansionKey(dataNode));
+    }
   }
 
   /** Collapse the data node. If it is already collapsed, does nothing. */
   collapse(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.collapse(dataNode);
+    } else if (this._expansionModel) {
+      this._expansionModel.deselect(this._trackExpansionKey(dataNode));
+    }
   }
 
   /**
    * If the data node is currently expanded, collapse it and all its descendants.
    * Otherwise, expand it and all its descendants.
    */
   toggleDescendants(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.toggleDescendants(dataNode);
+    } else if (this._expansionModel) {
+      if (this.isExpanded(dataNode)) {
+        this.collapseDescendants(dataNode);
+      } else {
+        this.expandDescendants(dataNode);
+      }
+    }
   }
 
   /**
-   * Expand the data node and all its descendants. If they are already expanded, does nothing.
-   */
+   * Expand the data node and all its descendants. If they are already expanded, does nothing. */
   expandDescendants(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.expandDescendants(dataNode);
+    } else if (this._expansionModel) {
+      const expansionModel = this._expansionModel;
+      this._getDescendants(dataNode)
+        .pipe(takeUntil(this._onDestroy))
+        .subscribe(children => {
+          expansionModel.select(...children.map(child => this._trackExpansionKey(child)));
+        });
+    }
   }
 
   /** Collapse the data node and all its descendants. If it is already collapsed, does nothing. */
   collapseDescendants(dataNode: T): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.collapseDescendants(dataNode);
+    } else if (this._expansionModel) {
+      const expansionModel = this._expansionModel;
+      this._getDescendants(dataNode)
+        .pipe(takeUntil(this._onDestroy))
+        .subscribe(children => {
+          expansionModel.deselect(...children.map(child => this._trackExpansionKey(child)));
+        });
+    }
   }
 
   /** Expands all data nodes in the tree. */
   expandAll(): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.expandAll();
+    } else if (this._expansionModel) {
+      const expansionModel = this._expansionModel;
+      this._getAllDescendants()
+        .pipe(takeUntil(this._onDestroy))
+        .subscribe(children => {
+          expansionModel.select(...children.map(child => this._trackExpansionKey(child)));
+        });
+    }
   }
 
   /** Collapse all data nodes in the tree. */
   collapseAll(): void {
-    throw new Error('not implemented');
+    if (this.treeControl) {
+      this.treeControl.collapseAll();
+    } else if (this._expansionModel) {
+      const expansionModel = this._expansionModel;
+      this._getAllDescendants()
+        .pipe(takeUntil(this._onDestroy))
+        .subscribe(children => {
+          expansionModel.deselect(...children.map(child => this._trackExpansionKey(child)));
+        });
+    }
   }
 
   /** Level accessor, used for compatibility between the old Tree and new Tree */
@@ -414,6 +483,72 @@ export class CdkTree<T, K = T> implements AfterContentChecked, CollectionViewer,
   _getChildrenAccessor() {
     return this.treeControl?.getChildren ?? this.childrenAccessor;
   }
+
+  private _getAllDescendants(): Observable<T[]> {
+    return merge(...(this._dataNodes?.map(dataNode => this._getDescendants(dataNode)) ?? []));
+  }
+
+  private _getDescendants(dataNode: T): Observable<T[]> {
+    if (this.treeControl) {
+      return observableOf(this.treeControl.getDescendants(dataNode));
+    }
+    if (this.levelAccessor) {
+      // If we have no known nodes, we wouldn't be able to determine descendants
+      if (!this._dataNodes) {
+        return observableOf([]);
+      }
+      const startIndex = this._dataNodes.indexOf(dataNode);
+      const results: T[] = [dataNode];
+
+      // Goes through flattened tree nodes in the `dataNodes` array, and get all descendants.
+      // The level of descendants of a tree node must be greater than the level of the given
+      // tree node.
+      // If we reach a node whose level is equal to the level of the tree node, we hit a sibling.
+      // If we reach a node whose level is greater than the level of the tree node, we hit a
+      // sibling of an ancestor.
+      const currentLevel = this.levelAccessor(dataNode);
+      for (
+        let i = startIndex + 1;
+        i < this._dataNodes.length && currentLevel < this.levelAccessor(this._dataNodes[i]);
+        i++
+      ) {
+        results.push(this._dataNodes[i]);
+      }
+      return observableOf(results);
+    }
+    if (this.childrenAccessor) {
+      return this._getChildrenRecursively(dataNode).pipe(
+        reduce(
+          (memo: T[], next) => {
+            memo.push(...next);
+            return memo;
+          },
+          [dataNode],
+        ),
+      );
+    }
+    throw getTreeControlMissingError();
+  }
+
+  private _getChildrenRecursively(dataNode: T): Observable<T[]> {
+    if (!this.childrenAccessor) {
+      return observableOf([]);
+    }
+
+    return coerceObservable(this.childrenAccessor(dataNode)).pipe(
+      take(1),
+      switchMap(children => {
+        return concat(
+          observableOf(children),
+          ...children.map(child => this._getChildrenRecursively(child)),
+        );
+      }),
+    );
+  }
+
+  private _trackExpansionKey(dataNode: T): K {
+    return this.expansionKey?.(dataNode) ?? (dataNode as unknown as K);
+  }
 }
 
 /**