@angular/cdk 18.1.1 → 18.2.0-next.1

package/esm2022/tree/tree.mjs

@@ -1,11 +1,22 @@
-import { isDataSource } from '@angular/cdk/collections';
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, Directive, ElementRef, Input, IterableDiffers, QueryList, ViewChild, ViewEncapsulation, inject, numberAttribute, } from '@angular/core';
-import { BehaviorSubject, Subject, isObservable, of as observableOf, } from 'rxjs';
-import { distinctUntilChanged, map, takeUntil } from 'rxjs/operators';
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { TREE_KEY_MANAGER, } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { isDataSource, SelectionModel, } from '@angular/cdk/collections';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, Directive, ElementRef, EventEmitter, Input, IterableDiffers, Output, QueryList, ViewChild, ViewEncapsulation, numberAttribute, inject, booleanAttribute, } from '@angular/core';
+import { coerceObservable } from '@angular/cdk/coercion/private';
+import { BehaviorSubject, combineLatest, concat, EMPTY, Subject, isObservable, of as observableOf, } from 'rxjs';
+import { distinctUntilChanged, concatMap, map, reduce, startWith, switchMap, take, takeUntil, tap, } from 'rxjs/operators';
 import { CdkTreeNodeDef, CdkTreeNodeOutletContext } from './node';
 import { CdkTreeNodeOutlet } from './outlet';
-import { getTreeControlFunctionsMissingError, getTreeControlMissingError, getTreeMissingMatchingNodeDefError, getTreeMultipleDefaultNodeDefsError, getTreeNoValidDataSourceError, } from './tree-errors';
+import { getMultipleTreeControlsError, getTreeControlMissingError, getTreeMissingMatchingNodeDefError, getTreeMultipleDefaultNodeDefsError, getTreeNoValidDataSourceError, } from './tree-errors';
 import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
 /**
  * CDK tree component that connects with a data source to retrieve data of type `T` and renders
  * dataNodes with hierarchy. Updates the dataNodes when new data is provided by the data source.
@@ -24,13 +35,25 @@ export class CdkTree {
             this._switchDataSource(dataSource);
         }
     }
-    constructor(_differs, _changeDetectorRef) {
+    constructor(_differs, _changeDetectorRef, _dir) {
         this._differs = _differs;
         this._changeDetectorRef = _changeDetectorRef;
+        this._dir = _dir;
         /** Subject that emits when the component has been destroyed. */
         this._onDestroy = new Subject();
         /** Level of nodes */
         this._levels = new Map();
+        /** The immediate parents for a node. This is `null` if there is no parent. */
+        this._parents = new Map();
+        /**
+         * Nodes grouped into each set, which is a list of nodes displayed together in the DOM.
+         *
+         * Lookup key is the parent of a set. Root nodes have key of null.
+         *
+         * Values is a 'set' of tree nodes. Each tree node maps to a treeitem element. Sets are in the
+         * order that it is rendered. Each set maps directly to aria-posinset and aria-setsize attributes.
+         */
+        this._ariaSets = new Map();
         // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.
         //     Remove the MAX_VALUE in viewChange
         /**
@@ -41,12 +64,31 @@ export class CdkTree {
             start: 0,
             end: Number.MAX_VALUE,
         });
+        /**
+         * Maintain a synchronous cache of flattened data nodes. This will only be
+         * populated after initial render, and in certain cases, will be delayed due to
+         * relying on Observable `getChildren` calls.
+         */
+        this._flattenedNodes = new BehaviorSubject([]);
+        /** The automatically determined node type for the tree. */
+        this._nodeType = new BehaviorSubject(null);
+        /** The mapping between data and the node that is rendered. */
+        this._nodes = new BehaviorSubject(new Map());
+        /**
+         * Synchronous cache of nodes for the `TreeKeyManager`. This is separate
+         * from `_flattenedNodes` so they can be independently updated at different
+         * times.
+         */
+        this._keyManagerNodes = new BehaviorSubject([]);
+        this._keyManagerFactory = inject(TREE_KEY_MANAGER);
+        this._viewInit = false;
     }
-    ngOnInit() {
-        this._dataDiffer = this._differs.find([]).create(this.trackBy);
-        if (!this.treeControl && (typeof ngDevMode === 'undefined' || ngDevMode)) {
-            throw getTreeControlMissingError();
-        }
+    ngAfterContentInit() {
+        this._initializeKeyManager();
+    }
+    ngAfterContentChecked() {
+        this._updateDefaultNodeDefinition();
+        this._subscribeToDataChanges();
     }
     ngOnDestroy() {
         this._nodeOutlet.viewContainer.clear();
@@ -60,19 +102,35 @@ export class CdkTree {
             this._dataSubscription.unsubscribe();
             this._dataSubscription = null;
         }
+        // In certain tests, the tree might be destroyed before this is initialized
+        // in `ngAfterContentInit`.
+        this._keyManager?.destroy();
     }
-    ngAfterContentChecked() {
+    ngOnInit() {
+        this._checkTreeControlUsage();
+        this._initializeDataDiffer();
+    }
+    ngAfterViewInit() {
+        this._viewInit = true;
+    }
+    _updateDefaultNodeDefinition() {
         const defaultNodeDefs = this._nodeDefs.filter(def => !def.when);
         if (defaultNodeDefs.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {
             throw getTreeMultipleDefaultNodeDefsError();
         }
         this._defaultNodeDef = defaultNodeDefs[0];
-        if (this.dataSource && this._nodeDefs && !this._dataSubscription) {
-            this._observeRenderChanges();
+    }
+    /**
+     * Sets the node type for the tree, if it hasn't been set yet.
+     *
+     * This will be called by the first node that's rendered in order for the tree
+     * to determine what data transformations are required.
+     */
+    _setNodeTypeIfUnset(nodeType) {
+        if (this._nodeType.value === null) {
+            this._nodeType.next(nodeType);
         }
     }
-    // TODO(tinayuangao): Work on keyboard traversal and actions, make sure it's working for RTL
-    //     and nested trees.
     /**
      * Switch to the provided data source by resetting the data and unsubscribing from the current
      * render change subscription if one exists. If the data source is null, interpret this by
@@ -92,11 +150,21 @@ export class CdkTree {
         }
         this._dataSource = dataSource;
         if (this._nodeDefs) {
-            this._observeRenderChanges();
+            this._subscribeToDataChanges();
         }
     }
+    _getExpansionModel() {
+        if (!this.treeControl) {
+            this._expansionModel ??= new SelectionModel(true);
+            return this._expansionModel;
+        }
+        return this.treeControl.expansionModel;
+    }
     /** Set up a subscription for the data provided by the data source. */
-    _observeRenderChanges() {
+    _subscribeToDataChanges() {
+        if (this._dataSubscription) {
+            return;
+        }
         let dataStream;
         if (isDataSource(this._dataSource)) {
             dataStream = this._dataSource.connect(this);
@@ -107,34 +175,140 @@ export class CdkTree {
         else if (Array.isArray(this._dataSource)) {
             dataStream = observableOf(this._dataSource);
         }
-        if (dataStream) {
-            this._dataSubscription = dataStream
-                .pipe(takeUntil(this._onDestroy))
-                .subscribe(data => this.renderNodeChanges(data));
+        if (!dataStream) {
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                throw getTreeNoValidDataSourceError();
+            }
+            return;
+        }
+        this._dataSubscription = this._getRenderData(dataStream)
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe(renderingData => {
+            this._renderDataChanges(renderingData);
+        });
+    }
+    /** Given an Observable containing a stream of the raw data, returns an Observable containing the RenderingData */
+    _getRenderData(dataStream) {
+        const expansionModel = this._getExpansionModel();
+        return combineLatest([
+            dataStream,
+            this._nodeType,
+            // We don't use the expansion data directly, however we add it here to essentially
+            // trigger data rendering when expansion changes occur.
+            expansionModel.changed.pipe(startWith(null), tap(expansionChanges => {
+                this._emitExpansionChanges(expansionChanges);
+            })),
+        ]).pipe(switchMap(([data, nodeType]) => {
+            if (nodeType === null) {
+                return observableOf({ renderNodes: data, flattenedNodes: null, nodeType });
+            }
+            // If we're here, then we know what our node type is, and therefore can
+            // perform our usual rendering pipeline, which necessitates converting the data
+            return this._computeRenderingData(data, nodeType).pipe(map(convertedData => ({ ...convertedData, nodeType })));
+        }));
+    }
+    _renderDataChanges(data) {
+        if (data.nodeType === null) {
+            this.renderNodeChanges(data.renderNodes);
+            return;
         }
-        else if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            throw getTreeNoValidDataSourceError();
+        // If we're here, then we know what our node type is, and therefore can
+        // perform our usual rendering pipeline.
+        this._updateCachedData(data.flattenedNodes);
+        this.renderNodeChanges(data.renderNodes);
+        this._updateKeyManagerItems(data.flattenedNodes);
+    }
+    _emitExpansionChanges(expansionChanges) {
+        if (!expansionChanges) {
+            return;
+        }
+        const nodes = this._nodes.value;
+        for (const added of expansionChanges.added) {
+            const node = nodes.get(added);
+            node?._emitExpansionState(true);
+        }
+        for (const removed of expansionChanges.removed) {
+            const node = nodes.get(removed);
+            node?._emitExpansionState(false);
+        }
+    }
+    _initializeKeyManager() {
+        const items = combineLatest([this._keyManagerNodes, this._nodes]).pipe(map(([keyManagerNodes, renderNodes]) => keyManagerNodes.reduce((items, data) => {
+            const node = renderNodes.get(this._getExpansionKey(data));
+            if (node) {
+                items.push(node);
+            }
+            return items;
+        }, [])));
+        const keyManagerOptions = {
+            trackBy: node => this._getExpansionKey(node.data),
+            skipPredicate: node => !!node.isDisabled,
+            typeAheadDebounceInterval: true,
+            horizontalOrientation: this._dir.value,
+        };
+        this._keyManager = this._keyManagerFactory(items, keyManagerOptions);
+    }
+    _initializeDataDiffer() {
+        // Provide a default trackBy based on `_getExpansionKey` if one isn't provided.
+        const trackBy = this.trackBy ?? ((_index, item) => this._getExpansionKey(item));
+        this._dataDiffer = this._differs.find([]).create(trackBy);
+    }
+    _checkTreeControlUsage() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            // Verify that Tree follows API contract of using one of TreeControl, levelAccessor or
+            // childrenAccessor. Throw an appropriate error if contract is not met.
+            let numTreeControls = 0;
+            if (this.treeControl) {
+                numTreeControls++;
+            }
+            if (this.levelAccessor) {
+                numTreeControls++;
+            }
+            if (this.childrenAccessor) {
+                numTreeControls++;
+            }
+            if (!numTreeControls) {
+                throw getTreeControlMissingError();
+            }
+            else if (numTreeControls > 1) {
+                throw getMultipleTreeControlsError();
+            }
         }
     }
     /** Check for changes made in the data and render each change (node added/removed/moved). */
     renderNodeChanges(data, dataDiffer = this._dataDiffer, viewContainer = this._nodeOutlet.viewContainer, parentData) {
         const changes = dataDiffer.diff(data);
-        if (!changes) {
+        // Some tree consumers expect change detection to propagate to nodes
+        // even when the array itself hasn't changed; we explicitly detect changes
+        // anyways in order for nodes to update their data.
+        //
+        // However, if change detection is called while the component's view is
+        // still initing, then the order of child views initing will be incorrect;
+        // to prevent this, we only exit early if the view hasn't initialized yet.
+        if (!changes && !this._viewInit) {
             return;
         }
-        changes.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {
+        changes?.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {
             if (item.previousIndex == null) {
                 this.insertNode(data[currentIndex], currentIndex, viewContainer, parentData);
             }
             else if (currentIndex == null) {
                 viewContainer.remove(adjustedPreviousIndex);
-                this._levels.delete(item.item);
             }
             else {
                 const view = viewContainer.get(adjustedPreviousIndex);
                 viewContainer.move(view, currentIndex);
             }
         });
+        // If the data itself changes, but keeps the same trackBy, we need to update the templates'
+        // context to reflect the new object.
+        changes?.forEachIdentityChange((record) => {
+            const newData = record.item;
+            if (record.currentIndex != undefined) {
+                const view = viewContainer.get(record.currentIndex);
+                view.context.$implicit = newData;
+            }
+        });
         // TODO: change to `this._changeDetectorRef.markForCheck()`, or just switch this component to
         // use signals.
         this._changeDetectorRef.detectChanges();
@@ -160,21 +334,24 @@ export class CdkTree {
      * within the data node view container.
      */
     insertNode(nodeData, index, viewContainer, parentData) {
+        const levelAccessor = this._getLevelAccessor();
         const node = this._getNodeDef(nodeData, index);
+        const key = this._getExpansionKey(nodeData);
         // Node context that will be provided to created embedded view
         const context = new CdkTreeNodeOutletContext(nodeData);
+        parentData ??= this._parents.get(key) ?? undefined;
         // If the tree is flat tree, then use the `getLevel` function in flat tree control
         // Otherwise, use the level of parent node.
-        if (this.treeControl.getLevel) {
-            context.level = this.treeControl.getLevel(nodeData);
+        if (levelAccessor) {
+            context.level = levelAccessor(nodeData);
         }
-        else if (typeof parentData !== 'undefined' && this._levels.has(parentData)) {
-            context.level = this._levels.get(parentData) + 1;
+        else if (parentData !== undefined && this._levels.has(this._getExpansionKey(parentData))) {
+            context.level = this._levels.get(this._getExpansionKey(parentData)) + 1;
         }
         else {
             context.level = 0;
         }
-        this._levels.set(nodeData, context.level);
+        this._levels.set(key, context.level);
         // Use default tree nodeOutlet, or nested node's nodeOutlet
         const container = viewContainer ? viewContainer : this._nodeOutlet.viewContainer;
         container.createEmbeddedView(node.template, context, index);
@@ -185,8 +362,427 @@ export class CdkTree {
             CdkTreeNode.mostRecentTreeNode.data = nodeData;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CdkTree, deps: [{ token: i0.IterableDiffers }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.0", type: CdkTree, isStandalone: true, selector: "cdk-tree", inputs: { dataSource: "dataSource", treeControl: "treeControl", trackBy: "trackBy" }, host: { attributes: { "role": "tree" }, classAttribute: "cdk-tree" }, queries: [{ propertyName: "_nodeDefs", predicate: CdkTreeNodeDef, descendants: true }], viewQueries: [{ propertyName: "_nodeOutlet", first: true, predicate: CdkTreeNodeOutlet, descendants: true, static: true }], exportAs: ["cdkTree"], ngImport: i0, template: `<ng-container cdkTreeNodeOutlet></ng-container>`, isInline: true, dependencies: [{ kind: "directive", type: CdkTreeNodeOutlet, selector: "[cdkTreeNodeOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None }); }
+    /** Whether the data node is expanded or collapsed. Returns true if it's expanded. */
+    isExpanded(dataNode) {
+        return !!(this.treeControl?.isExpanded(dataNode) ||
+            this._expansionModel?.isSelected(this._getExpansionKey(dataNode)));
+    }
+    /** If the data node is currently expanded, collapse it. Otherwise, expand it. */
+    toggle(dataNode) {
+        if (this.treeControl) {
+            this.treeControl.toggle(dataNode);
+        }
+        else if (this._expansionModel) {
+            this._expansionModel.toggle(this._getExpansionKey(dataNode));
+        }
+    }
+    /** Expand the data node. If it is already expanded, does nothing. */
+    expand(dataNode) {
+        if (this.treeControl) {
+            this.treeControl.expand(dataNode);
+        }
+        else if (this._expansionModel) {
+            this._expansionModel.select(this._getExpansionKey(dataNode));
+        }
+    }
+    /** Collapse the data node. If it is already collapsed, does nothing. */
+    collapse(dataNode) {
+        if (this.treeControl) {
+            this.treeControl.collapse(dataNode);
+        }
+        else if (this._expansionModel) {
+            this._expansionModel.deselect(this._getExpansionKey(dataNode));
+        }
+    }
+    /**
+     * If the data node is currently expanded, collapse it and all its descendants.
+     * Otherwise, expand it and all its descendants.
+     */
+    toggleDescendants(dataNode) {
+        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.
+     */
+    expandDescendants(dataNode) {
+        if (this.treeControl) {
+            this.treeControl.expandDescendants(dataNode);
+        }
+        else if (this._expansionModel) {
+            const expansionModel = this._expansionModel;
+            expansionModel.select(this._getExpansionKey(dataNode));
+            this._getDescendants(dataNode)
+                .pipe(take(1), takeUntil(this._onDestroy))
+                .subscribe(children => {
+                expansionModel.select(...children.map(child => this._getExpansionKey(child)));
+            });
+        }
+    }
+    /** Collapse the data node and all its descendants. If it is already collapsed, does nothing. */
+    collapseDescendants(dataNode) {
+        if (this.treeControl) {
+            this.treeControl.collapseDescendants(dataNode);
+        }
+        else if (this._expansionModel) {
+            const expansionModel = this._expansionModel;
+            expansionModel.deselect(this._getExpansionKey(dataNode));
+            this._getDescendants(dataNode)
+                .pipe(take(1), takeUntil(this._onDestroy))
+                .subscribe(children => {
+                expansionModel.deselect(...children.map(child => this._getExpansionKey(child)));
+            });
+        }
+    }
+    /** Expands all data nodes in the tree. */
+    expandAll() {
+        if (this.treeControl) {
+            this.treeControl.expandAll();
+        }
+        else if (this._expansionModel) {
+            const expansionModel = this._expansionModel;
+            expansionModel.select(...this._flattenedNodes.value.map(child => this._getExpansionKey(child)));
+        }
+    }
+    /** Collapse all data nodes in the tree. */
+    collapseAll() {
+        if (this.treeControl) {
+            this.treeControl.collapseAll();
+        }
+        else if (this._expansionModel) {
+            const expansionModel = this._expansionModel;
+            expansionModel.deselect(...this._flattenedNodes.value.map(child => this._getExpansionKey(child)));
+        }
+    }
+    /** Level accessor, used for compatibility between the old Tree and new Tree */
+    _getLevelAccessor() {
+        return this.treeControl?.getLevel?.bind(this.treeControl) ?? this.levelAccessor;
+    }
+    /** Children accessor, used for compatibility between the old Tree and new Tree */
+    _getChildrenAccessor() {
+        return this.treeControl?.getChildren?.bind(this.treeControl) ?? this.childrenAccessor;
+    }
+    /**
+     * Gets the direct children of a node; used for compatibility between the old tree and the
+     * new tree.
+     */
+    _getDirectChildren(dataNode) {
+        const levelAccessor = this._getLevelAccessor();
+        const expansionModel = this._expansionModel ?? this.treeControl?.expansionModel;
+        if (!expansionModel) {
+            return observableOf([]);
+        }
+        const key = this._getExpansionKey(dataNode);
+        const isExpanded = expansionModel.changed.pipe(switchMap(changes => {
+            if (changes.added.includes(key)) {
+                return observableOf(true);
+            }
+            else if (changes.removed.includes(key)) {
+                return observableOf(false);
+            }
+            return EMPTY;
+        }), startWith(this.isExpanded(dataNode)));
+        if (levelAccessor) {
+            return combineLatest([isExpanded, this._flattenedNodes]).pipe(map(([expanded, flattenedNodes]) => {
+                if (!expanded) {
+                    return [];
+                }
+                return this._findChildrenByLevel(levelAccessor, flattenedNodes, dataNode, 1);
+            }));
+        }
+        const childrenAccessor = this._getChildrenAccessor();
+        if (childrenAccessor) {
+            return coerceObservable(childrenAccessor(dataNode) ?? []);
+        }
+        throw getTreeControlMissingError();
+    }
+    /**
+     * Given the list of flattened nodes, the level accessor, and the level range within
+     * which to consider children, finds the children for a given node.
+     *
+     * For example, for direct children, `levelDelta` would be 1. For all descendants,
+     * `levelDelta` would be Infinity.
+     */
+    _findChildrenByLevel(levelAccessor, flattenedNodes, dataNode, levelDelta) {
+        const key = this._getExpansionKey(dataNode);
+        const startIndex = flattenedNodes.findIndex(node => this._getExpansionKey(node) === key);
+        const dataNodeLevel = levelAccessor(dataNode);
+        const expectedLevel = dataNodeLevel + levelDelta;
+        const results = [];
+        // Goes through flattened tree nodes in the `flattenedNodes` array, and get all
+        // descendants within a certain level range.
+        //
+        // If we reach a node whose level is equal to or less than the level of the tree node,
+        // we hit a sibling or parent's sibling, and should stop.
+        for (let i = startIndex + 1; i < flattenedNodes.length; i++) {
+            const currentLevel = levelAccessor(flattenedNodes[i]);
+            if (currentLevel <= dataNodeLevel) {
+                break;
+            }
+            if (currentLevel <= expectedLevel) {
+                results.push(flattenedNodes[i]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Adds the specified node component to the tree's internal registry.
+     *
+     * This primarily facilitates keyboard navigation.
+     */
+    _registerNode(node) {
+        this._nodes.value.set(this._getExpansionKey(node.data), node);
+        this._nodes.next(this._nodes.value);
+    }
+    /** Removes the specified node component from the tree's internal registry. */
+    _unregisterNode(node) {
+        this._nodes.value.delete(this._getExpansionKey(node.data));
+        this._nodes.next(this._nodes.value);
+    }
+    /**
+     * For the given node, determine the level where this node appears in the tree.
+     *
+     * This is intended to be used for `aria-level` but is 0-indexed.
+     */
+    _getLevel(node) {
+        return this._levels.get(this._getExpansionKey(node));
+    }
+    /**
+     * For the given node, determine the size of the parent's child set.
+     *
+     * This is intended to be used for `aria-setsize`.
+     */
+    _getSetSize(dataNode) {
+        const set = this._getAriaSet(dataNode);
+        return set.length;
+    }
+    /**
+     * For the given node, determine the index (starting from 1) of the node in its parent's child set.
+     *
+     * This is intended to be used for `aria-posinset`.
+     */
+    _getPositionInSet(dataNode) {
+        const set = this._getAriaSet(dataNode);
+        const key = this._getExpansionKey(dataNode);
+        return set.findIndex(node => this._getExpansionKey(node) === key) + 1;
+    }
+    /** Given a CdkTreeNode, gets the node that renders that node's parent's data. */
+    _getNodeParent(node) {
+        const parent = this._parents.get(this._getExpansionKey(node.data));
+        return parent && this._nodes.value.get(this._getExpansionKey(parent));
+    }
+    /** Given a CdkTreeNode, gets the nodes that renders that node's child data. */
+    _getNodeChildren(node) {
+        return this._getDirectChildren(node.data).pipe(map(children => children.reduce((nodes, child) => {
+            const value = this._nodes.value.get(this._getExpansionKey(child));
+            if (value) {
+                nodes.push(value);
+            }
+            return nodes;
+        }, [])));
+    }
+    /** `keydown` event handler; this just passes the event to the `TreeKeyManager`. */
+    _sendKeydownToKeyManager(event) {
+        this._keyManager.onKeydown(event);
+    }
+    /** Gets all nested descendants of a given node. */
+    _getDescendants(dataNode) {
+        if (this.treeControl) {
+            return observableOf(this.treeControl.getDescendants(dataNode));
+        }
+        if (this.levelAccessor) {
+            const results = this._findChildrenByLevel(this.levelAccessor, this._flattenedNodes.value, dataNode, Infinity);
+            return observableOf(results);
+        }
+        if (this.childrenAccessor) {
+            return this._getAllChildrenRecursively(dataNode).pipe(reduce((allChildren, nextChildren) => {
+                allChildren.push(...nextChildren);
+                return allChildren;
+            }, []));
+        }
+        throw getTreeControlMissingError();
+    }
+    /**
+     * Gets all children and sub-children of the provided node.
+     *
+     * This will emit multiple times, in the order that the children will appear
+     * in the tree, and can be combined with a `reduce` operator.
+     */
+    _getAllChildrenRecursively(dataNode) {
+        if (!this.childrenAccessor) {
+            return observableOf([]);
+        }
+        return coerceObservable(this.childrenAccessor(dataNode)).pipe(take(1), switchMap(children => {
+            // Here, we cache the parents of a particular child so that we can compute the levels.
+            for (const child of children) {
+                this._parents.set(this._getExpansionKey(child), dataNode);
+            }
+            return observableOf(...children).pipe(concatMap(child => concat(observableOf([child]), this._getAllChildrenRecursively(child))));
+        }));
+    }
+    _getExpansionKey(dataNode) {
+        // In the case that a key accessor function was not provided by the
+        // tree user, we'll default to using the node object itself as the key.
+        //
+        // This cast is safe since:
+        // - if an expansionKey is provided, TS will infer the type of K to be
+        //   the return type.
+        // - if it's not, then K will be defaulted to T.
+        return this.expansionKey?.(dataNode) ?? dataNode;
+    }
+    _getAriaSet(node) {
+        const key = this._getExpansionKey(node);
+        const parent = this._parents.get(key);
+        const parentKey = parent ? this._getExpansionKey(parent) : null;
+        const set = this._ariaSets.get(parentKey);
+        return set ?? [node];
+    }
+    /**
+     * Finds the parent for the given node. If this is a root node, this
+     * returns null. If we're unable to determine the parent, for example,
+     * if we don't have cached node data, this returns undefined.
+     */
+    _findParentForNode(node, index, cachedNodes) {
+        // In all cases, we have a mapping from node to level; all we need to do here is backtrack in
+        // our flattened list of nodes to determine the first node that's of a level lower than the
+        // provided node.
+        if (!cachedNodes.length) {
+            return null;
+        }
+        const currentLevel = this._levels.get(this._getExpansionKey(node)) ?? 0;
+        for (let parentIndex = index - 1; parentIndex >= 0; parentIndex--) {
+            const parentNode = cachedNodes[parentIndex];
+            const parentLevel = this._levels.get(this._getExpansionKey(parentNode)) ?? 0;
+            if (parentLevel < currentLevel) {
+                return parentNode;
+            }
+        }
+        return null;
+    }
+    /**
+     * Given a set of root nodes and the current node level, flattens any nested
+     * nodes into a single array.
+     *
+     * If any nodes are not expanded, then their children will not be added into the array.
+     * This will still traverse all nested children in order to build up our internal data
+     * models, but will not include them in the returned array.
+     */
+    _flattenNestedNodesWithExpansion(nodes, level = 0) {
+        const childrenAccessor = this._getChildrenAccessor();
+        // If we're using a level accessor, we don't need to flatten anything.
+        if (!childrenAccessor) {
+            return observableOf([...nodes]);
+        }
+        return observableOf(...nodes).pipe(concatMap(node => {
+            const parentKey = this._getExpansionKey(node);
+            if (!this._parents.has(parentKey)) {
+                this._parents.set(parentKey, null);
+            }
+            this._levels.set(parentKey, level);
+            const children = coerceObservable(childrenAccessor(node));
+            return concat(observableOf([node]), children.pipe(take(1), tap(childNodes => {
+                this._ariaSets.set(parentKey, [...(childNodes ?? [])]);
+                for (const child of childNodes ?? []) {
+                    const childKey = this._getExpansionKey(child);
+                    this._parents.set(childKey, node);
+                    this._levels.set(childKey, level + 1);
+                }
+            }), switchMap(childNodes => {
+                if (!childNodes) {
+                    return observableOf([]);
+                }
+                return this._flattenNestedNodesWithExpansion(childNodes, level + 1).pipe(map(nestedNodes => (this.isExpanded(node) ? nestedNodes : [])));
+            })));
+        }), reduce((results, children) => {
+            results.push(...children);
+            return results;
+        }, []));
+    }
+    /**
+     * Converts children for certain tree configurations.
+     *
+     * This also computes parent, level, and group data.
+     */
+    _computeRenderingData(nodes, nodeType) {
+        // The only situations where we have to convert children types is when
+        // they're mismatched; i.e. if the tree is using a childrenAccessor and the
+        // nodes are flat, or if the tree is using a levelAccessor and the nodes are
+        // nested.
+        if (this.childrenAccessor && nodeType === 'flat') {
+            // This flattens children into a single array.
+            this._ariaSets.set(null, [...nodes]);
+            return this._flattenNestedNodesWithExpansion(nodes).pipe(map(flattenedNodes => ({
+                renderNodes: flattenedNodes,
+                flattenedNodes,
+            })));
+        }
+        else if (this.levelAccessor && nodeType === 'nested') {
+            // In the nested case, we only look for root nodes. The CdkNestedNode
+            // itself will handle rendering each individual node's children.
+            const levelAccessor = this.levelAccessor;
+            return observableOf(nodes.filter(node => levelAccessor(node) === 0)).pipe(map(rootNodes => ({
+                renderNodes: rootNodes,
+                flattenedNodes: nodes,
+            })), tap(({ flattenedNodes }) => {
+                this._calculateParents(flattenedNodes);
+            }));
+        }
+        else if (nodeType === 'flat') {
+            // In the case of a TreeControl, we know that the node type matches up
+            // with the TreeControl, and so no conversions are necessary. Otherwise,
+            // we've already confirmed that the data model matches up with the
+            // desired node type here.
+            return observableOf({ renderNodes: nodes, flattenedNodes: nodes }).pipe(tap(({ flattenedNodes }) => {
+                this._calculateParents(flattenedNodes);
+            }));
+        }
+        else {
+            // For nested nodes, we still need to perform the node flattening in order
+            // to maintain our caches for various tree operations.
+            this._ariaSets.set(null, [...nodes]);
+            return this._flattenNestedNodesWithExpansion(nodes).pipe(map(flattenedNodes => ({
+                renderNodes: nodes,
+                flattenedNodes,
+            })));
+        }
+    }
+    _updateCachedData(flattenedNodes) {
+        this._flattenedNodes.next(flattenedNodes);
+    }
+    _updateKeyManagerItems(flattenedNodes) {
+        this._keyManagerNodes.next(flattenedNodes);
+    }
+    /** Traverse the flattened node data and compute parents, levels, and group data. */
+    _calculateParents(flattenedNodes) {
+        const levelAccessor = this._getLevelAccessor();
+        if (!levelAccessor) {
+            return;
+        }
+        this._parents.clear();
+        this._ariaSets.clear();
+        for (let index = 0; index < flattenedNodes.length; index++) {
+            const dataNode = flattenedNodes[index];
+            const key = this._getExpansionKey(dataNode);
+            this._levels.set(key, levelAccessor(dataNode));
+            const parent = this._findParentForNode(dataNode, index, flattenedNodes);
+            this._parents.set(key, parent);
+            const parentKey = parent ? this._getExpansionKey(parent) : null;
+            const group = this._ariaSets.get(parentKey) ?? [];
+            group.splice(index, 0, dataNode);
+            this._ariaSets.set(parentKey, group);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CdkTree, deps: [{ token: i0.IterableDiffers }, { token: i0.ChangeDetectorRef }, { token: i1.Directionality }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.0", type: CdkTree, isStandalone: true, selector: "cdk-tree", inputs: { dataSource: "dataSource", treeControl: "treeControl", levelAccessor: "levelAccessor", childrenAccessor: "childrenAccessor", trackBy: "trackBy", expansionKey: "expansionKey" }, host: { attributes: { "role": "tree" }, listeners: { "keydown": "_sendKeydownToKeyManager($event)" }, classAttribute: "cdk-tree" }, queries: [{ propertyName: "_nodeDefs", predicate: CdkTreeNodeDef, descendants: true }], viewQueries: [{ propertyName: "_nodeOutlet", first: true, predicate: CdkTreeNodeOutlet, descendants: true, static: true }], exportAs: ["cdkTree"], ngImport: i0, template: `<ng-container cdkTreeNodeOutlet></ng-container>`, isInline: true, dependencies: [{ kind: "directive", type: CdkTreeNodeOutlet, selector: "[cdkTreeNodeOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CdkTree, decorators: [{
             type: Component,
@@ -197,6 +793,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImpor
                     host: {
                         'class': 'cdk-tree',
                         'role': 'tree',
+                        '(keydown)': '_sendKeydownToKeyManager($event)',
                     },
                     encapsulation: ViewEncapsulation.None,
                     // The "OnPush" status for the `CdkTree` component is effectively a noop, so we are removing it.
@@ -207,12 +804,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImpor
                     standalone: true,
                     imports: [CdkTreeNodeOutlet],
                 }]
-        }], ctorParameters: () => [{ type: i0.IterableDiffers }, { type: i0.ChangeDetectorRef }], propDecorators: { dataSource: [{
+        }], ctorParameters: () => [{ type: i0.IterableDiffers }, { type: i0.ChangeDetectorRef }, { type: i1.Directionality }], propDecorators: { dataSource: [{
                 type: Input
             }], treeControl: [{
                 type: Input
+            }], levelAccessor: [{
+                type: Input
+            }], childrenAccessor: [{
+                type: Input
             }], trackBy: [{
                 type: Input
+            }], expansionKey: [{
+                type: Input
             }], _nodeOutlet: [{
                 type: ViewChild,
                 args: [CdkTreeNodeOutlet, { static: true }]
@@ -230,16 +833,42 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImpor
 export class CdkTreeNode {
     /**
      * The role of the tree node.
-     * @deprecated The correct role is 'treeitem', 'group' should not be used. This input will be
-     *   removed in a future version.
-     * @breaking-change 12.0.0 Remove this input
+     *
+     * @deprecated This will be ignored; the tree will automatically determine the appropriate role
+     * for tree node. This input will be removed in a future version.
+     * @breaking-change 21.0.0
      */
     get role() {
         return 'treeitem';
     }
     set role(_role) {
-        // TODO: move to host after View Engine deprecation
-        this._elementRef.nativeElement.setAttribute('role', _role);
+        // ignore any role setting, we handle this internally.
+    }
+    /**
+     * Whether or not this node is expandable.
+     *
+     * If not using `FlatTreeControl`, or if `isExpandable` is not provided to
+     * `NestedTreeControl`, this should be provided for correct node a11y.
+     */
+    get isExpandable() {
+        return this._isExpandable();
+    }
+    set isExpandable(isExpandable) {
+        this._inputIsExpandable = isExpandable;
+    }
+    get isExpanded() {
+        return this._tree.isExpanded(this._data);
+    }
+    set isExpanded(isExpanded) {
+        if (isExpanded) {
+            this.expand();
+        }
+        else {
+            this.collapse();
+        }
+    }
+    getLabel() {
+        return this.typeaheadLabel || this._elementRef.nativeElement.textContent?.trim() || '';
     }
     /**
      * The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it
@@ -253,40 +882,101 @@ export class CdkTreeNode {
     set data(value) {
         if (value !== this._data) {
             this._data = value;
-            this._setRoleFromData();
             this._dataChanges.next();
         }
     }
-    get isExpanded() {
-        return this._tree.treeControl.isExpanded(this._data);
+    /* If leaf node, return true to not assign aria-expanded attribute */
+    get isLeafNode() {
+        // If flat tree node data returns false for expandable property, it's a leaf node
+        if (this._tree.treeControl?.isExpandable !== undefined &&
+            !this._tree.treeControl.isExpandable(this._data)) {
+            return true;
+            // If nested tree node data returns 0 descendants, it's a leaf node
+        }
+        else if (this._tree.treeControl?.isExpandable === undefined &&
+            this._tree.treeControl?.getDescendants(this._data).length === 0) {
+            return true;
+        }
+        return false;
     }
     get level() {
-        // If the treeControl has a getLevel method, use it to get the level. Otherwise read the
+        // If the tree has a levelAccessor, use it to get the level. Otherwise read the
         // aria-level off the parent node and use it as the level for this node (note aria-level is
         // 1-indexed, while this property is 0-indexed, so we don't need to increment).
-        return this._tree.treeControl.getLevel
-            ? this._tree.treeControl.getLevel(this._data)
-            : this._parentNodeAriaLevel;
+        return this._tree._getLevel(this._data) ?? this._parentNodeAriaLevel;
+    }
+    /** Determines if the tree node is expandable. */
+    _isExpandable() {
+        if (this._tree.treeControl) {
+            if (this.isLeafNode) {
+                return false;
+            }
+            // For compatibility with trees created using TreeControl before we added
+            // CdkTreeNode#isExpandable.
+            return true;
+        }
+        return this._inputIsExpandable;
+    }
+    /**
+     * Determines the value for `aria-expanded`.
+     *
+     * For non-expandable nodes, this is `null`.
+     */
+    _getAriaExpanded() {
+        if (!this._isExpandable()) {
+            return null;
+        }
+        return String(this.isExpanded);
+    }
+    /**
+     * Determines the size of this node's parent's child set.
+     *
+     * This is intended to be used for `aria-setsize`.
+     */
+    _getSetSize() {
+        return this._tree._getSetSize(this._data);
+    }
+    /**
+     * Determines the index (starting from 1) of this node in its parent's child set.
+     *
+     * This is intended to be used for `aria-posinset`.
+     */
+    _getPositionInSet() {
+        return this._tree._getPositionInSet(this._data);
     }
     constructor(_elementRef, _tree) {
         this._elementRef = _elementRef;
         this._tree = _tree;
+        this._tabindex = -1;
+        /** This emits when the node has been programatically activated or activated by keyboard. */
+        this.activation = new EventEmitter();
+        /** This emits when the node's expansion status has been changed. */
+        this.expandedChange = new EventEmitter();
         /** Subject that emits when the component has been destroyed. */
         this._destroyed = new Subject();
         /** Emits when the node's data has changed. */
         this._dataChanges = new Subject();
+        this._inputIsExpandable = false;
+        /**
+         * Flag used to determine whether or not we should be focusing the actual element based on
+         * some user interaction (click or focus). On click, we don't forcibly focus the element
+         * since the click could trigger some other component that wants to grab its own focus
+         * (e.g. menu, dialog).
+         */
+        this._shouldFocus = true;
         this._changeDetectorRef = inject(ChangeDetectorRef);
         CdkTreeNode.mostRecentTreeNode = this;
-        this.role = 'treeitem';
     }
     ngOnInit() {
         this._parentNodeAriaLevel = getParentNodeAriaLevel(this._elementRef.nativeElement);
-        this._elementRef.nativeElement.setAttribute('aria-level', `${this.level + 1}`);
-        this._tree.treeControl.expansionModel.changed
-            .pipe(map(() => this.isExpanded), distinctUntilChanged())
+        this._tree
+            ._getExpansionModel()
+            .changed.pipe(map(() => this.isExpanded), distinctUntilChanged())
             .subscribe(() => {
             this._changeDetectorRef.markForCheck();
         });
+        this._tree._setNodeTypeIfUnset('flat');
+        this._tree._registerNode(this);
     }
     ngOnDestroy() {
         // If this is the last tree node being destroyed,
@@ -298,21 +988,63 @@ export class CdkTreeNode {
         this._destroyed.next();
         this._destroyed.complete();
     }
-    /** Focuses the menu item. Implements for FocusableOption. */
+    getParent() {
+        return this._tree._getNodeParent(this) ?? null;
+    }
+    getChildren() {
+        return this._tree._getNodeChildren(this);
+    }
+    /** Focuses this data node. Implemented for TreeKeyManagerItem. */
     focus() {
-        this._elementRef.nativeElement.focus();
+        this._tabindex = 0;
+        if (this._shouldFocus) {
+            this._elementRef.nativeElement.focus();
+        }
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Defocus this data node. */
+    unfocus() {
+        this._tabindex = -1;
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Emits an activation event. Implemented for TreeKeyManagerItem. */
+    activate() {
+        if (this.isDisabled) {
+            return;
+        }
+        this.activation.next(this._data);
+    }
+    /** Collapses this data node. Implemented for TreeKeyManagerItem. */
+    collapse() {
+        if (this.isExpandable) {
+            this._tree.collapse(this._data);
+        }
+    }
+    /** Expands this data node. Implemented for TreeKeyManagerItem. */
+    expand() {
+        if (this.isExpandable) {
+            this._tree.expand(this._data);
+        }
     }
-    // TODO: role should eventually just be set in the component host
-    _setRoleFromData() {
-        if (!this._tree.treeControl.isExpandable &&
-            !this._tree.treeControl.getChildren &&
-            (typeof ngDevMode === 'undefined' || ngDevMode)) {
-            throw getTreeControlFunctionsMissingError();
+    _focusItem() {
+        if (this.isDisabled) {
+            return;
+        }
+        this._tree._keyManager.focusItem(this);
+    }
+    _setActiveItem() {
+        if (this.isDisabled) {
+            return;
         }
-        this.role = 'treeitem';
+        this._shouldFocus = false;
+        this._tree._keyManager.focusItem(this);
+        this._shouldFocus = true;
+    }
+    _emitExpansionState(expanded) {
+        this.expandedChange.emit(expanded);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CdkTreeNode, deps: [{ token: i0.ElementRef }, { token: CdkTree }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: CdkTreeNode, isStandalone: true, selector: "cdk-tree-node", inputs: { role: "role" }, host: { properties: { "attr.aria-expanded": "isExpanded" }, classAttribute: "cdk-tree-node" }, exportAs: ["cdkTreeNode"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.1.0", type: CdkTreeNode, isStandalone: true, selector: "cdk-tree-node", inputs: { role: "role", isExpandable: ["isExpandable", "isExpandable", booleanAttribute], isExpanded: "isExpanded", isDisabled: ["isDisabled", "isDisabled", booleanAttribute], typeaheadLabel: ["cdkTreeNodeTypeaheadLabel", "typeaheadLabel"] }, outputs: { activation: "activation", expandedChange: "expandedChange" }, host: { attributes: { "role": "treeitem" }, listeners: { "click": "_setActiveItem()", "focus": "_focusItem()" }, properties: { "attr.aria-expanded": "_getAriaExpanded()", "attr.aria-level": "level + 1", "attr.aria-posinset": "_getPositionInSet()", "attr.aria-setsize": "_getSetSize()", "tabindex": "_tabindex" }, classAttribute: "cdk-tree-node" }, exportAs: ["cdkTreeNode"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CdkTreeNode, decorators: [{
             type: Directive,
@@ -321,12 +1053,34 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImpor
                     exportAs: 'cdkTreeNode',
                     host: {
                         'class': 'cdk-tree-node',
-                        '[attr.aria-expanded]': 'isExpanded',
+                        '[attr.aria-expanded]': '_getAriaExpanded()',
+                        '[attr.aria-level]': 'level + 1',
+                        '[attr.aria-posinset]': '_getPositionInSet()',
+                        '[attr.aria-setsize]': '_getSetSize()',
+                        '[tabindex]': '_tabindex',
+                        'role': 'treeitem',
+                        '(click)': '_setActiveItem()',
+                        '(focus)': '_focusItem()',
                     },
                     standalone: true,
                 }]
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: CdkTree }], propDecorators: { role: [{
                 type: Input
+            }], isExpandable: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], isExpanded: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], typeaheadLabel: [{
+                type: Input,
+                args: ['cdkTreeNodeTypeaheadLabel']
+            }], activation: [{
+                type: Output
+            }], expandedChange: [{
+                type: Output
             }] } });
 function getParentNodeAriaLevel(nodeElement) {
     let parent = nodeElement.parentElement;
@@ -353,4 +1107,4 @@ function isNodeElement(element) {
     const classList = element.classList;
     return !!(classList?.contains('cdk-nested-tree-node') || classList?.contains('cdk-tree'));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../../src/cdk/tree/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {FocusableOption} from '@angular/cdk/a11y';\nimport {CollectionViewer, DataSource, isDataSource} from '@angular/cdk/collections';\nimport {\n  AfterContentChecked,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  Input,\n  IterableChangeRecord,\n  IterableDiffer,\n  IterableDiffers,\n  OnDestroy,\n  OnInit,\n  QueryList,\n  TrackByFunction,\n  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n  inject,\n  numberAttribute,\n} from '@angular/core';\nimport {\n  BehaviorSubject,\n  Observable,\n  Subject,\n  Subscription,\n  isObservable,\n  of as observableOf,\n} from 'rxjs';\nimport {distinctUntilChanged, map, takeUntil} from 'rxjs/operators';\nimport {TreeControl} from './control/tree-control';\nimport {CdkTreeNodeDef, CdkTreeNodeOutletContext} from './node';\nimport {CdkTreeNodeOutlet} from './outlet';\nimport {\n  getTreeControlFunctionsMissingError,\n  getTreeControlMissingError,\n  getTreeMissingMatchingNodeDefError,\n  getTreeMultipleDefaultNodeDefsError,\n  getTreeNoValidDataSourceError,\n} from './tree-errors';\n\n/**\n * CDK tree component that connects with a data source to retrieve data of type `T` and renders\n * dataNodes with hierarchy. Updates the dataNodes when new data is provided by the data source.\n */\n@Component({\n  selector: 'cdk-tree',\n  exportAs: 'cdkTree',\n  template: `<ng-container cdkTreeNodeOutlet></ng-container>`,\n  host: {\n    'class': 'cdk-tree',\n    'role': 'tree',\n  },\n  encapsulation: ViewEncapsulation.None,\n  // The \"OnPush\" status for the `CdkTree` component is effectively a noop, so we are removing it.\n  // The view for `CdkTree` consists entirely of templates declared in other views. As they are\n  // declared elsewhere, they are checked when their declaration points are checked.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  standalone: true,\n  imports: [CdkTreeNodeOutlet],\n})\nexport class CdkTree<T, K = T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {\n  /** Subject that emits when the component has been destroyed. */\n  private readonly _onDestroy = new Subject<void>();\n\n  /** Differ used to find the changes in the data provided by the data source. */\n  private _dataDiffer: IterableDiffer<T>;\n\n  /** Stores the node definition that does not have a when predicate. */\n  private _defaultNodeDef: CdkTreeNodeDef<T> | null;\n\n  /** Data subscription */\n  private _dataSubscription: Subscription | null;\n\n  /** Level of nodes */\n  private _levels: Map<T, number> = new Map<T, number>();\n\n  /**\n   * Provides a stream containing the latest data array to render. Influenced by the tree's\n   * stream of view window (what dataNodes are currently on screen).\n   * Data source can be an observable of data array, or a data array to render.\n   */\n  @Input()\n  get dataSource(): DataSource<T> | Observable<T[]> | T[] {\n    return this._dataSource;\n  }\n  set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n    if (this._dataSource !== dataSource) {\n      this._switchDataSource(dataSource);\n    }\n  }\n  private _dataSource: DataSource<T> | Observable<T[]> | T[];\n\n  /** The tree controller */\n  @Input() treeControl: TreeControl<T, K>;\n\n  /**\n   * Tracking function that will be used to check the differences in data changes. Used similarly\n   * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data\n   * relative to the function to know if a node should be added/removed/moved.\n   * Accepts a function that takes two parameters, `index` and `item`.\n   */\n  @Input() trackBy: TrackByFunction<T>;\n\n  // Outlets within the tree's template where the dataNodes will be inserted.\n  @ViewChild(CdkTreeNodeOutlet, {static: true}) _nodeOutlet: CdkTreeNodeOutlet;\n\n  /** The tree node template for the tree */\n  @ContentChildren(CdkTreeNodeDef, {\n    // We need to use `descendants: true`, because Ivy will no longer match\n    // indirect descendants if it's left as false.\n    descendants: true,\n  })\n  _nodeDefs: QueryList<CdkTreeNodeDef<T>>;\n\n  // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.\n  //     Remove the MAX_VALUE in viewChange\n  /**\n   * Stream containing the latest information on what rows are being displayed on screen.\n   * Can be used by the data source to as a heuristic of what data should be provided.\n   */\n  readonly viewChange = new BehaviorSubject<{start: number; end: number}>({\n    start: 0,\n    end: Number.MAX_VALUE,\n  });\n\n  constructor(\n    private _differs: IterableDiffers,\n    private _changeDetectorRef: ChangeDetectorRef,\n  ) {}\n\n  ngOnInit() {\n    this._dataDiffer = this._differs.find([]).create(this.trackBy);\n    if (!this.treeControl && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeControlMissingError();\n    }\n  }\n\n  ngOnDestroy() {\n    this._nodeOutlet.viewContainer.clear();\n\n    this.viewChange.complete();\n    this._onDestroy.next();\n    this._onDestroy.complete();\n\n    if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {\n      (this.dataSource as DataSource<T>).disconnect(this);\n    }\n\n    if (this._dataSubscription) {\n      this._dataSubscription.unsubscribe();\n      this._dataSubscription = null;\n    }\n  }\n\n  ngAfterContentChecked() {\n    const defaultNodeDefs = this._nodeDefs.filter(def => !def.when);\n    if (defaultNodeDefs.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeMultipleDefaultNodeDefsError();\n    }\n    this._defaultNodeDef = defaultNodeDefs[0];\n\n    if (this.dataSource && this._nodeDefs && !this._dataSubscription) {\n      this._observeRenderChanges();\n    }\n  }\n\n  // TODO(tinayuangao): Work on keyboard traversal and actions, make sure it's working for RTL\n  //     and nested trees.\n\n  /**\n   * Switch to the provided data source by resetting the data and unsubscribing from the current\n   * render change subscription if one exists. If the data source is null, interpret this by\n   * clearing the node outlet. Otherwise start listening for new data.\n   */\n  private _switchDataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n    if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {\n      (this.dataSource as DataSource<T>).disconnect(this);\n    }\n\n    if (this._dataSubscription) {\n      this._dataSubscription.unsubscribe();\n      this._dataSubscription = null;\n    }\n\n    // Remove the all dataNodes if there is now no data source\n    if (!dataSource) {\n      this._nodeOutlet.viewContainer.clear();\n    }\n\n    this._dataSource = dataSource;\n    if (this._nodeDefs) {\n      this._observeRenderChanges();\n    }\n  }\n\n  /** Set up a subscription for the data provided by the data source. */\n  private _observeRenderChanges() {\n    let dataStream: Observable<readonly T[]> | undefined;\n\n    if (isDataSource(this._dataSource)) {\n      dataStream = this._dataSource.connect(this);\n    } else if (isObservable(this._dataSource)) {\n      dataStream = this._dataSource;\n    } else if (Array.isArray(this._dataSource)) {\n      dataStream = observableOf(this._dataSource);\n    }\n\n    if (dataStream) {\n      this._dataSubscription = dataStream\n        .pipe(takeUntil(this._onDestroy))\n        .subscribe(data => this.renderNodeChanges(data));\n    } else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      throw getTreeNoValidDataSourceError();\n    }\n  }\n\n  /** Check for changes made in the data and render each change (node added/removed/moved). */\n  renderNodeChanges(\n    data: readonly T[],\n    dataDiffer: IterableDiffer<T> = this._dataDiffer,\n    viewContainer: ViewContainerRef = this._nodeOutlet.viewContainer,\n    parentData?: T,\n  ) {\n    const changes = dataDiffer.diff(data);\n    if (!changes) {\n      return;\n    }\n\n    changes.forEachOperation(\n      (\n        item: IterableChangeRecord<T>,\n        adjustedPreviousIndex: number | null,\n        currentIndex: number | null,\n      ) => {\n        if (item.previousIndex == null) {\n          this.insertNode(data[currentIndex!], currentIndex!, viewContainer, parentData);\n        } else if (currentIndex == null) {\n          viewContainer.remove(adjustedPreviousIndex!);\n          this._levels.delete(item.item);\n        } else {\n          const view = viewContainer.get(adjustedPreviousIndex!);\n          viewContainer.move(view!, currentIndex);\n        }\n      },\n    );\n\n    // TODO: change to `this._changeDetectorRef.markForCheck()`, or just switch this component to\n    // use signals.\n    this._changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Finds the matching node definition that should be used for this node data. If there is only\n   * one node definition, it is returned. Otherwise, find the node definition that has a when\n   * predicate that returns true with the data. If none return true, return the default node\n   * definition.\n   */\n  _getNodeDef(data: T, i: number): CdkTreeNodeDef<T> {\n    if (this._nodeDefs.length === 1) {\n      return this._nodeDefs.first!;\n    }\n\n    const nodeDef =\n      this._nodeDefs.find(def => def.when && def.when(i, data)) || this._defaultNodeDef;\n\n    if (!nodeDef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeMissingMatchingNodeDefError();\n    }\n\n    return nodeDef!;\n  }\n\n  /**\n   * Create the embedded view for the data node template and place it in the correct index location\n   * within the data node view container.\n   */\n  insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T) {\n    const node = this._getNodeDef(nodeData, index);\n\n    // Node context that will be provided to created embedded view\n    const context = new CdkTreeNodeOutletContext<T>(nodeData);\n\n    // If the tree is flat tree, then use the `getLevel` function in flat tree control\n    // Otherwise, use the level of parent node.\n    if (this.treeControl.getLevel) {\n      context.level = this.treeControl.getLevel(nodeData);\n    } else if (typeof parentData !== 'undefined' && this._levels.has(parentData)) {\n      context.level = this._levels.get(parentData)! + 1;\n    } else {\n      context.level = 0;\n    }\n    this._levels.set(nodeData, context.level);\n\n    // Use default tree nodeOutlet, or nested node's nodeOutlet\n    const container = viewContainer ? viewContainer : this._nodeOutlet.viewContainer;\n    container.createEmbeddedView(node.template, context, index);\n\n    // Set the data to just created `CdkTreeNode`.\n    // The `CdkTreeNode` created from `createEmbeddedView` will be saved in static variable\n    //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.\n    if (CdkTreeNode.mostRecentTreeNode) {\n      CdkTreeNode.mostRecentTreeNode.data = nodeData;\n    }\n  }\n}\n\n/**\n * Tree node for CdkTree. It contains the data in the tree node.\n */\n@Directive({\n  selector: 'cdk-tree-node',\n  exportAs: 'cdkTreeNode',\n  host: {\n    'class': 'cdk-tree-node',\n    '[attr.aria-expanded]': 'isExpanded',\n  },\n  standalone: true,\n})\nexport class CdkTreeNode<T, K = T> implements FocusableOption, OnDestroy, OnInit {\n  /**\n   * The role of the tree node.\n   * @deprecated The correct role is 'treeitem', 'group' should not be used. This input will be\n   *   removed in a future version.\n   * @breaking-change 12.0.0 Remove this input\n   */\n  @Input() get role(): 'treeitem' | 'group' {\n    return 'treeitem';\n  }\n\n  set role(_role: 'treeitem' | 'group') {\n    // TODO: move to host after View Engine deprecation\n    this._elementRef.nativeElement.setAttribute('role', _role);\n  }\n\n  /**\n   * The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it\n   * in `CdkTree` and set the data to it.\n   */\n  static mostRecentTreeNode: CdkTreeNode<any> | null = null;\n\n  /** Subject that emits when the component has been destroyed. */\n  protected readonly _destroyed = new Subject<void>();\n\n  /** Emits when the node's data has changed. */\n  readonly _dataChanges = new Subject<void>();\n\n  private _parentNodeAriaLevel: number;\n\n  /** The tree node's data. */\n  get data(): T {\n    return this._data;\n  }\n  set data(value: T) {\n    if (value !== this._data) {\n      this._data = value;\n      this._setRoleFromData();\n      this._dataChanges.next();\n    }\n  }\n  protected _data: T;\n\n  get isExpanded(): boolean {\n    return this._tree.treeControl.isExpanded(this._data);\n  }\n\n  get level(): number {\n    // If the treeControl has a getLevel method, use it to get the level. Otherwise read the\n    // aria-level off the parent node and use it as the level for this node (note aria-level is\n    // 1-indexed, while this property is 0-indexed, so we don't need to increment).\n    return this._tree.treeControl.getLevel\n      ? this._tree.treeControl.getLevel(this._data)\n      : this._parentNodeAriaLevel;\n  }\n\n  private _changeDetectorRef = inject(ChangeDetectorRef);\n\n  constructor(\n    protected _elementRef: ElementRef<HTMLElement>,\n    protected _tree: CdkTree<T, K>,\n  ) {\n    CdkTreeNode.mostRecentTreeNode = this as CdkTreeNode<T, K>;\n    this.role = 'treeitem';\n  }\n\n  ngOnInit(): void {\n    this._parentNodeAriaLevel = getParentNodeAriaLevel(this._elementRef.nativeElement);\n    this._elementRef.nativeElement.setAttribute('aria-level', `${this.level + 1}`);\n    this._tree.treeControl.expansionModel.changed\n      .pipe(\n        map(() => this.isExpanded),\n        distinctUntilChanged(),\n      )\n      .subscribe(() => {\n        this._changeDetectorRef.markForCheck();\n      });\n  }\n\n  ngOnDestroy() {\n    // If this is the last tree node being destroyed,\n    // clear out the reference to avoid leaking memory.\n    if (CdkTreeNode.mostRecentTreeNode === this) {\n      CdkTreeNode.mostRecentTreeNode = null;\n    }\n\n    this._dataChanges.complete();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Focuses the menu item. Implements for FocusableOption. */\n  focus(): void {\n    this._elementRef.nativeElement.focus();\n  }\n\n  // TODO: role should eventually just be set in the component host\n  protected _setRoleFromData(): void {\n    if (\n      !this._tree.treeControl.isExpandable &&\n      !this._tree.treeControl.getChildren &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)\n    ) {\n      throw getTreeControlFunctionsMissingError();\n    }\n    this.role = 'treeitem';\n  }\n}\n\nfunction getParentNodeAriaLevel(nodeElement: HTMLElement): number {\n  let parent = nodeElement.parentElement;\n  while (parent && !isNodeElement(parent)) {\n    parent = parent.parentElement;\n  }\n  if (!parent) {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      throw Error('Incorrect tree structure containing detached node.');\n    } else {\n      return -1;\n    }\n  } else if (parent.classList.contains('cdk-nested-tree-node')) {\n    return numberAttribute(parent.getAttribute('aria-level')!);\n  } else {\n    // The ancestor element is the cdk-tree itself\n    return 0;\n  }\n}\n\nfunction isNodeElement(element: HTMLElement) {\n  const classList = element.classList;\n  return !!(classList?.contains('cdk-nested-tree-node') || classList?.contains('cdk-tree'));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../../src/cdk/tree/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {\n  TREE_KEY_MANAGER,\n  TreeKeyManagerFactory,\n  TreeKeyManagerItem,\n  TreeKeyManagerOptions,\n  TreeKeyManagerStrategy,\n} from '@angular/cdk/a11y';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {\n  CollectionViewer,\n  DataSource,\n  isDataSource,\n  SelectionChange,\n  SelectionModel,\n} from '@angular/cdk/collections';\nimport {\n  AfterContentChecked,\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  EmbeddedViewRef,\n  Input,\n  IterableChangeRecord,\n  IterableDiffer,\n  IterableDiffers,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  TrackByFunction,\n  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n  numberAttribute,\n  inject,\n  booleanAttribute,\n} from '@angular/core';\nimport {coerceObservable} from '@angular/cdk/coercion/private';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  concat,\n  EMPTY,\n  Observable,\n  Subject,\n  Subscription,\n  isObservable,\n  of as observableOf,\n} from 'rxjs';\nimport {\n  distinctUntilChanged,\n  concatMap,\n  map,\n  reduce,\n  startWith,\n  switchMap,\n  take,\n  takeUntil,\n  tap,\n} from 'rxjs/operators';\nimport {TreeControl} from './control/tree-control';\nimport {CdkTreeNodeDef, CdkTreeNodeOutletContext} from './node';\nimport {CdkTreeNodeOutlet} from './outlet';\nimport {\n  getMultipleTreeControlsError,\n  getTreeControlMissingError,\n  getTreeMissingMatchingNodeDefError,\n  getTreeMultipleDefaultNodeDefsError,\n  getTreeNoValidDataSourceError,\n} from './tree-errors';\n\ntype RenderingData<T> =\n  | {\n      flattenedNodes: null;\n      nodeType: null;\n      renderNodes: readonly T[];\n    }\n  | {\n      flattenedNodes: readonly T[];\n      nodeType: 'nested' | 'flat';\n      renderNodes: readonly T[];\n    };\n\n/**\n * CDK tree component that connects with a data source to retrieve data of type `T` and renders\n * dataNodes with hierarchy. Updates the dataNodes when new data is provided by the data source.\n */\n@Component({\n  selector: 'cdk-tree',\n  exportAs: 'cdkTree',\n  template: `<ng-container cdkTreeNodeOutlet></ng-container>`,\n  host: {\n    'class': 'cdk-tree',\n    'role': 'tree',\n    '(keydown)': '_sendKeydownToKeyManager($event)',\n  },\n  encapsulation: ViewEncapsulation.None,\n  // The \"OnPush\" status for the `CdkTree` component is effectively a noop, so we are removing it.\n  // The view for `CdkTree` consists entirely of templates declared in other views. As they are\n  // declared elsewhere, they are checked when their declaration points are checked.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  standalone: true,\n  imports: [CdkTreeNodeOutlet],\n})\nexport class CdkTree<T, K = T>\n  implements\n    AfterContentChecked,\n    AfterContentInit,\n    AfterViewInit,\n    CollectionViewer,\n    OnDestroy,\n    OnInit\n{\n  /** Subject that emits when the component has been destroyed. */\n  private readonly _onDestroy = new Subject<void>();\n\n  /** Differ used to find the changes in the data provided by the data source. */\n  private _dataDiffer: IterableDiffer<T>;\n\n  /** Stores the node definition that does not have a when predicate. */\n  private _defaultNodeDef: CdkTreeNodeDef<T> | null;\n\n  /** Data subscription */\n  private _dataSubscription: Subscription | null;\n\n  /** Level of nodes */\n  private _levels: Map<K, number> = new Map<K, number>();\n\n  /** The immediate parents for a node. This is `null` if there is no parent. */\n  private _parents: Map<K, T | null> = new Map<K, T | null>();\n\n  /**\n   * Nodes grouped into each set, which is a list of nodes displayed together in the DOM.\n   *\n   * Lookup key is the parent of a set. Root nodes have key of null.\n   *\n   * Values is a 'set' of tree nodes. Each tree node maps to a treeitem element. Sets are in the\n   * order that it is rendered. Each set maps directly to aria-posinset and aria-setsize attributes.\n   */\n  private _ariaSets: Map<K | null, T[]> = new Map<K | null, T[]>();\n\n  /**\n   * Provides a stream containing the latest data array to render. Influenced by the tree's\n   * stream of view window (what dataNodes are currently on screen).\n   * Data source can be an observable of data array, or a data array to render.\n   */\n  @Input()\n  get dataSource(): DataSource<T> | Observable<T[]> | T[] {\n    return this._dataSource;\n  }\n  set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n    if (this._dataSource !== dataSource) {\n      this._switchDataSource(dataSource);\n    }\n  }\n  private _dataSource: DataSource<T> | Observable<T[]> | T[];\n\n  /**\n   * The tree controller\n   *\n   * @deprecated Use one of `levelAccessor` or `childrenAccessor` instead. To be removed in a\n   * future version.\n   * @breaking-change 21.0.0\n   */\n  @Input() treeControl?: TreeControl<T, K>;\n\n  /**\n   * Given a data node, determines what tree level the node is at.\n   *\n   * One of levelAccessor or childrenAccessor must be specified, not both.\n   * This is enforced at run-time.\n   */\n  @Input() levelAccessor?: (dataNode: T) => number;\n\n  /**\n   * Given a data node, determines what the children of that node are.\n   *\n   * One of levelAccessor or childrenAccessor must be specified, not both.\n   * This is enforced at run-time.\n   */\n  @Input() childrenAccessor?: (dataNode: T) => T[] | Observable<T[]>;\n\n  /**\n   * Tracking function that will be used to check the differences in data changes. Used similarly\n   * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data\n   * relative to the function to know if a node should be added/removed/moved.\n   * Accepts a function that takes two parameters, `index` and `item`.\n   */\n  @Input() trackBy: TrackByFunction<T>;\n\n  /**\n   * Given a data node, determines the key by which we determine whether or not this node is expanded.\n   */\n  @Input() expansionKey?: (dataNode: T) => K;\n\n  // Outlets within the tree's template where the dataNodes will be inserted.\n  @ViewChild(CdkTreeNodeOutlet, {static: true}) _nodeOutlet: CdkTreeNodeOutlet;\n\n  /** The tree node template for the tree */\n  @ContentChildren(CdkTreeNodeDef, {\n    // We need to use `descendants: true`, because Ivy will no longer match\n    // indirect descendants if it's left as false.\n    descendants: true,\n  })\n  _nodeDefs: QueryList<CdkTreeNodeDef<T>>;\n\n  // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.\n  //     Remove the MAX_VALUE in viewChange\n  /**\n   * Stream containing the latest information on what rows are being displayed on screen.\n   * Can be used by the data source to as a heuristic of what data should be provided.\n   */\n  readonly viewChange = new BehaviorSubject<{start: number; end: number}>({\n    start: 0,\n    end: Number.MAX_VALUE,\n  });\n\n  /** Keep track of which nodes are expanded. */\n  private _expansionModel?: SelectionModel<K>;\n\n  /**\n   * Maintain a synchronous cache of flattened data nodes. This will only be\n   * populated after initial render, and in certain cases, will be delayed due to\n   * relying on Observable `getChildren` calls.\n   */\n  private _flattenedNodes: BehaviorSubject<readonly T[]> = new BehaviorSubject<readonly T[]>([]);\n\n  /** The automatically determined node type for the tree. */\n  private _nodeType: BehaviorSubject<'flat' | 'nested' | null> = new BehaviorSubject<\n    'flat' | 'nested' | null\n  >(null);\n\n  /** The mapping between data and the node that is rendered. */\n  private _nodes: BehaviorSubject<Map<K, CdkTreeNode<T, K>>> = new BehaviorSubject(\n    new Map<K, CdkTreeNode<T, K>>(),\n  );\n\n  /**\n   * Synchronous cache of nodes for the `TreeKeyManager`. This is separate\n   * from `_flattenedNodes` so they can be independently updated at different\n   * times.\n   */\n  private _keyManagerNodes: BehaviorSubject<readonly T[]> = new BehaviorSubject<readonly T[]>([]);\n\n  private _keyManagerFactory = inject(TREE_KEY_MANAGER) as TreeKeyManagerFactory<CdkTreeNode<T, K>>;\n\n  /** The key manager for this tree. Handles focus and activation based on user keyboard input. */\n  _keyManager: TreeKeyManagerStrategy<CdkTreeNode<T, K>>;\n  private _viewInit = false;\n\n  constructor(\n    private _differs: IterableDiffers,\n    private _changeDetectorRef: ChangeDetectorRef,\n    private _dir: Directionality,\n  ) {}\n\n  ngAfterContentInit() {\n    this._initializeKeyManager();\n  }\n\n  ngAfterContentChecked() {\n    this._updateDefaultNodeDefinition();\n    this._subscribeToDataChanges();\n  }\n\n  ngOnDestroy() {\n    this._nodeOutlet.viewContainer.clear();\n\n    this.viewChange.complete();\n    this._onDestroy.next();\n    this._onDestroy.complete();\n\n    if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {\n      (this.dataSource as DataSource<T>).disconnect(this);\n    }\n\n    if (this._dataSubscription) {\n      this._dataSubscription.unsubscribe();\n      this._dataSubscription = null;\n    }\n\n    // In certain tests, the tree might be destroyed before this is initialized\n    // in `ngAfterContentInit`.\n    this._keyManager?.destroy();\n  }\n\n  ngOnInit() {\n    this._checkTreeControlUsage();\n    this._initializeDataDiffer();\n  }\n\n  ngAfterViewInit() {\n    this._viewInit = true;\n  }\n\n  private _updateDefaultNodeDefinition() {\n    const defaultNodeDefs = this._nodeDefs.filter(def => !def.when);\n    if (defaultNodeDefs.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeMultipleDefaultNodeDefsError();\n    }\n    this._defaultNodeDef = defaultNodeDefs[0];\n  }\n\n  /**\n   * Sets the node type for the tree, if it hasn't been set yet.\n   *\n   * This will be called by the first node that's rendered in order for the tree\n   * to determine what data transformations are required.\n   */\n  _setNodeTypeIfUnset(nodeType: 'flat' | 'nested') {\n    if (this._nodeType.value === null) {\n      this._nodeType.next(nodeType);\n    }\n  }\n\n  /**\n   * Switch to the provided data source by resetting the data and unsubscribing from the current\n   * render change subscription if one exists. If the data source is null, interpret this by\n   * clearing the node outlet. Otherwise start listening for new data.\n   */\n  private _switchDataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n    if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {\n      (this.dataSource as DataSource<T>).disconnect(this);\n    }\n\n    if (this._dataSubscription) {\n      this._dataSubscription.unsubscribe();\n      this._dataSubscription = null;\n    }\n\n    // Remove the all dataNodes if there is now no data source\n    if (!dataSource) {\n      this._nodeOutlet.viewContainer.clear();\n    }\n\n    this._dataSource = dataSource;\n    if (this._nodeDefs) {\n      this._subscribeToDataChanges();\n    }\n  }\n\n  _getExpansionModel() {\n    if (!this.treeControl) {\n      this._expansionModel ??= new SelectionModel<K>(true);\n      return this._expansionModel;\n    }\n    return this.treeControl.expansionModel;\n  }\n\n  /** Set up a subscription for the data provided by the data source. */\n  private _subscribeToDataChanges() {\n    if (this._dataSubscription) {\n      return;\n    }\n\n    let dataStream: Observable<readonly T[]> | undefined;\n\n    if (isDataSource(this._dataSource)) {\n      dataStream = this._dataSource.connect(this);\n    } else if (isObservable(this._dataSource)) {\n      dataStream = this._dataSource;\n    } else if (Array.isArray(this._dataSource)) {\n      dataStream = observableOf(this._dataSource);\n    }\n\n    if (!dataStream) {\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        throw getTreeNoValidDataSourceError();\n      }\n      return;\n    }\n\n    this._dataSubscription = this._getRenderData(dataStream)\n      .pipe(takeUntil(this._onDestroy))\n      .subscribe(renderingData => {\n        this._renderDataChanges(renderingData);\n      });\n  }\n\n  /** Given an Observable containing a stream of the raw data, returns an Observable containing the RenderingData */\n  private _getRenderData(dataStream: Observable<readonly T[]>): Observable<RenderingData<T>> {\n    const expansionModel = this._getExpansionModel();\n    return combineLatest([\n      dataStream,\n      this._nodeType,\n      // We don't use the expansion data directly, however we add it here to essentially\n      // trigger data rendering when expansion changes occur.\n      expansionModel.changed.pipe(\n        startWith(null),\n        tap(expansionChanges => {\n          this._emitExpansionChanges(expansionChanges);\n        }),\n      ),\n    ]).pipe(\n      switchMap(([data, nodeType]) => {\n        if (nodeType === null) {\n          return observableOf({renderNodes: data, flattenedNodes: null, nodeType} as const);\n        }\n\n        // If we're here, then we know what our node type is, and therefore can\n        // perform our usual rendering pipeline, which necessitates converting the data\n        return this._computeRenderingData(data, nodeType).pipe(\n          map(convertedData => ({...convertedData, nodeType}) as const),\n        );\n      }),\n    );\n  }\n\n  private _renderDataChanges(data: RenderingData<T>) {\n    if (data.nodeType === null) {\n      this.renderNodeChanges(data.renderNodes);\n      return;\n    }\n\n    // If we're here, then we know what our node type is, and therefore can\n    // perform our usual rendering pipeline.\n    this._updateCachedData(data.flattenedNodes);\n    this.renderNodeChanges(data.renderNodes);\n    this._updateKeyManagerItems(data.flattenedNodes);\n  }\n\n  private _emitExpansionChanges(expansionChanges: SelectionChange<K> | null) {\n    if (!expansionChanges) {\n      return;\n    }\n\n    const nodes = this._nodes.value;\n    for (const added of expansionChanges.added) {\n      const node = nodes.get(added);\n      node?._emitExpansionState(true);\n    }\n    for (const removed of expansionChanges.removed) {\n      const node = nodes.get(removed);\n      node?._emitExpansionState(false);\n    }\n  }\n\n  private _initializeKeyManager() {\n    const items = combineLatest([this._keyManagerNodes, this._nodes]).pipe(\n      map(([keyManagerNodes, renderNodes]) =>\n        keyManagerNodes.reduce<CdkTreeNode<T, K>[]>((items, data) => {\n          const node = renderNodes.get(this._getExpansionKey(data));\n          if (node) {\n            items.push(node);\n          }\n          return items;\n        }, []),\n      ),\n    );\n\n    const keyManagerOptions: TreeKeyManagerOptions<CdkTreeNode<T, K>> = {\n      trackBy: node => this._getExpansionKey(node.data),\n      skipPredicate: node => !!node.isDisabled,\n      typeAheadDebounceInterval: true,\n      horizontalOrientation: this._dir.value,\n    };\n\n    this._keyManager = this._keyManagerFactory(items, keyManagerOptions);\n  }\n\n  private _initializeDataDiffer() {\n    // Provide a default trackBy based on `_getExpansionKey` if one isn't provided.\n    const trackBy = this.trackBy ?? ((_index: number, item: T) => this._getExpansionKey(item));\n    this._dataDiffer = this._differs.find([]).create(trackBy);\n  }\n\n  private _checkTreeControlUsage() {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      // Verify that Tree follows API contract of using one of TreeControl, levelAccessor or\n      // childrenAccessor. Throw an appropriate error if contract is not met.\n      let numTreeControls = 0;\n\n      if (this.treeControl) {\n        numTreeControls++;\n      }\n      if (this.levelAccessor) {\n        numTreeControls++;\n      }\n      if (this.childrenAccessor) {\n        numTreeControls++;\n      }\n\n      if (!numTreeControls) {\n        throw getTreeControlMissingError();\n      } else if (numTreeControls > 1) {\n        throw getMultipleTreeControlsError();\n      }\n    }\n  }\n\n  /** Check for changes made in the data and render each change (node added/removed/moved). */\n  renderNodeChanges(\n    data: readonly T[],\n    dataDiffer: IterableDiffer<T> = this._dataDiffer,\n    viewContainer: ViewContainerRef = this._nodeOutlet.viewContainer,\n    parentData?: T,\n  ) {\n    const changes = dataDiffer.diff(data);\n\n    // Some tree consumers expect change detection to propagate to nodes\n    // even when the array itself hasn't changed; we explicitly detect changes\n    // anyways in order for nodes to update their data.\n    //\n    // However, if change detection is called while the component's view is\n    // still initing, then the order of child views initing will be incorrect;\n    // to prevent this, we only exit early if the view hasn't initialized yet.\n    if (!changes && !this._viewInit) {\n      return;\n    }\n\n    changes?.forEachOperation(\n      (\n        item: IterableChangeRecord<T>,\n        adjustedPreviousIndex: number | null,\n        currentIndex: number | null,\n      ) => {\n        if (item.previousIndex == null) {\n          this.insertNode(data[currentIndex!], currentIndex!, viewContainer, parentData);\n        } else if (currentIndex == null) {\n          viewContainer.remove(adjustedPreviousIndex!);\n        } else {\n          const view = viewContainer.get(adjustedPreviousIndex!);\n          viewContainer.move(view!, currentIndex);\n        }\n      },\n    );\n\n    // If the data itself changes, but keeps the same trackBy, we need to update the templates'\n    // context to reflect the new object.\n    changes?.forEachIdentityChange((record: IterableChangeRecord<T>) => {\n      const newData = record.item;\n      if (record.currentIndex != undefined) {\n        const view = viewContainer.get(record.currentIndex);\n        (view as EmbeddedViewRef<any>).context.$implicit = newData;\n      }\n    });\n\n    // TODO: change to `this._changeDetectorRef.markForCheck()`, or just switch this component to\n    // use signals.\n    this._changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Finds the matching node definition that should be used for this node data. If there is only\n   * one node definition, it is returned. Otherwise, find the node definition that has a when\n   * predicate that returns true with the data. If none return true, return the default node\n   * definition.\n   */\n  _getNodeDef(data: T, i: number): CdkTreeNodeDef<T> {\n    if (this._nodeDefs.length === 1) {\n      return this._nodeDefs.first!;\n    }\n\n    const nodeDef =\n      this._nodeDefs.find(def => def.when && def.when(i, data)) || this._defaultNodeDef;\n\n    if (!nodeDef && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeMissingMatchingNodeDefError();\n    }\n\n    return nodeDef!;\n  }\n\n  /**\n   * Create the embedded view for the data node template and place it in the correct index location\n   * within the data node view container.\n   */\n  insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T) {\n    const levelAccessor = this._getLevelAccessor();\n\n    const node = this._getNodeDef(nodeData, index);\n    const key = this._getExpansionKey(nodeData);\n\n    // Node context that will be provided to created embedded view\n    const context = new CdkTreeNodeOutletContext<T>(nodeData);\n\n    parentData ??= this._parents.get(key) ?? undefined;\n    // If the tree is flat tree, then use the `getLevel` function in flat tree control\n    // Otherwise, use the level of parent node.\n    if (levelAccessor) {\n      context.level = levelAccessor(nodeData);\n    } else if (parentData !== undefined && this._levels.has(this._getExpansionKey(parentData))) {\n      context.level = this._levels.get(this._getExpansionKey(parentData))! + 1;\n    } else {\n      context.level = 0;\n    }\n    this._levels.set(key, context.level);\n\n    // Use default tree nodeOutlet, or nested node's nodeOutlet\n    const container = viewContainer ? viewContainer : this._nodeOutlet.viewContainer;\n    container.createEmbeddedView(node.template, context, index);\n\n    // Set the data to just created `CdkTreeNode`.\n    // The `CdkTreeNode` created from `createEmbeddedView` will be saved in static variable\n    //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.\n    if (CdkTreeNode.mostRecentTreeNode) {\n      CdkTreeNode.mostRecentTreeNode.data = nodeData;\n    }\n  }\n\n  /** Whether the data node is expanded or collapsed. Returns true if it's expanded. */\n  isExpanded(dataNode: T): boolean {\n    return !!(\n      this.treeControl?.isExpanded(dataNode) ||\n      this._expansionModel?.isSelected(this._getExpansionKey(dataNode))\n    );\n  }\n\n  /** If the data node is currently expanded, collapse it. Otherwise, expand it. */\n  toggle(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.toggle(dataNode);\n    } else if (this._expansionModel) {\n      this._expansionModel.toggle(this._getExpansionKey(dataNode));\n    }\n  }\n\n  /** Expand the data node. If it is already expanded, does nothing. */\n  expand(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.expand(dataNode);\n    } else if (this._expansionModel) {\n      this._expansionModel.select(this._getExpansionKey(dataNode));\n    }\n  }\n\n  /** Collapse the data node. If it is already collapsed, does nothing. */\n  collapse(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.collapse(dataNode);\n    } else if (this._expansionModel) {\n      this._expansionModel.deselect(this._getExpansionKey(dataNode));\n    }\n  }\n\n  /**\n   * If the data node is currently expanded, collapse it and all its descendants.\n   * Otherwise, expand it and all its descendants.\n   */\n  toggleDescendants(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.toggleDescendants(dataNode);\n    } else if (this._expansionModel) {\n      if (this.isExpanded(dataNode)) {\n        this.collapseDescendants(dataNode);\n      } else {\n        this.expandDescendants(dataNode);\n      }\n    }\n  }\n\n  /**\n   * Expand the data node and all its descendants. If they are already expanded, does nothing.\n   */\n  expandDescendants(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.expandDescendants(dataNode);\n    } else if (this._expansionModel) {\n      const expansionModel = this._expansionModel;\n      expansionModel.select(this._getExpansionKey(dataNode));\n      this._getDescendants(dataNode)\n        .pipe(take(1), takeUntil(this._onDestroy))\n        .subscribe(children => {\n          expansionModel.select(...children.map(child => this._getExpansionKey(child)));\n        });\n    }\n  }\n\n  /** Collapse the data node and all its descendants. If it is already collapsed, does nothing. */\n  collapseDescendants(dataNode: T): void {\n    if (this.treeControl) {\n      this.treeControl.collapseDescendants(dataNode);\n    } else if (this._expansionModel) {\n      const expansionModel = this._expansionModel;\n      expansionModel.deselect(this._getExpansionKey(dataNode));\n      this._getDescendants(dataNode)\n        .pipe(take(1), takeUntil(this._onDestroy))\n        .subscribe(children => {\n          expansionModel.deselect(...children.map(child => this._getExpansionKey(child)));\n        });\n    }\n  }\n\n  /** Expands all data nodes in the tree. */\n  expandAll(): void {\n    if (this.treeControl) {\n      this.treeControl.expandAll();\n    } else if (this._expansionModel) {\n      const expansionModel = this._expansionModel;\n      expansionModel.select(\n        ...this._flattenedNodes.value.map(child => this._getExpansionKey(child)),\n      );\n    }\n  }\n\n  /** Collapse all data nodes in the tree. */\n  collapseAll(): void {\n    if (this.treeControl) {\n      this.treeControl.collapseAll();\n    } else if (this._expansionModel) {\n      const expansionModel = this._expansionModel;\n      expansionModel.deselect(\n        ...this._flattenedNodes.value.map(child => this._getExpansionKey(child)),\n      );\n    }\n  }\n\n  /** Level accessor, used for compatibility between the old Tree and new Tree */\n  _getLevelAccessor() {\n    return this.treeControl?.getLevel?.bind(this.treeControl) ?? this.levelAccessor;\n  }\n\n  /** Children accessor, used for compatibility between the old Tree and new Tree */\n  _getChildrenAccessor() {\n    return this.treeControl?.getChildren?.bind(this.treeControl) ?? this.childrenAccessor;\n  }\n\n  /**\n   * Gets the direct children of a node; used for compatibility between the old tree and the\n   * new tree.\n   */\n  _getDirectChildren(dataNode: T): Observable<T[]> {\n    const levelAccessor = this._getLevelAccessor();\n    const expansionModel = this._expansionModel ?? this.treeControl?.expansionModel;\n    if (!expansionModel) {\n      return observableOf([]);\n    }\n\n    const key = this._getExpansionKey(dataNode);\n\n    const isExpanded = expansionModel.changed.pipe(\n      switchMap(changes => {\n        if (changes.added.includes(key)) {\n          return observableOf(true);\n        } else if (changes.removed.includes(key)) {\n          return observableOf(false);\n        }\n        return EMPTY;\n      }),\n      startWith(this.isExpanded(dataNode)),\n    );\n\n    if (levelAccessor) {\n      return combineLatest([isExpanded, this._flattenedNodes]).pipe(\n        map(([expanded, flattenedNodes]) => {\n          if (!expanded) {\n            return [];\n          }\n          return this._findChildrenByLevel(\n            levelAccessor,\n            flattenedNodes,\n\n            dataNode,\n            1,\n          );\n        }),\n      );\n    }\n    const childrenAccessor = this._getChildrenAccessor();\n    if (childrenAccessor) {\n      return coerceObservable(childrenAccessor(dataNode) ?? []);\n    }\n    throw getTreeControlMissingError();\n  }\n\n  /**\n   * Given the list of flattened nodes, the level accessor, and the level range within\n   * which to consider children, finds the children for a given node.\n   *\n   * For example, for direct children, `levelDelta` would be 1. For all descendants,\n   * `levelDelta` would be Infinity.\n   */\n  private _findChildrenByLevel(\n    levelAccessor: (node: T) => number,\n    flattenedNodes: readonly T[],\n    dataNode: T,\n    levelDelta: number,\n  ): T[] {\n    const key = this._getExpansionKey(dataNode);\n    const startIndex = flattenedNodes.findIndex(node => this._getExpansionKey(node) === key);\n    const dataNodeLevel = levelAccessor(dataNode);\n    const expectedLevel = dataNodeLevel + levelDelta;\n    const results: T[] = [];\n\n    // Goes through flattened tree nodes in the `flattenedNodes` array, and get all\n    // descendants within a certain level range.\n    //\n    // If we reach a node whose level is equal to or less than the level of the tree node,\n    // we hit a sibling or parent's sibling, and should stop.\n    for (let i = startIndex + 1; i < flattenedNodes.length; i++) {\n      const currentLevel = levelAccessor(flattenedNodes[i]);\n      if (currentLevel <= dataNodeLevel) {\n        break;\n      }\n      if (currentLevel <= expectedLevel) {\n        results.push(flattenedNodes[i]);\n      }\n    }\n    return results;\n  }\n\n  /**\n   * Adds the specified node component to the tree's internal registry.\n   *\n   * This primarily facilitates keyboard navigation.\n   */\n  _registerNode(node: CdkTreeNode<T, K>) {\n    this._nodes.value.set(this._getExpansionKey(node.data), node);\n    this._nodes.next(this._nodes.value);\n  }\n\n  /** Removes the specified node component from the tree's internal registry. */\n  _unregisterNode(node: CdkTreeNode<T, K>) {\n    this._nodes.value.delete(this._getExpansionKey(node.data));\n    this._nodes.next(this._nodes.value);\n  }\n\n  /**\n   * For the given node, determine the level where this node appears in the tree.\n   *\n   * This is intended to be used for `aria-level` but is 0-indexed.\n   */\n  _getLevel(node: T) {\n    return this._levels.get(this._getExpansionKey(node));\n  }\n\n  /**\n   * For the given node, determine the size of the parent's child set.\n   *\n   * This is intended to be used for `aria-setsize`.\n   */\n  _getSetSize(dataNode: T) {\n    const set = this._getAriaSet(dataNode);\n    return set.length;\n  }\n\n  /**\n   * For the given node, determine the index (starting from 1) of the node in its parent's child set.\n   *\n   * This is intended to be used for `aria-posinset`.\n   */\n  _getPositionInSet(dataNode: T) {\n    const set = this._getAriaSet(dataNode);\n    const key = this._getExpansionKey(dataNode);\n    return set.findIndex(node => this._getExpansionKey(node) === key) + 1;\n  }\n\n  /** Given a CdkTreeNode, gets the node that renders that node's parent's data. */\n  _getNodeParent(node: CdkTreeNode<T, K>) {\n    const parent = this._parents.get(this._getExpansionKey(node.data));\n    return parent && this._nodes.value.get(this._getExpansionKey(parent));\n  }\n\n  /** Given a CdkTreeNode, gets the nodes that renders that node's child data. */\n  _getNodeChildren(node: CdkTreeNode<T, K>) {\n    return this._getDirectChildren(node.data).pipe(\n      map(children =>\n        children.reduce<CdkTreeNode<T, K>[]>((nodes, child) => {\n          const value = this._nodes.value.get(this._getExpansionKey(child));\n          if (value) {\n            nodes.push(value);\n          }\n\n          return nodes;\n        }, []),\n      ),\n    );\n  }\n\n  /** `keydown` event handler; this just passes the event to the `TreeKeyManager`. */\n  _sendKeydownToKeyManager(event: KeyboardEvent) {\n    this._keyManager.onKeydown(event);\n  }\n\n  /** Gets all nested descendants of a given node. */\n  private _getDescendants(dataNode: T): Observable<T[]> {\n    if (this.treeControl) {\n      return observableOf(this.treeControl.getDescendants(dataNode));\n    }\n    if (this.levelAccessor) {\n      const results = this._findChildrenByLevel(\n        this.levelAccessor,\n        this._flattenedNodes.value,\n        dataNode,\n        Infinity,\n      );\n      return observableOf(results);\n    }\n    if (this.childrenAccessor) {\n      return this._getAllChildrenRecursively(dataNode).pipe(\n        reduce((allChildren: T[], nextChildren) => {\n          allChildren.push(...nextChildren);\n          return allChildren;\n        }, []),\n      );\n    }\n    throw getTreeControlMissingError();\n  }\n\n  /**\n   * Gets all children and sub-children of the provided node.\n   *\n   * This will emit multiple times, in the order that the children will appear\n   * in the tree, and can be combined with a `reduce` operator.\n   */\n  private _getAllChildrenRecursively(dataNode: T): Observable<T[]> {\n    if (!this.childrenAccessor) {\n      return observableOf([]);\n    }\n\n    return coerceObservable(this.childrenAccessor(dataNode)).pipe(\n      take(1),\n      switchMap(children => {\n        // Here, we cache the parents of a particular child so that we can compute the levels.\n        for (const child of children) {\n          this._parents.set(this._getExpansionKey(child), dataNode);\n        }\n        return observableOf(...children).pipe(\n          concatMap(child => concat(observableOf([child]), this._getAllChildrenRecursively(child))),\n        );\n      }),\n    );\n  }\n\n  private _getExpansionKey(dataNode: T): K {\n    // In the case that a key accessor function was not provided by the\n    // tree user, we'll default to using the node object itself as the key.\n    //\n    // This cast is safe since:\n    // - if an expansionKey is provided, TS will infer the type of K to be\n    //   the return type.\n    // - if it's not, then K will be defaulted to T.\n    return this.expansionKey?.(dataNode) ?? (dataNode as unknown as K);\n  }\n\n  private _getAriaSet(node: T) {\n    const key = this._getExpansionKey(node);\n    const parent = this._parents.get(key);\n    const parentKey = parent ? this._getExpansionKey(parent) : null;\n    const set = this._ariaSets.get(parentKey);\n    return set ?? [node];\n  }\n\n  /**\n   * Finds the parent for the given node. If this is a root node, this\n   * returns null. If we're unable to determine the parent, for example,\n   * if we don't have cached node data, this returns undefined.\n   */\n  private _findParentForNode(node: T, index: number, cachedNodes: readonly T[]): T | null {\n    // In all cases, we have a mapping from node to level; all we need to do here is backtrack in\n    // our flattened list of nodes to determine the first node that's of a level lower than the\n    // provided node.\n    if (!cachedNodes.length) {\n      return null;\n    }\n    const currentLevel = this._levels.get(this._getExpansionKey(node)) ?? 0;\n    for (let parentIndex = index - 1; parentIndex >= 0; parentIndex--) {\n      const parentNode = cachedNodes[parentIndex];\n      const parentLevel = this._levels.get(this._getExpansionKey(parentNode)) ?? 0;\n\n      if (parentLevel < currentLevel) {\n        return parentNode;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Given a set of root nodes and the current node level, flattens any nested\n   * nodes into a single array.\n   *\n   * If any nodes are not expanded, then their children will not be added into the array.\n   * This will still traverse all nested children in order to build up our internal data\n   * models, but will not include them in the returned array.\n   */\n  private _flattenNestedNodesWithExpansion(nodes: readonly T[], level = 0): Observable<T[]> {\n    const childrenAccessor = this._getChildrenAccessor();\n    // If we're using a level accessor, we don't need to flatten anything.\n    if (!childrenAccessor) {\n      return observableOf([...nodes]);\n    }\n\n    return observableOf(...nodes).pipe(\n      concatMap(node => {\n        const parentKey = this._getExpansionKey(node);\n        if (!this._parents.has(parentKey)) {\n          this._parents.set(parentKey, null);\n        }\n        this._levels.set(parentKey, level);\n\n        const children = coerceObservable(childrenAccessor(node));\n        return concat(\n          observableOf([node]),\n          children.pipe(\n            take(1),\n            tap(childNodes => {\n              this._ariaSets.set(parentKey, [...(childNodes ?? [])]);\n              for (const child of childNodes ?? []) {\n                const childKey = this._getExpansionKey(child);\n                this._parents.set(childKey, node);\n                this._levels.set(childKey, level + 1);\n              }\n            }),\n            switchMap(childNodes => {\n              if (!childNodes) {\n                return observableOf([]);\n              }\n              return this._flattenNestedNodesWithExpansion(childNodes, level + 1).pipe(\n                map(nestedNodes => (this.isExpanded(node) ? nestedNodes : [])),\n              );\n            }),\n          ),\n        );\n      }),\n      reduce((results, children) => {\n        results.push(...children);\n        return results;\n      }, [] as T[]),\n    );\n  }\n\n  /**\n   * Converts children for certain tree configurations.\n   *\n   * This also computes parent, level, and group data.\n   */\n  private _computeRenderingData(\n    nodes: readonly T[],\n    nodeType: 'flat' | 'nested',\n  ): Observable<{\n    renderNodes: readonly T[];\n    flattenedNodes: readonly T[];\n  }> {\n    // The only situations where we have to convert children types is when\n    // they're mismatched; i.e. if the tree is using a childrenAccessor and the\n    // nodes are flat, or if the tree is using a levelAccessor and the nodes are\n    // nested.\n    if (this.childrenAccessor && nodeType === 'flat') {\n      // This flattens children into a single array.\n      this._ariaSets.set(null, [...nodes]);\n      return this._flattenNestedNodesWithExpansion(nodes).pipe(\n        map(flattenedNodes => ({\n          renderNodes: flattenedNodes,\n          flattenedNodes,\n        })),\n      );\n    } else if (this.levelAccessor && nodeType === 'nested') {\n      // In the nested case, we only look for root nodes. The CdkNestedNode\n      // itself will handle rendering each individual node's children.\n      const levelAccessor = this.levelAccessor;\n      return observableOf(nodes.filter(node => levelAccessor(node) === 0)).pipe(\n        map(rootNodes => ({\n          renderNodes: rootNodes,\n          flattenedNodes: nodes,\n        })),\n        tap(({flattenedNodes}) => {\n          this._calculateParents(flattenedNodes);\n        }),\n      );\n    } else if (nodeType === 'flat') {\n      // In the case of a TreeControl, we know that the node type matches up\n      // with the TreeControl, and so no conversions are necessary. Otherwise,\n      // we've already confirmed that the data model matches up with the\n      // desired node type here.\n      return observableOf({renderNodes: nodes, flattenedNodes: nodes}).pipe(\n        tap(({flattenedNodes}) => {\n          this._calculateParents(flattenedNodes);\n        }),\n      );\n    } else {\n      // For nested nodes, we still need to perform the node flattening in order\n      // to maintain our caches for various tree operations.\n      this._ariaSets.set(null, [...nodes]);\n      return this._flattenNestedNodesWithExpansion(nodes).pipe(\n        map(flattenedNodes => ({\n          renderNodes: nodes,\n          flattenedNodes,\n        })),\n      );\n    }\n  }\n\n  private _updateCachedData(flattenedNodes: readonly T[]) {\n    this._flattenedNodes.next(flattenedNodes);\n  }\n\n  private _updateKeyManagerItems(flattenedNodes: readonly T[]) {\n    this._keyManagerNodes.next(flattenedNodes);\n  }\n\n  /** Traverse the flattened node data and compute parents, levels, and group data. */\n  private _calculateParents(flattenedNodes: readonly T[]): void {\n    const levelAccessor = this._getLevelAccessor();\n    if (!levelAccessor) {\n      return;\n    }\n\n    this._parents.clear();\n    this._ariaSets.clear();\n\n    for (let index = 0; index < flattenedNodes.length; index++) {\n      const dataNode = flattenedNodes[index];\n      const key = this._getExpansionKey(dataNode);\n      this._levels.set(key, levelAccessor(dataNode));\n      const parent = this._findParentForNode(dataNode, index, flattenedNodes);\n      this._parents.set(key, parent);\n      const parentKey = parent ? this._getExpansionKey(parent) : null;\n\n      const group = this._ariaSets.get(parentKey) ?? [];\n      group.splice(index, 0, dataNode);\n      this._ariaSets.set(parentKey, group);\n    }\n  }\n}\n\n/**\n * Tree node for CdkTree. It contains the data in the tree node.\n */\n@Directive({\n  selector: 'cdk-tree-node',\n  exportAs: 'cdkTreeNode',\n  host: {\n    'class': 'cdk-tree-node',\n    '[attr.aria-expanded]': '_getAriaExpanded()',\n    '[attr.aria-level]': 'level + 1',\n    '[attr.aria-posinset]': '_getPositionInSet()',\n    '[attr.aria-setsize]': '_getSetSize()',\n    '[tabindex]': '_tabindex',\n    'role': 'treeitem',\n    '(click)': '_setActiveItem()',\n    '(focus)': '_focusItem()',\n  },\n  standalone: true,\n})\nexport class CdkTreeNode<T, K = T> implements OnDestroy, OnInit, TreeKeyManagerItem {\n  protected _tabindex: number | null = -1;\n\n  /**\n   * The role of the tree node.\n   *\n   * @deprecated This will be ignored; the tree will automatically determine the appropriate role\n   * for tree node. This input will be removed in a future version.\n   * @breaking-change 21.0.0\n   */\n  @Input() get role(): 'treeitem' | 'group' {\n    return 'treeitem';\n  }\n\n  set role(_role: 'treeitem' | 'group') {\n    // ignore any role setting, we handle this internally.\n  }\n\n  /**\n   * Whether or not this node is expandable.\n   *\n   * If not using `FlatTreeControl`, or if `isExpandable` is not provided to\n   * `NestedTreeControl`, this should be provided for correct node a11y.\n   */\n  @Input({transform: booleanAttribute})\n  get isExpandable() {\n    return this._isExpandable();\n  }\n  set isExpandable(isExpandable: boolean) {\n    this._inputIsExpandable = isExpandable;\n  }\n\n  @Input()\n  get isExpanded(): boolean {\n    return this._tree.isExpanded(this._data);\n  }\n  set isExpanded(isExpanded: boolean) {\n    if (isExpanded) {\n      this.expand();\n    } else {\n      this.collapse();\n    }\n  }\n\n  /**\n   * Whether or not this node is disabled. If it's disabled, then the user won't be able to focus\n   * or activate this node.\n   */\n  @Input({transform: booleanAttribute}) isDisabled: boolean;\n\n  /**\n   * The text used to locate this item during typeahead. If not specified, the `textContent` will\n   * will be used.\n   */\n  @Input('cdkTreeNodeTypeaheadLabel') typeaheadLabel: string | null;\n\n  getLabel(): string {\n    return this.typeaheadLabel || this._elementRef.nativeElement.textContent?.trim() || '';\n  }\n\n  /** This emits when the node has been programatically activated or activated by keyboard. */\n  @Output()\n  readonly activation: EventEmitter<T> = new EventEmitter<T>();\n\n  /** This emits when the node's expansion status has been changed. */\n  @Output()\n  readonly expandedChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n  /**\n   * The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it\n   * in `CdkTree` and set the data to it.\n   */\n  static mostRecentTreeNode: CdkTreeNode<any> | null = null;\n\n  /** Subject that emits when the component has been destroyed. */\n  protected readonly _destroyed = new Subject<void>();\n\n  /** Emits when the node's data has changed. */\n  readonly _dataChanges = new Subject<void>();\n\n  private _inputIsExpandable: boolean = false;\n  /**\n   * Flag used to determine whether or not we should be focusing the actual element based on\n   * some user interaction (click or focus). On click, we don't forcibly focus the element\n   * since the click could trigger some other component that wants to grab its own focus\n   * (e.g. menu, dialog).\n   */\n  private _shouldFocus = true;\n  private _parentNodeAriaLevel: number;\n\n  /** The tree node's data. */\n  get data(): T {\n    return this._data;\n  }\n  set data(value: T) {\n    if (value !== this._data) {\n      this._data = value;\n      this._dataChanges.next();\n    }\n  }\n  protected _data: T;\n\n  /* If leaf node, return true to not assign aria-expanded attribute */\n  get isLeafNode(): boolean {\n    // If flat tree node data returns false for expandable property, it's a leaf node\n    if (\n      this._tree.treeControl?.isExpandable !== undefined &&\n      !this._tree.treeControl.isExpandable(this._data)\n    ) {\n      return true;\n\n      // If nested tree node data returns 0 descendants, it's a leaf node\n    } else if (\n      this._tree.treeControl?.isExpandable === undefined &&\n      this._tree.treeControl?.getDescendants(this._data).length === 0\n    ) {\n      return true;\n    }\n\n    return false;\n  }\n\n  get level(): number {\n    // If the tree has a levelAccessor, use it to get the level. Otherwise read the\n    // aria-level off the parent node and use it as the level for this node (note aria-level is\n    // 1-indexed, while this property is 0-indexed, so we don't need to increment).\n    return this._tree._getLevel(this._data) ?? this._parentNodeAriaLevel;\n  }\n\n  /** Determines if the tree node is expandable. */\n  _isExpandable(): boolean {\n    if (this._tree.treeControl) {\n      if (this.isLeafNode) {\n        return false;\n      }\n\n      // For compatibility with trees created using TreeControl before we added\n      // CdkTreeNode#isExpandable.\n      return true;\n    }\n    return this._inputIsExpandable;\n  }\n\n  /**\n   * Determines the value for `aria-expanded`.\n   *\n   * For non-expandable nodes, this is `null`.\n   */\n  _getAriaExpanded(): string | null {\n    if (!this._isExpandable()) {\n      return null;\n    }\n    return String(this.isExpanded);\n  }\n\n  /**\n   * Determines the size of this node's parent's child set.\n   *\n   * This is intended to be used for `aria-setsize`.\n   */\n  _getSetSize(): number {\n    return this._tree._getSetSize(this._data);\n  }\n\n  /**\n   * Determines the index (starting from 1) of this node in its parent's child set.\n   *\n   * This is intended to be used for `aria-posinset`.\n   */\n  _getPositionInSet(): number {\n    return this._tree._getPositionInSet(this._data);\n  }\n\n  private _changeDetectorRef = inject(ChangeDetectorRef);\n\n  constructor(\n    protected _elementRef: ElementRef<HTMLElement>,\n    protected _tree: CdkTree<T, K>,\n  ) {\n    CdkTreeNode.mostRecentTreeNode = this as CdkTreeNode<T, K>;\n  }\n\n  ngOnInit(): void {\n    this._parentNodeAriaLevel = getParentNodeAriaLevel(this._elementRef.nativeElement);\n    this._tree\n      ._getExpansionModel()\n      .changed.pipe(\n        map(() => this.isExpanded),\n        distinctUntilChanged(),\n      )\n      .subscribe(() => {\n        this._changeDetectorRef.markForCheck();\n      });\n    this._tree._setNodeTypeIfUnset('flat');\n    this._tree._registerNode(this);\n  }\n\n  ngOnDestroy() {\n    // If this is the last tree node being destroyed,\n    // clear out the reference to avoid leaking memory.\n    if (CdkTreeNode.mostRecentTreeNode === this) {\n      CdkTreeNode.mostRecentTreeNode = null;\n    }\n\n    this._dataChanges.complete();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  getParent(): CdkTreeNode<T, K> | null {\n    return this._tree._getNodeParent(this) ?? null;\n  }\n\n  getChildren(): CdkTreeNode<T, K>[] | Observable<CdkTreeNode<T, K>[]> {\n    return this._tree._getNodeChildren(this);\n  }\n\n  /** Focuses this data node. Implemented for TreeKeyManagerItem. */\n  focus(): void {\n    this._tabindex = 0;\n    if (this._shouldFocus) {\n      this._elementRef.nativeElement.focus();\n    }\n\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Defocus this data node. */\n  unfocus(): void {\n    this._tabindex = -1;\n\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Emits an activation event. Implemented for TreeKeyManagerItem. */\n  activate(): void {\n    if (this.isDisabled) {\n      return;\n    }\n    this.activation.next(this._data);\n  }\n\n  /** Collapses this data node. Implemented for TreeKeyManagerItem. */\n  collapse(): void {\n    if (this.isExpandable) {\n      this._tree.collapse(this._data);\n    }\n  }\n\n  /** Expands this data node. Implemented for TreeKeyManagerItem. */\n  expand(): void {\n    if (this.isExpandable) {\n      this._tree.expand(this._data);\n    }\n  }\n\n  _focusItem() {\n    if (this.isDisabled) {\n      return;\n    }\n    this._tree._keyManager.focusItem(this);\n  }\n\n  _setActiveItem() {\n    if (this.isDisabled) {\n      return;\n    }\n    this._shouldFocus = false;\n    this._tree._keyManager.focusItem(this);\n    this._shouldFocus = true;\n  }\n\n  _emitExpansionState(expanded: boolean) {\n    this.expandedChange.emit(expanded);\n  }\n}\n\nfunction getParentNodeAriaLevel(nodeElement: HTMLElement): number {\n  let parent = nodeElement.parentElement;\n  while (parent && !isNodeElement(parent)) {\n    parent = parent.parentElement;\n  }\n  if (!parent) {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      throw Error('Incorrect tree structure containing detached node.');\n    } else {\n      return -1;\n    }\n  } else if (parent.classList.contains('cdk-nested-tree-node')) {\n    return numberAttribute(parent.getAttribute('aria-level')!);\n  } else {\n    // The ancestor element is the cdk-tree itself\n    return 0;\n  }\n}\n\nfunction isNodeElement(element: HTMLElement) {\n  const classList = element.classList;\n  return !!(classList?.contains('cdk-nested-tree-node') || classList?.contains('cdk-tree'));\n}\n"]}