@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/tree/tree.js

@@ -9,305 +9,297 @@ import { getTreeControlFunctionsMissingError, getTreeControlMissingError, getTre
  * 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.
  */
-let CdkTree = /** @class */ (() => {
-    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 });
-        }
+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
         /**
-         * 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.
+         * 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.
          */
-        get dataSource() { return this._dataSource; }
-        set dataSource(dataSource) {
-            if (this._dataSource !== dataSource) {
-                this._switchDataSource(dataSource);
-            }
+        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) {
-                throw getTreeControlMissingError();
-            }
+    }
+    ngOnInit() {
+        this._dataDiffer = this._differs.find([]).create(this.trackBy);
+        if (!this.treeControl) {
+            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;
         }
-        ngOnDestroy() {
+    }
+    ngAfterContentChecked() {
+        const defaultNodeDefs = this._nodeDefs.filter(def => !def.when);
+        if (defaultNodeDefs.length > 1) {
+            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.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) {
-                throw getTreeMultipleDefaultNodeDefsError();
-            }
-            this._defaultNodeDef = defaultNodeDefs[0];
-            if (this.dataSource && this._nodeDefs && !this._dataSubscription) {
-                this._observeRenderChanges();
-            }
+        this._dataSource = dataSource;
+        if (this._nodeDefs) {
+            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);
         }
-        /** 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 {
-                throw getTreeNoValidDataSourceError();
-            }
+        else if (isObservable(this._dataSource)) {
+            dataStream = this._dataSource;
         }
-        /** 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();
+        else if (Array.isArray(this._dataSource)) {
+            dataStream = observableOf(this._dataSource);
         }
-        /**
-         * 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) {
-                throw getTreeMissingMatchingNodeDefError();
-            }
-            return nodeDef;
+        if (dataStream) {
+            this._dataSubscription = dataStream.pipe(takeUntil(this._onDestroy))
+                .subscribe(data => this.renderNodeChanges(data));
         }
-        /**
-         * 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 {
+            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 (typeof parentData !== 'undefined' && this._levels.has(parentData)) {
-                context.level = this._levels.get(parentData) + 1;
+            else if (currentIndex == null) {
+                viewContainer.remove(adjustedPreviousIndex);
+                this._levels.delete(item.item);
             }
             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;
+                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) {
+            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.decorators = [
-        { 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
-                },] }
-    ];
-    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
-                    },] }]
-    };
-    return CdkTree;
-})();
-export { CdkTree };
+}
+CdkTree.decorators = [
+    { 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
+            },] }
+];
+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
+                },] }]
+};
 /**
  * Tree node for CdkTree. It contains the data in the tree node.
  */
-let CdkTreeNode = /** @class */ (() => {
-    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();
-            /**
-             * The role of the node should be 'group' if it's an internal node,
-             * and 'treeitem' if it's a leaf node.
-             */
-            this.role = 'treeitem';
-            CdkTreeNode.mostRecentTreeNode = this;
-        }
-        /** 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();
-            }
+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();
+        /**
+         * The role of the node should be 'group' if it's an internal node,
+         * and 'treeitem' if it's a leaf node.
+         */
+        this.role = 'treeitem';
+        CdkTreeNode.mostRecentTreeNode = this;
+    }
+    /** 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);
+    }
+    get isExpanded() {
+        return this._tree.treeControl.isExpanded(this._data);
+    }
+    get level() {
+        return this._tree.treeControl.getLevel ? this._tree.treeControl.getLevel(this._data) : 0;
+    }
+    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;
         }
-        get level() {
-            return this._tree.treeControl.getLevel ? this._tree.treeControl.getLevel(this._data) : 0;
+        this._dataChanges.complete();
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /** Focuses the menu item. Implements for FocusableOption. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    _setRoleFromData() {
+        if (this._tree.treeControl.isExpandable) {
+            this.role = this._tree.treeControl.isExpandable(this._data) ? 'group' : 'treeitem';
         }
-        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;
+        else {
+            if (!this._tree.treeControl.getChildren) {
+                throw getTreeControlFunctionsMissingError();
             }
-            this._dataChanges.complete();
-            this._destroyed.next();
-            this._destroyed.complete();
-        }
-        /** Focuses the menu item. Implements for FocusableOption. */
-        focus() {
-            this._elementRef.nativeElement.focus();
-        }
-        _setRoleFromData() {
-            if (this._tree.treeControl.isExpandable) {
-                this.role = this._tree.treeControl.isExpandable(this._data) ? 'group' : 'treeitem';
+            const childrenNodes = this._tree.treeControl.getChildren(this._data);
+            if (Array.isArray(childrenNodes)) {
+                this._setRoleFromChildren(childrenNodes);
             }
-            else {
-                if (!this._tree.treeControl.getChildren) {
-                    throw getTreeControlFunctionsMissingError();
-                }
-                const childrenNodes = this._tree.treeControl.getChildren(this._data);
-                if (Array.isArray(childrenNodes)) {
-                    this._setRoleFromChildren(childrenNodes);
-                }
-                else if (isObservable(childrenNodes)) {
-                    childrenNodes.pipe(takeUntil(this._destroyed))
-                        .subscribe(children => this._setRoleFromChildren(children));
-                }
+            else if (isObservable(childrenNodes)) {
+                childrenNodes.pipe(takeUntil(this._destroyed))
+                    .subscribe(children => this._setRoleFromChildren(children));
             }
         }
-        _setRoleFromChildren(children) {
-            this.role = children && children.length ? 'group' : 'treeitem';
-        }
     }
-    /**
-     * 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.decorators = [
-        { type: Directive, args: [{
-                    selector: 'cdk-tree-node',
-                    exportAs: 'cdkTreeNode',
-                    host: {
-                        '[attr.aria-expanded]': 'isExpanded',
-                        '[attr.aria-level]': 'role === "treeitem" ? level : null',
-                        '[attr.role]': 'role',
-                        'class': 'cdk-tree-node',
-                    },
-                },] }
-    ];
-    CdkTreeNode.ctorParameters = () => [
-        { type: ElementRef },
-        { type: CdkTree }
-    ];
-    CdkTreeNode.propDecorators = {
-        role: [{ type: Input }]
-    };
-    return CdkTreeNode;
-})();
-export { CdkTreeNode };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../../src/cdk/tree/tree.ts"],"names":[],"mappings":"AAQA,OAAO,EAA+B,YAAY,EAAC,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAEL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,SAAS,EACT,UAAU,EACV,KAAK,EAGL,eAAe,EAGf,SAAS,EACT,SAAS,EAET,iBAAiB,EAElB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EAEf,EAAE,IAAI,YAAY,EAClB,OAAO,EAEP,YAAY,GACb,MAAM,MAAM,CAAC;AACd,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAEzC,OAAO,EAAC,cAAc,EAAE,wBAAwB,EAAC,MAAM,QAAQ,CAAC;AAChE,OAAO,EAAC,iBAAiB,EAAC,MAAM,UAAU,CAAC;AAC3C,OAAO,EACL,mCAAmC,EACnC,0BAA0B,EAC1B,kCAAkC,EAClC,mCAAmC,EACnC,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AAEvB;;;GAGG;AACH;IAAA,MAgBa,OAAO;QA4DlB,YAAoB,QAAyB,EACzB,kBAAqC;YADrC,aAAQ,GAAR,QAAQ,CAAiB;YACzB,uBAAkB,GAAlB,kBAAkB,CAAmB;YA5DzD,gEAAgE;YACxD,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;YAWzC,qBAAqB;YACb,YAAO,GAAmB,IAAI,GAAG,EAAa,CAAC;YAqCvD,6FAA6F;YAC7F,yCAAyC;YACzC;;;eAGG;YACH,eAAU,GACR,IAAI,eAAe,CAA+B,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,SAAS,EAAC,CAAC,CAAC;QAG3B,CAAC;QA7C7D;;;;WAIG;QACH,IACI,UAAU,KAA4C,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACpF,IAAI,UAAU,CAAC,UAAiD;YAC9D,IAAI,IAAI,CAAC,WAAW,KAAK,UAAU,EAAE;gBACnC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;aACpC;QACH,CAAC;QAoCD,QAAQ;YACN,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC/D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACrB,MAAM,0BAA0B,EAAE,CAAC;aACpC;QACH,CAAC;QAED,WAAW;YACT,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAEvC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YAE3B,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,UAAU,KAAK,UAAU,EAAE;gBAC3F,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aACrD;YAED,IAAI,IAAI,CAAC,iBAAiB,EAAE;gBAC1B,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;gBACrC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;aAC/B;QACH,CAAC;QAED,qBAAqB;YACnB,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAChE,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC9B,MAAM,mCAAmC,EAAE,CAAC;aAC7C;YACD,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;YAE1C,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;gBAChE,IAAI,CAAC,qBAAqB,EAAE,CAAC;aAC9B;QACH,CAAC;QAGD,4FAA4F;QAC5F,wBAAwB;QAExB;;;;WAIG;QACK,iBAAiB,CAAC,UAAiD;YACzE,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,UAAU,KAAK,UAAU,EAAE;gBAC3F,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aACrD;YAED,IAAI,IAAI,CAAC,iBAAiB,EAAE;gBAC1B,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;gBACrC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;aAC/B;YAED,0DAA0D;YAC1D,IAAI,CAAC,UAAU,EAAE;gBACf,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;aACxC;YAED,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;YAC9B,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI,CAAC,qBAAqB,EAAE,CAAC;aAC9B;QACH,CAAC;QAED,sEAAsE;QAC9D,qBAAqB;YAC3B,IAAI,UAA0D,CAAC;YAE/D,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;gBAClC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;aAC7C;iBAAM,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;gBACzC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;aAC/B;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;gBAC1C,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC7C;YAED,IAAI,UAAU,EAAE;gBACd,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;qBACjE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;aACpD;iBAAM;gBACL,MAAM,6BAA6B,EAAE,CAAC;aACvC;QACH,CAAC;QAED,4FAA4F;QAC5F,iBAAiB,CAAC,IAA4B,EAAE,aAAgC,IAAI,CAAC,WAAW,EAC9E,gBAAkC,IAAI,CAAC,WAAW,CAAC,aAAa,EAChE,UAAc;YAC9B,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,OAAO,EAAE;gBAAE,OAAO;aAAE;YAEzB,OAAO,CAAC,gBAAgB,CAAC,CAAC,IAA6B,EAC7B,qBAAoC,EACpC,YAA2B,EAAE,EAAE;gBACrD,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,EAAE;oBAC9B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAa,CAAC,EAAE,YAAa,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;iBAChF;qBAAM,IAAI,YAAY,IAAI,IAAI,EAAE;oBAC/B,aAAa,CAAC,MAAM,CAAC,qBAAsB,CAAC,CAAC;oBAC7C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAChC;qBAAM;oBACL,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,qBAAsB,CAAC,CAAC;oBACvD,aAAa,CAAC,IAAI,CAAC,IAAK,EAAE,YAAY,CAAC,CAAC;iBACzC;YACH,CAAC,CAAC,CAAC;YAEL,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;QAC1C,CAAC;QAED;;;;;WAKG;QACH,WAAW,CAAC,IAAO,EAAE,CAAS;YAC5B,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;gBAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;aAAE;YAEjE,MAAM,OAAO,GACX,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC;YACpF,IAAI,CAAC,OAAO,EAAE;gBAAE,MAAM,kCAAkC,EAAE,CAAC;aAAE;YAE7D,OAAO,OAAO,CAAC;QACjB,CAAC;QAED;;;WAGG;QACH,UAAU,CAAC,QAAW,EAAE,KAAa,EAAE,aAAgC,EAAE,UAAc;YACrF,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAE/C,8DAA8D;YAC9D,MAAM,OAAO,GAAG,IAAI,wBAAwB,CAAI,QAAQ,CAAC,CAAC;YAE1D,kFAAkF;YAClF,2CAA2C;YAC3C,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;gBAC7B,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;aACrD;iBAAM,IAAI,OAAO,UAAU,KAAK,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBAC5E,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,GAAG,CAAC,CAAC;aACnD;iBAAM;gBACL,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;aACnB;YACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;YAE1C,2DAA2D;YAC3D,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;YACjF,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YAE5D,8CAA8C;YAC9C,uFAAuF;YACvF,yFAAyF;YACzF,IAAI,WAAW,CAAC,kBAAkB,EAAE;gBAClC,WAAW,CAAC,kBAAkB,CAAC,IAAI,GAAG,QAAQ,CAAC;aAChD;QACH,CAAC;;;gBA5OF,SAAS,SAAC;oBACT,QAAQ,EAAE,UAAU;oBACpB,QAAQ,EAAE,SAAS;oBACnB,QAAQ,EAAE,iDAAiD;oBAC3D,IAAI,EAAE;wBACJ,OAAO,EAAE,UAAU;wBACnB,MAAM,EAAE,MAAM;qBACf;oBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBAErC,gGAAgG;oBAChG,6FAA6F;oBAC7F,kFAAkF;oBAClF,+CAA+C;oBAC/C,eAAe,EAAE,uBAAuB,CAAC,OAAO;iBACjD;;;gBAhDC,eAAe;gBARf,iBAAiB;;;6BA8EhB,KAAK;8BAUL,KAAK;0BAQL,KAAK;8BAGL,SAAS,SAAC,iBAAiB,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;4BAG3C,eAAe,SAAC,cAAc,EAAE;wBAC/B,uEAAuE;wBACvE,8CAA8C;wBAC9C,WAAW,EAAE,IAAI;qBAClB;;IA4KH,cAAC;KAAA;SA7NY,OAAO;AAgOpB;;GAEG;AACH;IAAA,MAUa,WAAW;QAsCtB,YAAsB,WAAoC,EACpC,KAAiB;YADjB,gBAAW,GAAX,WAAW,CAAyB;YACpC,UAAK,GAAL,KAAK,CAAY;YAhCvC,gEAAgE;YACtD,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;YAE3C,8CAA8C;YAC9C,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;YAqBnC;;;eAGG;YACM,SAAI,GAAyB,UAAU,CAAC;YAI/C,WAAW,CAAC,kBAAkB,GAAG,IAAsB,CAAC;QAC1D,CAAC;QA5BD,4BAA4B;QAC5B,IAAI,IAAI,KAAQ,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACpC,IAAI,IAAI,CAAC,KAAQ;YACf,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE;gBACxB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;gBACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACxB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;aAC1B;QACH,CAAC;QAGD,IAAI,UAAU;YACZ,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,KAAK;YACP,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3F,CAAC;QAaD,WAAW;YACT,iDAAiD;YACjD,mDAAmD;YACnD,IAAI,WAAW,CAAC,kBAAkB,KAAK,IAAI,EAAE;gBAC3C,WAAW,CAAC,kBAAkB,GAAG,IAAI,CAAC;aACvC;YAED,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC7B,CAAC;QAED,6DAA6D;QAC7D,KAAK;YACH,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QACzC,CAAC;QAES,gBAAgB;YACxB,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,EAAE;gBACvC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;aACpF;iBAAM;gBACL,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,EAAE;oBACvC,MAAM,mCAAmC,EAAE,CAAC;iBAC7C;gBACD,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrE,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;oBAChC,IAAI,CAAC,oBAAoB,CAAC,aAAoB,CAAC,CAAC;iBACjD;qBAAM,IAAI,YAAY,CAAC,aAAa,CAAC,EAAE;oBACtC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;yBACzC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC;iBACjE;aACF;QACH,CAAC;QAES,oBAAoB,CAAC,QAAa;YAC1C,IAAI,CAAC,IAAI,GAAG,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;QACjE,CAAC;;IA9ED;;;OAGG;IACI,8BAAkB,GAA4B,IAAI,CAAC;;gBAf3D,SAAS,SAAC;oBACT,QAAQ,EAAE,eAAe;oBACzB,QAAQ,EAAE,aAAa;oBACvB,IAAI,EAAE;wBACJ,sBAAsB,EAAE,YAAY;wBACpC,mBAAmB,EAAE,oCAAoC;wBACzD,aAAa,EAAE,MAAM;wBACrB,OAAO,EAAE,eAAe;qBACzB;iBACF;;;gBAjSC,UAAU;gBAyUmB,OAAO;;;uBAHnC,KAAK;;IA4CR,kBAAC;KAAA;SAhFY,WAAW","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  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n  TrackByFunction\n} from '@angular/core';\nimport {\n  BehaviorSubject,\n  Observable,\n  of as observableOf,\n  Subject,\n  Subscription,\n  isObservable,\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';\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> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {\n  /** Subject that emits when the component has been destroyed. */\n  private _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>;\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  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) {\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) {\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<T[] | ReadonlyArray<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 {\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: T[] | ReadonlyArray<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    if (!nodeDef) { throw getTreeMissingMatchingNodeDefError(); }\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  host: {\n    '[attr.aria-expanded]': 'isExpanded',\n    '[attr.aria-level]': 'role === \"treeitem\" ? level : null',\n    '[attr.role]': 'role',\n    'class': 'cdk-tree-node',\n  },\n})\nexport class CdkTreeNode<T> implements FocusableOption, OnDestroy {\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 _destroyed = new Subject<void>();\n\n  /** Emits when the node's data has changed. */\n  _dataChanges = new Subject<void>();\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  get level(): number {\n    return this._tree.treeControl.getLevel ? this._tree.treeControl.getLevel(this._data) : 0;\n  }\n\n  /**\n   * The role of the node should be 'group' if it's an internal node,\n   * and 'treeitem' if it's a leaf node.\n   */\n  @Input() role: 'treeitem' | 'group' = 'treeitem';\n\n  constructor(protected _elementRef: ElementRef<HTMLElement>,\n              protected _tree: CdkTree<T>) {\n    CdkTreeNode.mostRecentTreeNode = this as CdkTreeNode<T>;\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  protected _setRoleFromData(): void {\n    if (this._tree.treeControl.isExpandable) {\n      this.role = this._tree.treeControl.isExpandable(this._data) ? 'group' : 'treeitem';\n    } else {\n      if (!this._tree.treeControl.getChildren) {\n        throw getTreeControlFunctionsMissingError();\n      }\n      const childrenNodes = this._tree.treeControl.getChildren(this._data);\n      if (Array.isArray(childrenNodes)) {\n        this._setRoleFromChildren(childrenNodes as T[]);\n      } else if (isObservable(childrenNodes)) {\n        childrenNodes.pipe(takeUntil(this._destroyed))\n            .subscribe(children => this._setRoleFromChildren(children));\n      }\n    }\n  }\n\n  protected _setRoleFromChildren(children: T[]) {\n    this.role = children && children.length ? 'group' : 'treeitem';\n  }\n}\n"]}
+    _setRoleFromChildren(children) {
+        this.role = children && children.length ? 'group' : 'treeitem';
+    }
+}
+/**
+ * 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.decorators = [
+    { type: Directive, args: [{
+                selector: 'cdk-tree-node',
+                exportAs: 'cdkTreeNode',
+                host: {
+                    '[attr.aria-expanded]': 'isExpanded',
+                    '[attr.aria-level]': 'role === "treeitem" ? level : null',
+                    '[attr.role]': 'role',
+                    'class': 'cdk-tree-node',
+                },
+            },] }
+];
+CdkTreeNode.ctorParameters = () => [
+    { type: ElementRef },
+    { type: CdkTree }
+];
+CdkTreeNode.propDecorators = {
+    role: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../../src/cdk/tree/tree.ts"],"names":[],"mappings":"AAQA,OAAO,EAA+B,YAAY,EAAC,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAEL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,SAAS,EACT,UAAU,EACV,KAAK,EAGL,eAAe,EAGf,SAAS,EACT,SAAS,EAET,iBAAiB,EAElB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EAEf,EAAE,IAAI,YAAY,EAClB,OAAO,EAEP,YAAY,GACb,MAAM,MAAM,CAAC;AACd,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAEzC,OAAO,EAAC,cAAc,EAAE,wBAAwB,EAAC,MAAM,QAAQ,CAAC;AAChE,OAAO,EAAC,iBAAiB,EAAC,MAAM,UAAU,CAAC;AAC3C,OAAO,EACL,mCAAmC,EACnC,0BAA0B,EAC1B,kCAAkC,EAClC,mCAAmC,EACnC,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AAEvB;;;GAGG;AAiBH,MAAM,OAAO,OAAO;IA4DlB,YAAoB,QAAyB,EACzB,kBAAqC;QADrC,aAAQ,GAAR,QAAQ,CAAiB;QACzB,uBAAkB,GAAlB,kBAAkB,CAAmB;QA5DzD,gEAAgE;QACxD,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;QAWzC,qBAAqB;QACb,YAAO,GAAmB,IAAI,GAAG,EAAa,CAAC;QAqCvD,6FAA6F;QAC7F,yCAAyC;QACzC;;;WAGG;QACH,eAAU,GACR,IAAI,eAAe,CAA+B,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,SAAS,EAAC,CAAC,CAAC;IAG3B,CAAC;IA7C7D;;;;OAIG;IACH,IACI,UAAU,KAA4C,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IACpF,IAAI,UAAU,CAAC,UAAiD;QAC9D,IAAI,IAAI,CAAC,WAAW,KAAK,UAAU,EAAE;YACnC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;SACpC;IACH,CAAC;IAoCD,QAAQ;QACN,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,MAAM,0BAA0B,EAAE,CAAC;SACpC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAEvC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAE3B,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,UAAU,KAAK,UAAU,EAAE;YAC3F,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SACrD;QAED,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;YACrC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;SAC/B;IACH,CAAC;IAED,qBAAqB;QACnB,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChE,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE;YAC9B,MAAM,mCAAmC,EAAE,CAAC;SAC7C;QACD,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;QAE1C,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YAChE,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;IACH,CAAC;IAGD,4FAA4F;IAC5F,wBAAwB;IAExB;;;;OAIG;IACK,iBAAiB,CAAC,UAAiD;QACzE,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,UAAU,KAAK,UAAU,EAAE;YAC3F,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SACrD;QAED,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;YACrC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;SAC/B;QAED,0DAA0D;QAC1D,IAAI,CAAC,UAAU,EAAE;YACf,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SACxC;QAED,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;IACH,CAAC;IAED,sEAAsE;IAC9D,qBAAqB;QAC3B,IAAI,UAA0D,CAAC;QAE/D,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAClC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SAC7C;aAAM,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YACzC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;SAC/B;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC1C,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SAC7C;QAED,IAAI,UAAU,EAAE;YACd,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;iBACjE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;SACpD;aAAM;YACL,MAAM,6BAA6B,EAAE,CAAC;SACvC;IACH,CAAC;IAED,4FAA4F;IAC5F,iBAAiB,CAAC,IAA4B,EAAE,aAAgC,IAAI,CAAC,WAAW,EAC9E,gBAAkC,IAAI,CAAC,WAAW,CAAC,aAAa,EAChE,UAAc;QAC9B,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,EAAE;YAAE,OAAO;SAAE;QAEzB,OAAO,CAAC,gBAAgB,CAAC,CAAC,IAA6B,EAC7B,qBAAoC,EACpC,YAA2B,EAAE,EAAE;YACrD,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,EAAE;gBAC9B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAa,CAAC,EAAE,YAAa,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;aAChF;iBAAM,IAAI,YAAY,IAAI,IAAI,EAAE;gBAC/B,aAAa,CAAC,MAAM,CAAC,qBAAsB,CAAC,CAAC;gBAC7C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAChC;iBAAM;gBACL,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,qBAAsB,CAAC,CAAC;gBACvD,aAAa,CAAC,IAAI,CAAC,IAAK,EAAE,YAAY,CAAC,CAAC;aACzC;QACH,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,IAAO,EAAE,CAAS;QAC5B,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;SAAE;QAEjE,MAAM,OAAO,GACX,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC;QACpF,IAAI,CAAC,OAAO,EAAE;YAAE,MAAM,kCAAkC,EAAE,CAAC;SAAE;QAE7D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,QAAW,EAAE,KAAa,EAAE,aAAgC,EAAE,UAAc;QACrF,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAE/C,8DAA8D;QAC9D,MAAM,OAAO,GAAG,IAAI,wBAAwB,CAAI,QAAQ,CAAC,CAAC;QAE1D,kFAAkF;QAClF,2CAA2C;QAC3C,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;YAC7B,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;SACrD;aAAM,IAAI,OAAO,UAAU,KAAK,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;YAC5E,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,GAAG,CAAC,CAAC;SACnD;aAAM;YACL,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;SACnB;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAE1C,2DAA2D;QAC3D,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;QACjF,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QAE5D,8CAA8C;QAC9C,uFAAuF;QACvF,yFAAyF;QACzF,IAAI,WAAW,CAAC,kBAAkB,EAAE;YAClC,WAAW,CAAC,kBAAkB,CAAC,IAAI,GAAG,QAAQ,CAAC;SAChD;IACH,CAAC;;;YA5OF,SAAS,SAAC;gBACT,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,iDAAiD;gBAC3D,IAAI,EAAE;oBACJ,OAAO,EAAE,UAAU;oBACnB,MAAM,EAAE,MAAM;iBACf;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBAErC,gGAAgG;gBAChG,6FAA6F;gBAC7F,kFAAkF;gBAClF,+CAA+C;gBAC/C,eAAe,EAAE,uBAAuB,CAAC,OAAO;aACjD;;;YAhDC,eAAe;YARf,iBAAiB;;;yBA8EhB,KAAK;0BAUL,KAAK;sBAQL,KAAK;0BAGL,SAAS,SAAC,iBAAiB,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;wBAG3C,eAAe,SAAC,cAAc,EAAE;oBAC/B,uEAAuE;oBACvE,8CAA8C;oBAC9C,WAAW,EAAE,IAAI;iBAClB;;AA+KH;;GAEG;AAWH,MAAM,OAAO,WAAW;IAsCtB,YAAsB,WAAoC,EACpC,KAAiB;QADjB,gBAAW,GAAX,WAAW,CAAyB;QACpC,UAAK,GAAL,KAAK,CAAY;QAhCvC,gEAAgE;QACtD,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;QAE3C,8CAA8C;QAC9C,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QAqBnC;;;WAGG;QACM,SAAI,GAAyB,UAAU,CAAC;QAI/C,WAAW,CAAC,kBAAkB,GAAG,IAAsB,CAAC;IAC1D,CAAC;IA5BD,4BAA4B;IAC5B,IAAI,IAAI,KAAQ,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACpC,IAAI,IAAI,CAAC,KAAQ;QACf,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE;YACxB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;IACH,CAAC;IAGD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC;IAaD,WAAW;QACT,iDAAiD;QACjD,mDAAmD;QACnD,IAAI,WAAW,CAAC,kBAAkB,KAAK,IAAI,EAAE;YAC3C,WAAW,CAAC,kBAAkB,GAAG,IAAI,CAAC;SACvC;QAED,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,6DAA6D;IAC7D,KAAK;QACH,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IACzC,CAAC;IAES,gBAAgB;QACxB,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,EAAE;YACvC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;SACpF;aAAM;YACL,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,EAAE;gBACvC,MAAM,mCAAmC,EAAE,CAAC;aAC7C;YACD,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrE,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;gBAChC,IAAI,CAAC,oBAAoB,CAAC,aAAoB,CAAC,CAAC;aACjD;iBAAM,IAAI,YAAY,CAAC,aAAa,CAAC,EAAE;gBACtC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;qBACzC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC;aACjE;SACF;IACH,CAAC;IAES,oBAAoB,CAAC,QAAa;QAC1C,IAAI,CAAC,IAAI,GAAG,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;IACjE,CAAC;;AA9ED;;;GAGG;AACI,8BAAkB,GAA4B,IAAI,CAAC;;YAf3D,SAAS,SAAC;gBACT,QAAQ,EAAE,eAAe;gBACzB,QAAQ,EAAE,aAAa;gBACvB,IAAI,EAAE;oBACJ,sBAAsB,EAAE,YAAY;oBACpC,mBAAmB,EAAE,oCAAoC;oBACzD,aAAa,EAAE,MAAM;oBACrB,OAAO,EAAE,eAAe;iBACzB;aACF;;;YAjSC,UAAU;YAyUmB,OAAO;;;mBAHnC,KAAK","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  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n  TrackByFunction\n} from '@angular/core';\nimport {\n  BehaviorSubject,\n  Observable,\n  of as observableOf,\n  Subject,\n  Subscription,\n  isObservable,\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';\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> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {\n  /** Subject that emits when the component has been destroyed. */\n  private _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>;\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  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) {\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) {\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<T[] | ReadonlyArray<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 {\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: T[] | ReadonlyArray<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    if (!nodeDef) { throw getTreeMissingMatchingNodeDefError(); }\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  host: {\n    '[attr.aria-expanded]': 'isExpanded',\n    '[attr.aria-level]': 'role === \"treeitem\" ? level : null',\n    '[attr.role]': 'role',\n    'class': 'cdk-tree-node',\n  },\n})\nexport class CdkTreeNode<T> implements FocusableOption, OnDestroy {\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 _destroyed = new Subject<void>();\n\n  /** Emits when the node's data has changed. */\n  _dataChanges = new Subject<void>();\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  get level(): number {\n    return this._tree.treeControl.getLevel ? this._tree.treeControl.getLevel(this._data) : 0;\n  }\n\n  /**\n   * The role of the node should be 'group' if it's an internal node,\n   * and 'treeitem' if it's a leaf node.\n   */\n  @Input() role: 'treeitem' | 'group' = 'treeitem';\n\n  constructor(protected _elementRef: ElementRef<HTMLElement>,\n              protected _tree: CdkTree<T>) {\n    CdkTreeNode.mostRecentTreeNode = this as CdkTreeNode<T>;\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  protected _setRoleFromData(): void {\n    if (this._tree.treeControl.isExpandable) {\n      this.role = this._tree.treeControl.isExpandable(this._data) ? 'group' : 'treeitem';\n    } else {\n      if (!this._tree.treeControl.getChildren) {\n        throw getTreeControlFunctionsMissingError();\n      }\n      const childrenNodes = this._tree.treeControl.getChildren(this._data);\n      if (Array.isArray(childrenNodes)) {\n        this._setRoleFromChildren(childrenNodes as T[]);\n      } else if (isObservable(childrenNodes)) {\n        childrenNodes.pipe(takeUntil(this._destroyed))\n            .subscribe(children => this._setRoleFromChildren(children));\n      }\n    }\n  }\n\n  protected _setRoleFromChildren(children: T[]) {\n    this.role = children && children.length ? 'group' : 'treeitem';\n  }\n}\n"]}