You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
384 lines
53 KiB
384 lines
53 KiB
import { isDataSource } from '@angular/cdk/collections';
|
|
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, Directive, ElementRef, Input, IterableDiffers, QueryList, ViewChild, ViewEncapsulation } from '@angular/core';
|
|
import { BehaviorSubject, isObservable, of as observableOf, Subject, } from 'rxjs';
|
|
import { takeUntil } from 'rxjs/operators';
|
|
import { CdkTreeNodeDef, CdkTreeNodeOutletContext } from './node';
|
|
import { CdkTreeNodeOutlet } from './outlet';
|
|
import { getTreeControlFunctionsMissingError, getTreeControlMissingError, getTreeMissingMatchingNodeDefError, getTreeMultipleDefaultNodeDefsError, getTreeNoValidDataSourceError } from './tree-errors';
|
|
import { coerceNumberProperty } from '@angular/cdk/coercion';
|
|
/**
|
|
* 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.
|
|
*/
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from './outlet';
|
|
export class CdkTree {
|
|
constructor(_differs, _changeDetectorRef) {
|
|
this._differs = _differs;
|
|
this._changeDetectorRef = _changeDetectorRef;
|
|
/** Subject that emits when the component has been destroyed. */
|
|
this._onDestroy = new Subject();
|
|
/** Level of nodes */
|
|
this._levels = new Map();
|
|
// TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.
|
|
// Remove the MAX_VALUE in viewChange
|
|
/**
|
|
* Stream containing the latest information on what rows are being displayed on screen.
|
|
* Can be used by the data source to as a heuristic of what data should be provided.
|
|
*/
|
|
this.viewChange = new BehaviorSubject({ start: 0, end: Number.MAX_VALUE });
|
|
}
|
|
/**
|
|
* Provides a stream containing the latest data array to render. Influenced by the tree's
|
|
* stream of view window (what dataNodes are currently on screen).
|
|
* Data source can be an observable of data array, or a data array to render.
|
|
*/
|
|
get dataSource() { return this._dataSource; }
|
|
set dataSource(dataSource) {
|
|
if (this._dataSource !== dataSource) {
|
|
this._switchDataSource(dataSource);
|
|
}
|
|
}
|
|
ngOnInit() {
|
|
this._dataDiffer = this._differs.find([]).create(this.trackBy);
|
|
if (!this.treeControl && (typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
throw getTreeControlMissingError();
|
|
}
|
|
}
|
|
ngOnDestroy() {
|
|
this._nodeOutlet.viewContainer.clear();
|
|
this.viewChange.complete();
|
|
this._onDestroy.next();
|
|
this._onDestroy.complete();
|
|
if (this._dataSource && typeof this._dataSource.disconnect === 'function') {
|
|
this.dataSource.disconnect(this);
|
|
}
|
|
if (this._dataSubscription) {
|
|
this._dataSubscription.unsubscribe();
|
|
this._dataSubscription = null;
|
|
}
|
|
}
|
|
ngAfterContentChecked() {
|
|
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();
|
|
}
|
|
}
|
|
// 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
|
|
* clearing the node outlet. Otherwise start listening for new data.
|
|
*/
|
|
_switchDataSource(dataSource) {
|
|
if (this._dataSource && typeof this._dataSource.disconnect === 'function') {
|
|
this.dataSource.disconnect(this);
|
|
}
|
|
if (this._dataSubscription) {
|
|
this._dataSubscription.unsubscribe();
|
|
this._dataSubscription = null;
|
|
}
|
|
// Remove the all dataNodes if there is now no data source
|
|
if (!dataSource) {
|
|
this._nodeOutlet.viewContainer.clear();
|
|
}
|
|
this._dataSource = dataSource;
|
|
if (this._nodeDefs) {
|
|
this._observeRenderChanges();
|
|
}
|
|
}
|
|
/** Set up a subscription for the data provided by the data source. */
|
|
_observeRenderChanges() {
|
|
let dataStream;
|
|
if (isDataSource(this._dataSource)) {
|
|
dataStream = this._dataSource.connect(this);
|
|
}
|
|
else if (isObservable(this._dataSource)) {
|
|
dataStream = this._dataSource;
|
|
}
|
|
else if (Array.isArray(this._dataSource)) {
|
|
dataStream = observableOf(this._dataSource);
|
|
}
|
|
if (dataStream) {
|
|
this._dataSubscription = dataStream.pipe(takeUntil(this._onDestroy))
|
|
.subscribe(data => this.renderNodeChanges(data));
|
|
}
|
|
else if (typeof ngDevMode === 'undefined' || ngDevMode) {
|
|
throw getTreeNoValidDataSourceError();
|
|
}
|
|
}
|
|
/** 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) {
|
|
return;
|
|
}
|
|
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);
|
|
}
|
|
});
|
|
this._changeDetectorRef.detectChanges();
|
|
}
|
|
/**
|
|
* Finds the matching node definition that should be used for this node data. If there is only
|
|
* one node definition, it is returned. Otherwise, find the node definition that has a when
|
|
* predicate that returns true with the data. If none return true, return the default node
|
|
* definition.
|
|
*/
|
|
_getNodeDef(data, i) {
|
|
if (this._nodeDefs.length === 1) {
|
|
return this._nodeDefs.first;
|
|
}
|
|
const nodeDef = this._nodeDefs.find(def => def.when && def.when(i, data)) || this._defaultNodeDef;
|
|
if (!nodeDef && (typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
throw getTreeMissingMatchingNodeDefError();
|
|
}
|
|
return nodeDef;
|
|
}
|
|
/**
|
|
* Create the embedded view for the data node template and place it in the correct index location
|
|
* within the data node view container.
|
|
*/
|
|
insertNode(nodeData, index, viewContainer, parentData) {
|
|
const node = this._getNodeDef(nodeData, index);
|
|
// Node context that will be provided to created embedded view
|
|
const context = new CdkTreeNodeOutletContext(nodeData);
|
|
// 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);
|
|
}
|
|
else if (typeof parentData !== 'undefined' && this._levels.has(parentData)) {
|
|
context.level = this._levels.get(parentData) + 1;
|
|
}
|
|
else {
|
|
context.level = 0;
|
|
}
|
|
this._levels.set(nodeData, context.level);
|
|
// Use default tree nodeOutlet, or nested node's nodeOutlet
|
|
const container = viewContainer ? viewContainer : this._nodeOutlet.viewContainer;
|
|
container.createEmbeddedView(node.template, context, index);
|
|
// Set the data to just created `CdkTreeNode`.
|
|
// The `CdkTreeNode` created from `createEmbeddedView` will be saved in static variable
|
|
// `mostRecentTreeNode`. We get it from static variable and pass the node data to it.
|
|
if (CdkTreeNode.mostRecentTreeNode) {
|
|
CdkTreeNode.mostRecentTreeNode.data = nodeData;
|
|
}
|
|
}
|
|
}
|
|
CdkTree.ɵfac = function CdkTree_Factory(t) { return new (t || CdkTree)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.IterableDiffers), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef)); };
|
|
CdkTree.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: CdkTree, selectors: [["cdk-tree"]], contentQueries: function CdkTree_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
|
|
ɵngcc0.ɵɵcontentQuery(dirIndex, CdkTreeNodeDef, 5);
|
|
} if (rf & 2) {
|
|
let _t;
|
|
ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._nodeDefs = _t);
|
|
} }, viewQuery: function CdkTree_Query(rf, ctx) { if (rf & 1) {
|
|
ɵngcc0.ɵɵviewQuery(CdkTreeNodeOutlet, 7);
|
|
} if (rf & 2) {
|
|
let _t;
|
|
ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._nodeOutlet = _t.first);
|
|
} }, hostAttrs: ["role", "tree", 1, "cdk-tree"], inputs: { dataSource: "dataSource", treeControl: "treeControl", trackBy: "trackBy" }, exportAs: ["cdkTree"], decls: 1, vars: 0, consts: [["cdkTreeNodeOutlet", ""]], template: function CdkTree_Template(rf, ctx) { if (rf & 1) {
|
|
ɵngcc0.ɵɵelementContainer(0, 0);
|
|
} }, directives: [ɵngcc1.CdkTreeNodeOutlet], encapsulation: 2 });
|
|
CdkTree.ctorParameters = () => [
|
|
{ type: IterableDiffers },
|
|
{ type: ChangeDetectorRef }
|
|
];
|
|
CdkTree.propDecorators = {
|
|
dataSource: [{ type: Input }],
|
|
treeControl: [{ type: Input }],
|
|
trackBy: [{ type: Input }],
|
|
_nodeOutlet: [{ type: ViewChild, args: [CdkTreeNodeOutlet, { static: true },] }],
|
|
_nodeDefs: [{ type: ContentChildren, args: [CdkTreeNodeDef, {
|
|
// We need to use `descendants: true`, because Ivy will no longer match
|
|
// indirect descendants if it's left as false.
|
|
descendants: true
|
|
},] }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkTree, [{
|
|
type: Component,
|
|
args: [{
|
|
selector: 'cdk-tree',
|
|
exportAs: 'cdkTree',
|
|
template: `<ng-container cdkTreeNodeOutlet></ng-container>`,
|
|
host: {
|
|
'class': 'cdk-tree',
|
|
'role': 'tree'
|
|
},
|
|
encapsulation: ViewEncapsulation.None,
|
|
// The "OnPush" status for the `CdkTree` component is effectively a noop, so we are removing it.
|
|
// The view for `CdkTree` consists entirely of templates declared in other views. As they are
|
|
// declared elsewhere, they are checked when their declaration points are checked.
|
|
// tslint:disable-next-line:validate-decorators
|
|
changeDetection: ChangeDetectionStrategy.Default
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.IterableDiffers }, { type: ɵngcc0.ChangeDetectorRef }]; }, { dataSource: [{
|
|
type: Input
|
|
}], treeControl: [{
|
|
type: Input
|
|
}], trackBy: [{
|
|
type: Input
|
|
}], _nodeOutlet: [{
|
|
type: ViewChild,
|
|
args: [CdkTreeNodeOutlet, { static: true }]
|
|
}], _nodeDefs: [{
|
|
type: ContentChildren,
|
|
args: [CdkTreeNodeDef, {
|
|
// We need to use `descendants: true`, because Ivy will no longer match
|
|
// indirect descendants if it's left as false.
|
|
descendants: true
|
|
}]
|
|
}] }); })();
|
|
/**
|
|
* Tree node for CdkTree. It contains the data in the tree node.
|
|
*/
|
|
export class CdkTreeNode {
|
|
constructor(_elementRef, _tree) {
|
|
this._elementRef = _elementRef;
|
|
this._tree = _tree;
|
|
/** 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();
|
|
CdkTreeNode.mostRecentTreeNode = this;
|
|
// The classes are directly added here instead of in the host property because classes on
|
|
// the host property are not inherited with View Engine. It is not set as a @HostBinding because
|
|
// it is not set by the time it's children nodes try to read the class from it.
|
|
// TODO: move to host after View Engine deprecation
|
|
this._elementRef.nativeElement.classList.add('cdk-tree-node');
|
|
this.role = 'treeitem';
|
|
}
|
|
/**
|
|
* 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
|
|
*/
|
|
get role() { return 'treeitem'; }
|
|
set role(_role) {
|
|
// TODO: move to host after View Engine deprecation
|
|
this._elementRef.nativeElement.setAttribute('role', _role);
|
|
}
|
|
/** The tree node's data. */
|
|
get data() { return this._data; }
|
|
set data(value) {
|
|
if (value !== this._data) {
|
|
this._data = value;
|
|
this._setRoleFromData();
|
|
this._dataChanges.next();
|
|
}
|
|
}
|
|
get isExpanded() {
|
|
return this._tree.treeControl.isExpanded(this._data);
|
|
}
|
|
_setExpanded(_expanded) {
|
|
this._isAriaExpanded = _expanded;
|
|
this._elementRef.nativeElement.setAttribute('aria-expanded', `${_expanded}`);
|
|
}
|
|
get level() {
|
|
// If the treeControl has a getLevel method, 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;
|
|
}
|
|
ngOnInit() {
|
|
this._parentNodeAriaLevel = getParentNodeAriaLevel(this._elementRef.nativeElement);
|
|
this._elementRef.nativeElement.setAttribute('aria-level', `${this.level + 1}`);
|
|
}
|
|
ngDoCheck() {
|
|
// aria-expanded is be set here because the expanded state is stored in the tree control and
|
|
// the node isn't aware when the state is changed.
|
|
// It is not set using a @HostBinding because they sometimes get lost with Mixin based classes.
|
|
// TODO: move to host after View Engine deprecation
|
|
if (this.isExpanded != this._isAriaExpanded) {
|
|
this._setExpanded(this.isExpanded);
|
|
}
|
|
}
|
|
ngOnDestroy() {
|
|
// If this is the last tree node being destroyed,
|
|
// clear out the reference to avoid leaking memory.
|
|
if (CdkTreeNode.mostRecentTreeNode === this) {
|
|
CdkTreeNode.mostRecentTreeNode = null;
|
|
}
|
|
this._dataChanges.complete();
|
|
this._destroyed.next();
|
|
this._destroyed.complete();
|
|
}
|
|
/** Focuses the menu item. Implements for FocusableOption. */
|
|
focus() {
|
|
this._elementRef.nativeElement.focus();
|
|
}
|
|
// 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();
|
|
}
|
|
this.role = 'treeitem';
|
|
}
|
|
}
|
|
CdkTreeNode.ɵfac = function CdkTreeNode_Factory(t) { return new (t || CdkTreeNode)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(CdkTree)); };
|
|
CdkTreeNode.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkTreeNode, selectors: [["cdk-tree-node"]], inputs: { role: "role" }, exportAs: ["cdkTreeNode"] });
|
|
/**
|
|
* The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it
|
|
* in `CdkTree` and set the data to it.
|
|
*/
|
|
CdkTreeNode.mostRecentTreeNode = null;
|
|
CdkTreeNode.ctorParameters = () => [
|
|
{ type: ElementRef },
|
|
{ type: CdkTree }
|
|
];
|
|
CdkTreeNode.propDecorators = {
|
|
role: [{ type: Input }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkTreeNode, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: 'cdk-tree-node',
|
|
exportAs: 'cdkTreeNode'
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.ElementRef }, { type: CdkTree }]; }, { role: [{
|
|
type: Input
|
|
}] }); })();
|
|
function getParentNodeAriaLevel(nodeElement) {
|
|
let parent = nodeElement.parentElement;
|
|
while (parent && !isNodeElement(parent)) {
|
|
parent = parent.parentElement;
|
|
}
|
|
if (!parent) {
|
|
if (typeof ngDevMode === 'undefined' || ngDevMode) {
|
|
throw Error('Incorrect tree structure containing detached node.');
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
}
|
|
else if (parent.classList.contains('cdk-nested-tree-node')) {
|
|
return coerceNumberProperty(parent.getAttribute('aria-level'));
|
|
}
|
|
else {
|
|
// The ancestor element is the cdk-tree itself
|
|
return 0;
|
|
}
|
|
}
|
|
function isNodeElement(element) {
|
|
const classList = element.classList;
|
|
return !!((classList === null || classList === void 0 ? void 0 : classList.contains('cdk-nested-tree-node')) || (classList === null || classList === void 0 ? void 0 : classList.contains('cdk-tree')));
|
|
}
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tree.js","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  DoCheck,\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} from '@angular/core';\nimport {\n  BehaviorSubject,\n  isObservable,\n  Observable,\n  of as observableOf,\n  Subject,\n  Subscription,\n} from 'rxjs';\nimport {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';\nimport {coerceNumberProperty} from '@angular/cdk/coercion';\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\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})\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[] { return this._dataSource; }\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  }) _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 =\n    new BehaviorSubject<{start: number, end: number}>({start: 0, end: Number.MAX_VALUE});\n\n  constructor(private _differs: IterableDiffers,\n              private _changeDetectorRef: ChangeDetectorRef) {}\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\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.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(data: readonly T[], dataDiffer: IterableDiffer<T> = this._dataDiffer,\n                    viewContainer: ViewContainerRef = this._nodeOutlet.viewContainer,\n                    parentData?: T) {\n    const changes = dataDiffer.diff(data);\n    if (!changes) { return; }\n\n    changes.forEachOperation((item: IterableChangeRecord<T>,\n                              adjustedPreviousIndex: number | null,\n                              currentIndex: number | null) => {\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    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) { return this._nodeDefs.first; }\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/**\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})\nexport class CdkTreeNode<T, K = T> implements DoCheck, 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' { return 'treeitem'; }\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 { return this._data; }\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  private _setExpanded(_expanded: boolean) {\n    this._isAriaExpanded = _expanded;\n    this._elementRef.nativeElement.setAttribute('aria-expanded', `${_expanded}`);\n  }\n\n  protected _isAriaExpanded: boolean;\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) : this._parentNodeAriaLevel;\n   }\n\n  constructor(protected _elementRef: ElementRef<HTMLElement>,\n              protected _tree: CdkTree<T, K>) {\n    CdkTreeNode.mostRecentTreeNode = this as CdkTreeNode<T, K>;\n    // The classes are directly added here instead of in the host property because classes on\n    // the host property are not inherited with View Engine. It is not set as a @HostBinding because\n    // it is not set by the time it's children nodes try to read the class from it.\n    // TODO: move to host after View Engine deprecation\n    this._elementRef.nativeElement.classList.add('cdk-tree-node');\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  }\n\n  ngDoCheck() {\n    // aria-expanded is be set here because the expanded state is stored in the tree control and\n    // the node isn't aware when the state is changed.\n    // It is not set using a @HostBinding because they sometimes get lost with Mixin based classes.\n    // TODO: move to host after View Engine deprecation\n    if (this.isExpanded != this._isAriaExpanded) {\n      this._setExpanded(this.isExpanded);\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 (!this._tree.treeControl.isExpandable && !this._tree.treeControl.getChildren &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)) {\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 coerceNumberProperty(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"]}
|