/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { ContentChildren, Directive, ElementRef, IterableDiffers, QueryList, } from '@angular/core';
import { isObservable } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
import { CDK_TREE_NODE_OUTLET_NODE, CdkTreeNodeOutlet } from './outlet';
import { CdkTree, CdkTreeNode } from './tree';
import { getTreeControlFunctionsMissingError } from './tree-errors';
/**
 * Nested node is a child of `<cdk-tree>`. It works with nested tree.
 * By using `cdk-nested-tree-node` component in tree node template, children of the parent node will
 * be added in the `cdkTreeNodeOutlet` in tree node template.
 * The children of node will be automatically added to `cdkTreeNodeOutlet`.
 */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from './tree';
export class CdkNestedTreeNode extends CdkTreeNode {
    constructor(elementRef, tree, _differs) {
        super(elementRef, tree);
        this._differs = _differs;
        // 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
        elementRef.nativeElement.classList.add('cdk-nested-tree-node');
    }
    ngAfterContentInit() {
        this._dataDiffer = this._differs.find([]).create(this._tree.trackBy);
        if (!this._tree.treeControl.getChildren && (typeof ngDevMode === 'undefined' || ngDevMode)) {
            throw getTreeControlFunctionsMissingError();
        }
        const childrenNodes = this._tree.treeControl.getChildren(this.data);
        if (Array.isArray(childrenNodes)) {
            this.updateChildrenNodes(childrenNodes);
        }
        else if (isObservable(childrenNodes)) {
            childrenNodes.pipe(takeUntil(this._destroyed))
                .subscribe(result => this.updateChildrenNodes(result));
        }
        this.nodeOutlet.changes.pipe(takeUntil(this._destroyed))
            .subscribe(() => this.updateChildrenNodes());
    }
    // This is a workaround for https://github.com/angular/angular/issues/23091
    // In aot mode, the lifecycle hooks from parent class are not called.
    ngOnInit() {
        super.ngOnInit();
    }
    ngDoCheck() {
        super.ngDoCheck();
    }
    ngOnDestroy() {
        this._clear();
        super.ngOnDestroy();
    }
    /** Add children dataNodes to the NodeOutlet */
    updateChildrenNodes(children) {
        const outlet = this._getNodeOutlet();
        if (children) {
            this._children = children;
        }
        if (outlet && this._children) {
            const viewContainer = outlet.viewContainer;
            this._tree.renderNodeChanges(this._children, this._dataDiffer, viewContainer, this._data);
        }
        else {
            // Reset the data differ if there's no children nodes displayed
            this._dataDiffer.diff([]);
        }
    }
    /** Clear the children dataNodes. */
    _clear() {
        const outlet = this._getNodeOutlet();
        if (outlet) {
            outlet.viewContainer.clear();
            this._dataDiffer.diff([]);
        }
    }
    /** Gets the outlet for the current node. */
    _getNodeOutlet() {
        const outlets = this.nodeOutlet;
        // Note that since we use `descendants: true` on the query, we have to ensure
        // that we don't pick up the outlet of a child node by accident.
        return outlets && outlets.find(outlet => !outlet._node || outlet._node === this);
    }
}
CdkNestedTreeNode.ɵfac = function CdkNestedTreeNode_Factory(t) { return new (t || CdkNestedTreeNode)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.CdkTree), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.IterableDiffers)); };
CdkNestedTreeNode.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkNestedTreeNode, selectors: [["cdk-nested-tree-node"]], contentQueries: function CdkNestedTreeNode_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
        ɵngcc0.ɵɵcontentQuery(dirIndex, CdkTreeNodeOutlet, 5);
    } if (rf & 2) {
        let _t;
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.nodeOutlet = _t);
    } }, inputs: { role: "role", disabled: "disabled", tabIndex: "tabIndex" }, exportAs: ["cdkNestedTreeNode"], features: [ɵngcc0.ɵɵProvidersFeature([
            { provide: CdkTreeNode, useExisting: CdkNestedTreeNode },
            { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: CdkNestedTreeNode }
        ]), ɵngcc0.ɵɵInheritDefinitionFeature] });
CdkNestedTreeNode.ctorParameters = () => [
    { type: ElementRef },
    { type: CdkTree },
    { type: IterableDiffers }
];
CdkNestedTreeNode.propDecorators = {
    nodeOutlet: [{ type: ContentChildren, args: [CdkTreeNodeOutlet, {
                    // 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(CdkNestedTreeNode, [{
        type: Directive,
        args: [{
                selector: 'cdk-nested-tree-node',
                exportAs: 'cdkNestedTreeNode',
                inputs: ['role', 'disabled', 'tabIndex'],
                providers: [
                    { provide: CdkTreeNode, useExisting: CdkNestedTreeNode },
                    { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: CdkNestedTreeNode }
                ]
            }]
    }], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc1.CdkTree }, { type: ɵngcc0.IterableDiffers }]; }, { nodeOutlet: [{
            type: ContentChildren,
            args: [CdkTreeNodeOutlet, {
                    // We need to use `descendants: true`, because Ivy will no longer match
                    // indirect descendants if it's left as false.
                    descendants: true
                }]
        }] }); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"nested-node.js","sources":["../../../../../../src/cdk/tree/nested-node.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {\n  AfterContentInit,\n  ContentChildren,\n  Directive,\n  DoCheck,\n  ElementRef,\n  IterableDiffer,\n  IterableDiffers,\n  OnDestroy,\n  OnInit,\n  QueryList,\n} from '@angular/core';\nimport {isObservable} from 'rxjs';\nimport {takeUntil} from 'rxjs/operators';\n\nimport {CDK_TREE_NODE_OUTLET_NODE, CdkTreeNodeOutlet} from './outlet';\nimport {CdkTree, CdkTreeNode} from './tree';\nimport {getTreeControlFunctionsMissingError} from './tree-errors';\n\n/**\n * Nested node is a child of `<cdk-tree>`. It works with nested tree.\n * By using `cdk-nested-tree-node` component in tree node template, children of the parent node will\n * be added in the `cdkTreeNodeOutlet` in tree node template.\n * The children of node will be automatically added to `cdkTreeNodeOutlet`.\n */\n@Directive({\n  selector: 'cdk-nested-tree-node',\n  exportAs: 'cdkNestedTreeNode',\n  inputs: ['role', 'disabled', 'tabIndex'],\n  providers: [\n    {provide: CdkTreeNode, useExisting: CdkNestedTreeNode},\n    {provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: CdkNestedTreeNode}\n  ]\n})\nexport class CdkNestedTreeNode<T, K = T> extends CdkTreeNode<T, K>\n    implements AfterContentInit, DoCheck, OnDestroy, OnInit {\n  /** Differ used to find the changes in the data provided by the data source. */\n  private _dataDiffer: IterableDiffer<T>;\n\n  /** The children data dataNodes of current node. They will be placed in `CdkTreeNodeOutlet`. */\n  protected _children: T[];\n\n  /** The children node placeholder. */\n  @ContentChildren(CdkTreeNodeOutlet, {\n    // We need to use `descendants: true`, because Ivy will no longer match\n    // indirect descendants if it's left as false.\n    descendants: true\n  })\n  nodeOutlet: QueryList<CdkTreeNodeOutlet>;\n\n  constructor(elementRef: ElementRef<HTMLElement>,\n              tree: CdkTree<T, K>,\n              protected _differs: IterableDiffers) {\n    super(elementRef, tree);\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    elementRef.nativeElement.classList.add('cdk-nested-tree-node');\n  }\n\n  ngAfterContentInit() {\n    this._dataDiffer = this._differs.find([]).create(this._tree.trackBy);\n    if (!this._tree.treeControl.getChildren && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTreeControlFunctionsMissingError();\n    }\n    const childrenNodes = this._tree.treeControl.getChildren(this.data);\n    if (Array.isArray(childrenNodes)) {\n      this.updateChildrenNodes(childrenNodes as T[]);\n    } else if (isObservable(childrenNodes)) {\n      childrenNodes.pipe(takeUntil(this._destroyed))\n        .subscribe(result => this.updateChildrenNodes(result));\n    }\n    this.nodeOutlet.changes.pipe(takeUntil(this._destroyed))\n        .subscribe(() => this.updateChildrenNodes());\n  }\n\n  // This is a workaround for https://github.com/angular/angular/issues/23091\n  // In aot mode, the lifecycle hooks from parent class are not called.\n  override ngOnInit() {\n    super.ngOnInit();\n  }\n\n  override ngDoCheck() {\n    super.ngDoCheck();\n  }\n\n  override ngOnDestroy() {\n    this._clear();\n    super.ngOnDestroy();\n  }\n\n  /** Add children dataNodes to the NodeOutlet */\n  protected updateChildrenNodes(children?: T[]): void {\n    const outlet = this._getNodeOutlet();\n    if (children) {\n      this._children = children;\n    }\n    if (outlet && this._children) {\n      const viewContainer = outlet.viewContainer;\n      this._tree.renderNodeChanges(this._children, this._dataDiffer, viewContainer, this._data);\n    } else {\n      // Reset the data differ if there's no children nodes displayed\n      this._dataDiffer.diff([]);\n    }\n  }\n\n  /** Clear the children dataNodes. */\n  protected _clear(): void {\n    const outlet = this._getNodeOutlet();\n    if (outlet) {\n      outlet.viewContainer.clear();\n      this._dataDiffer.diff([]);\n    }\n  }\n\n  /** Gets the outlet for the current node. */\n  private _getNodeOutlet() {\n    const outlets = this.nodeOutlet;\n\n    // Note that since we use `descendants: true` on the query, we have to ensure\n    // that we don't pick up the outlet of a child node by accident.\n    return outlets && outlets.find(outlet => !outlet._node || outlet._node === this);\n  }\n}\n"]}