@angular/material 13.0.0-next.7 → 13.0.0-next.8

package/esm2020/tree/node.mjs

@@ -0,0 +1,143 @@
+/**
+ * @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 { CDK_TREE_NODE_OUTLET_NODE, CdkNestedTreeNode, CdkTree, CdkTreeNode, CdkTreeNodeDef, } from '@angular/cdk/tree';
+import { Attribute, Directive, ElementRef, Input, IterableDiffers, } from '@angular/core';
+import { mixinDisabled, mixinTabIndex, } from '@angular/material/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/tree";
+const _MatTreeNodeBase = mixinTabIndex(mixinDisabled(CdkTreeNode));
+/**
+ * Wrapper for the CdkTree node with Material design styles.
+ */
+export class MatTreeNode extends _MatTreeNodeBase {
+    constructor(elementRef, tree, tabIndex) {
+        super(elementRef, tree);
+        this.tabIndex = Number(tabIndex) || 0;
+        // 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('mat-tree-node');
+    }
+    // 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() {
+        super.ngOnDestroy();
+    }
+}
+MatTreeNode.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNode, deps: [{ token: i0.ElementRef }, { token: i1.CdkTree }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Directive });
+MatTreeNode.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatTreeNode, selector: "mat-tree-node", inputs: { role: "role", disabled: "disabled", tabIndex: "tabIndex" }, providers: [{ provide: CdkTreeNode, useExisting: MatTreeNode }], exportAs: ["matTreeNode"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNode, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mat-tree-node',
+                    exportAs: 'matTreeNode',
+                    inputs: ['role', 'disabled', 'tabIndex'],
+                    providers: [{ provide: CdkTreeNode, useExisting: MatTreeNode }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.CdkTree }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }]; } });
+/**
+ * Wrapper for the CdkTree node definition with Material design styles.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+export class MatTreeNodeDef extends CdkTreeNodeDef {
+}
+MatTreeNodeDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeDef, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+MatTreeNodeDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatTreeNodeDef, selector: "[matTreeNodeDef]", inputs: { when: ["matTreeNodeDefWhen", "when"], data: ["matTreeNode", "data"] }, providers: [{ provide: CdkTreeNodeDef, useExisting: MatTreeNodeDef }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matTreeNodeDef]',
+                    inputs: [
+                        'when: matTreeNodeDefWhen'
+                    ],
+                    providers: [{ provide: CdkTreeNodeDef, useExisting: MatTreeNodeDef }]
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: ['matTreeNode']
+            }] } });
+/**
+ * Wrapper for the CdkTree nested node with Material design styles.
+ */
+export class MatNestedTreeNode extends CdkNestedTreeNode {
+    constructor(elementRef, tree, differs, tabIndex) {
+        super(elementRef, tree, differs);
+        this._disabled = false;
+        this.tabIndex = Number(tabIndex) || 0;
+        // 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('mat-nested-tree-node');
+    }
+    /** Whether the node is disabled. */
+    get disabled() { return this._disabled; }
+    set disabled(value) { this._disabled = coerceBooleanProperty(value); }
+    /** Tabindex for the node. */
+    get tabIndex() { return this.disabled ? -1 : this._tabIndex; }
+    set tabIndex(value) {
+        // If the specified tabIndex value is null or undefined, fall back to the default value.
+        this._tabIndex = value != null ? value : 0;
+    }
+    // This is a workaround for https://github.com/angular/angular/issues/19145
+    // In aot mode, the lifecycle hooks from parent class are not called.
+    // TODO(tinayuangao): Remove when the angular issue #19145 is fixed
+    ngOnInit() {
+        super.ngOnInit();
+    }
+    ngDoCheck() {
+        super.ngDoCheck();
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+}
+MatNestedTreeNode.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatNestedTreeNode, deps: [{ token: i0.ElementRef }, { token: i1.CdkTree }, { token: i0.IterableDiffers }, { token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Directive });
+MatNestedTreeNode.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatNestedTreeNode, selector: "mat-nested-tree-node", inputs: { role: "role", disabled: "disabled", tabIndex: "tabIndex", node: ["matNestedTreeNode", "node"] }, providers: [
+        { provide: CdkNestedTreeNode, useExisting: MatNestedTreeNode },
+        { provide: CdkTreeNode, useExisting: MatNestedTreeNode },
+        { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: MatNestedTreeNode }
+    ], exportAs: ["matNestedTreeNode"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatNestedTreeNode, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mat-nested-tree-node',
+                    exportAs: 'matNestedTreeNode',
+                    inputs: ['role', 'disabled', 'tabIndex'],
+                    providers: [
+                        { provide: CdkNestedTreeNode, useExisting: MatNestedTreeNode },
+                        { provide: CdkTreeNode, useExisting: MatNestedTreeNode },
+                        { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: MatNestedTreeNode }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.CdkTree }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }]; }, propDecorators: { node: [{
+                type: Input,
+                args: ['matNestedTreeNode']
+            }], disabled: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../../../src/material/tree/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 */\n\nimport {\n  CDK_TREE_NODE_OUTLET_NODE,\n  CdkNestedTreeNode,\n  CdkTree,\n  CdkTreeNode,\n  CdkTreeNodeDef,\n} from '@angular/cdk/tree';\nimport {\n  AfterContentInit,\n  Attribute,\n  Directive,\n  DoCheck,\n  ElementRef,\n  Input,\n  IterableDiffers,\n  OnDestroy, OnInit,\n} from '@angular/core';\nimport {\n  CanDisable,\n  HasTabIndex,\n  mixinDisabled,\n  mixinTabIndex,\n} from '@angular/material/core';\nimport {BooleanInput, coerceBooleanProperty, NumberInput} from '@angular/cdk/coercion';\n\nconst _MatTreeNodeBase = mixinTabIndex(mixinDisabled(CdkTreeNode));\n\n/**\n * Wrapper for the CdkTree node with Material design styles.\n */\n@Directive({\n  selector: 'mat-tree-node',\n  exportAs: 'matTreeNode',\n  inputs: ['role', 'disabled', 'tabIndex'],\n  providers: [{provide: CdkTreeNode, useExisting: MatTreeNode}]\n})\nexport class MatTreeNode<T, K = T> extends _MatTreeNodeBase<T, K>\n    implements CanDisable, DoCheck, HasTabIndex, OnInit, OnDestroy {\n\n\n  constructor(elementRef: ElementRef<HTMLElement>,\n              tree: CdkTree<T, K>,\n              @Attribute('tabindex') tabIndex: string) {\n    super(elementRef, tree);\n\n    this.tabIndex = Number(tabIndex) || 0;\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('mat-tree-node');\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    super.ngOnDestroy();\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_tabIndex: NumberInput;\n}\n\n/**\n * Wrapper for the CdkTree node definition with Material design styles.\n * Captures the node's template and a when predicate that describes when this node should be used.\n */\n@Directive({\n  selector: '[matTreeNodeDef]',\n  inputs: [\n    'when: matTreeNodeDefWhen'\n  ],\n  providers: [{provide: CdkTreeNodeDef, useExisting: MatTreeNodeDef}]\n})\nexport class MatTreeNodeDef<T> extends CdkTreeNodeDef<T> {\n  @Input('matTreeNode') data: T;\n}\n\n/**\n * Wrapper for the CdkTree nested node with Material design styles.\n */\n@Directive({\n  selector: 'mat-nested-tree-node',\n  exportAs: 'matNestedTreeNode',\n  inputs: ['role', 'disabled', 'tabIndex'],\n  providers: [\n    {provide: CdkNestedTreeNode, useExisting: MatNestedTreeNode},\n    {provide: CdkTreeNode, useExisting: MatNestedTreeNode},\n    {provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: MatNestedTreeNode}\n  ]\n})\nexport class MatNestedTreeNode<T, K = T> extends CdkNestedTreeNode<T, K>\n    implements AfterContentInit, DoCheck, OnDestroy, OnInit {\n  @Input('matNestedTreeNode') node: T;\n\n  /** Whether the node is disabled. */\n  @Input()\n  get disabled() { return this._disabled; }\n  set disabled(value: any) { this._disabled = coerceBooleanProperty(value); }\n  private _disabled = false;\n\n  /** Tabindex for the node. */\n  @Input()\n  get tabIndex(): number { return this.disabled ? -1 : this._tabIndex; }\n  set tabIndex(value: number) {\n    // If the specified tabIndex value is null or undefined, fall back to the default value.\n    this._tabIndex = value != null ? value : 0;\n  }\n  private _tabIndex: number;\n\n  constructor(elementRef: ElementRef<HTMLElement>,\n              tree: CdkTree<T, K>,\n              differs: IterableDiffers,\n              @Attribute('tabindex') tabIndex: string) {\n    super(elementRef, tree, differs);\n    this.tabIndex = Number(tabIndex) || 0;\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('mat-nested-tree-node');\n  }\n\n  // This is a workaround for https://github.com/angular/angular/issues/19145\n  // In aot mode, the lifecycle hooks from parent class are not called.\n  // TODO(tinayuangao): Remove when the angular issue #19145 is fixed\n  override ngOnInit() {\n    super.ngOnInit();\n  }\n\n  override ngDoCheck() {\n    super.ngDoCheck();\n  }\n\n  override ngAfterContentInit() {\n    super.ngAfterContentInit();\n  }\n\n  override ngOnDestroy() {\n    super.ngOnDestroy();\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}

package/esm2020/tree/outlet.mjs

@@ -0,0 +1,41 @@
+/**
+ * @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 { CDK_TREE_NODE_OUTLET_NODE, CdkTreeNodeOutlet } from '@angular/cdk/tree';
+import { Directive, Inject, Optional, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Outlet for nested CdkNode. Put `[matTreeNodeOutlet]` on a tag to place children dataNodes
+ * inside the outlet.
+ */
+export class MatTreeNodeOutlet {
+    constructor(viewContainer, _node) {
+        this.viewContainer = viewContainer;
+        this._node = _node;
+    }
+}
+MatTreeNodeOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeOutlet, deps: [{ token: i0.ViewContainerRef }, { token: CDK_TREE_NODE_OUTLET_NODE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+MatTreeNodeOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatTreeNodeOutlet, selector: "[matTreeNodeOutlet]", providers: [{
+            provide: CdkTreeNodeOutlet,
+            useExisting: MatTreeNodeOutlet
+        }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeOutlet, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matTreeNodeOutlet]',
+                    providers: [{
+                            provide: CdkTreeNodeOutlet,
+                            useExisting: MatTreeNodeOutlet
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CDK_TREE_NODE_OUTLET_NODE]
+                }, {
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/padding.mjs

@@ -0,0 +1,37 @@
+/**
+ * @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 { CdkTreeNodePadding } from '@angular/cdk/tree';
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Wrapper for the CdkTree padding with Material design styles.
+ */
+export class MatTreeNodePadding extends CdkTreeNodePadding {
+    /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
+    get level() { return this._level; }
+    set level(value) { this._setLevelInput(value); }
+    /** The indent for each level. Default number 40px from material design menu sub-menu spec. */
+    get indent() { return this._indent; }
+    set indent(indent) { this._setIndentInput(indent); }
+}
+MatTreeNodePadding.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodePadding, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+MatTreeNodePadding.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatTreeNodePadding, selector: "[matTreeNodePadding]", inputs: { level: ["matTreeNodePadding", "level"], indent: ["matTreeNodePaddingIndent", "indent"] }, providers: [{ provide: CdkTreeNodePadding, useExisting: MatTreeNodePadding }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodePadding, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matTreeNodePadding]',
+                    providers: [{ provide: CdkTreeNodePadding, useExisting: MatTreeNodePadding }]
+                }]
+        }], propDecorators: { level: [{
+                type: Input,
+                args: ['matTreeNodePadding']
+            }], indent: [{
+                type: Input,
+                args: ['matTreeNodePaddingIndent']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/testing/node-harness.mjs

@@ -0,0 +1,69 @@
+/**
+ * @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 { ContentContainerComponentHarness, HarnessPredicate, } from '@angular/cdk/testing';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+/** Harness for interacting with a standard Angular Material tree node. */
+export class MatTreeNodeHarness extends ContentContainerComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._toggle = this.locatorForOptional('[matTreeNodeToggle]');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree node with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getNodePredicate(MatTreeNodeHarness, options);
+    }
+    /** Whether the tree node is expanded. */
+    async isExpanded() {
+        return coerceBooleanProperty(await (await this.host()).getAttribute('aria-expanded'));
+    }
+    /** Whether the tree node is disabled. */
+    async isDisabled() {
+        return coerceBooleanProperty(await (await this.host()).getProperty('aria-disabled'));
+    }
+    /** Gets the level of the tree node. Note that this gets the aria-level and is 1 indexed. */
+    async getLevel() {
+        return coerceNumberProperty(await (await this.host()).getAttribute('aria-level'));
+    }
+    /** Gets the tree node's text. */
+    async getText() {
+        return (await this.host()).text({ exclude: '.mat-tree-node, .mat-nested-tree-node, button' });
+    }
+    /** Toggles node between expanded/collapsed. Only works when node is not disabled. */
+    async toggle() {
+        const toggle = await this._toggle();
+        if (toggle) {
+            return toggle.click();
+        }
+    }
+    /** Expands the node if it is collapsed. Only works when node is not disabled. */
+    async expand() {
+        if (!(await this.isExpanded())) {
+            await this.toggle();
+        }
+    }
+    /** Collapses the node if it is expanded. Only works when node is not disabled. */
+    async collapse() {
+        if (await this.isExpanded()) {
+            await this.toggle();
+        }
+    }
+}
+/** The selector of the host element of a `MatTreeNode` instance. */
+MatTreeNodeHarness.hostSelector = '.mat-tree-node, .mat-nested-tree-node';
+function getNodePredicate(type, options) {
+    return new HarnessPredicate(type, options)
+        .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))
+        .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled)
+        .addOption('expanded', options.expanded, async (harness, expanded) => (await harness.isExpanded()) === expanded)
+        .addOption('level', options.level, async (harness, level) => (await harness.getLevel()) === level);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/testing/tree-harness.mjs

@@ -0,0 +1,123 @@
+/**
+ * @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 { ComponentHarness, HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { MatTreeNodeHarness } from './node-harness';
+/** Harness for interacting with a standard mat-tree in tests. */
+export class MatTreeHarness extends ComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatTreeHarness, options);
+    }
+    /** Gets all of the nodes in the tree. */
+    async getNodes(filter = {}) {
+        return this.locatorForAll(MatTreeNodeHarness.with(filter))();
+    }
+    /**
+     * Gets an object representation for the visible tree structure
+     * If a node is under an unexpanded node it will not be included.
+     * Eg.
+     * Tree (all nodes expanded):
+     * `
+     * <mat-tree>
+     *   <mat-tree-node>Node 1<mat-tree-node>
+     *   <mat-nested-tree-node>
+     *     Node 2
+     *     <mat-nested-tree-node>
+     *       Node 2.1
+     *       <mat-tree-node>
+     *         Node 2.1.1
+     *       <mat-tree-node>
+     *     <mat-nested-tree-node>
+     *     <mat-tree-node>
+     *       Node 2.2
+     *     <mat-tree-node>
+     *   <mat-nested-tree-node>
+     * </mat-tree>`
+     *
+     * Tree structure:
+     * {
+     *  children: [
+     *    {
+     *      text: 'Node 1',
+     *      children: [
+     *        {
+     *          text: 'Node 2',
+     *          children: [
+     *            {
+     *              text: 'Node 2.1',
+     *              children: [{text: 'Node 2.1.1'}]
+     *            },
+     *            {text: 'Node 2.2'}
+     *          ]
+     *        }
+     *      ]
+     *    }
+     *  ]
+     * };
+     */
+    async getTreeStructure() {
+        const nodes = await this.getNodes();
+        const nodeInformation = await parallel(() => nodes.map(node => {
+            return parallel(() => [node.getLevel(), node.getText(), node.isExpanded()]);
+        }));
+        return this._getTreeStructure(nodeInformation, 1, true);
+    }
+    /**
+     * Recursively collect the structured text of the tree nodes.
+     * @param nodes A list of tree nodes
+     * @param level The level of nodes that are being accounted for during this iteration
+     * @param parentExpanded Whether the parent of the first node in param nodes is expanded
+     */
+    _getTreeStructure(nodes, level, parentExpanded) {
+        const result = {};
+        for (let i = 0; i < nodes.length; i++) {
+            const [nodeLevel, text, expanded] = nodes[i];
+            const nextNodeLevel = nodes[i + 1]?.[0] ?? -1;
+            // Return the accumulated value for the current level once we reach a shallower level node
+            if (nodeLevel < level) {
+                return result;
+            }
+            // Skip deeper level nodes during this iteration, they will be picked up in a later iteration
+            if (nodeLevel > level) {
+                continue;
+            }
+            // Only add to representation if it is visible (parent is expanded)
+            if (parentExpanded) {
+                // Collect the data under this node according to the following rules:
+                // 1. If the next node in the list is a sibling of the current node add it to the child list
+                // 2. If the next node is a child of the current node, get the sub-tree structure for the
+                //    child and add it under this node
+                // 3. If the next node has a shallower level, we've reached the end of the child nodes for
+                //    the current parent.
+                if (nextNodeLevel === level) {
+                    this._addChildToNode(result, { text });
+                }
+                else if (nextNodeLevel > level) {
+                    let children = this._getTreeStructure(nodes.slice(i + 1), nextNodeLevel, expanded)?.children;
+                    let child = children ? { text, children } : { text };
+                    this._addChildToNode(result, child);
+                }
+                else {
+                    this._addChildToNode(result, { text });
+                    return result;
+                }
+            }
+        }
+        return result;
+    }
+    _addChildToNode(result, child) {
+        result.children ? result.children.push(child) : result.children = [child];
+    }
+}
+/** The selector for the host element of a `MatTableHarness` instance. */
+MatTreeHarness.hostSelector = '.mat-tree';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/tree/testing/tree-harness.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 */\n\nimport {ComponentHarness, HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {MatTreeNodeHarness} from './node-harness';\nimport {TreeHarnessFilters, TreeNodeHarnessFilters} from './tree-harness-filters';\n\nexport type TextTree = {\n  text?: string;\n  children?: TextTree[];\n};\n\n/** Harness for interacting with a standard mat-tree in tests. */\nexport class MatTreeHarness extends ComponentHarness {\n  /** The selector for the host element of a `MatTableHarness` instance. */\n  static hostSelector = '.mat-tree';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a tree with specific attributes.\n   * @param options Options for narrowing the search\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: TreeHarnessFilters = {}): HarnessPredicate<MatTreeHarness> {\n    return new HarnessPredicate(MatTreeHarness, options);\n  }\n\n  /** Gets all of the nodes in the tree. */\n  async getNodes(filter: TreeNodeHarnessFilters = {}): Promise<MatTreeNodeHarness[]> {\n    return this.locatorForAll(MatTreeNodeHarness.with(filter))();\n  }\n\n  /**\n   * Gets an object representation for the visible tree structure\n   * If a node is under an unexpanded node it will not be included.\n   * Eg.\n   * Tree (all nodes expanded):\n   * `\n   * <mat-tree>\n   *   <mat-tree-node>Node 1<mat-tree-node>\n   *   <mat-nested-tree-node>\n   *     Node 2\n   *     <mat-nested-tree-node>\n   *       Node 2.1\n   *       <mat-tree-node>\n   *         Node 2.1.1\n   *       <mat-tree-node>\n   *     <mat-nested-tree-node>\n   *     <mat-tree-node>\n   *       Node 2.2\n   *     <mat-tree-node>\n   *   <mat-nested-tree-node>\n   * </mat-tree>`\n   *\n   * Tree structure:\n   * {\n   *  children: [\n   *    {\n   *      text: 'Node 1',\n   *      children: [\n   *        {\n   *          text: 'Node 2',\n   *          children: [\n   *            {\n   *              text: 'Node 2.1',\n   *              children: [{text: 'Node 2.1.1'}]\n   *            },\n   *            {text: 'Node 2.2'}\n   *          ]\n   *        }\n   *      ]\n   *    }\n   *  ]\n   * };\n   */\n  async getTreeStructure(): Promise<TextTree> {\n    const nodes = await this.getNodes();\n    const nodeInformation = await parallel(() => nodes.map(node => {\n      return parallel(() => [node.getLevel(), node.getText(), node.isExpanded()]);\n    }));\n    return this._getTreeStructure(nodeInformation, 1, true);\n  }\n\n  /**\n   * Recursively collect the structured text of the tree nodes.\n   * @param nodes A list of tree nodes\n   * @param level The level of nodes that are being accounted for during this iteration\n   * @param parentExpanded Whether the parent of the first node in param nodes is expanded\n   */\n  private _getTreeStructure(nodes: [number, string, boolean][], level: number,\n                                     parentExpanded: boolean): TextTree {\n    const result: TextTree = {};\n    for (let i = 0; i < nodes.length; i++) {\n      const [nodeLevel, text, expanded] = nodes[i];\n      const nextNodeLevel = nodes[i + 1]?.[0] ?? -1;\n\n      // Return the accumulated value for the current level once we reach a shallower level node\n      if (nodeLevel < level) {\n        return result;\n      }\n      // Skip deeper level nodes during this iteration, they will be picked up in a later iteration\n      if (nodeLevel > level) {\n        continue;\n      }\n      // Only add to representation if it is visible (parent is expanded)\n      if (parentExpanded) {\n        // Collect the data under this node according to the following rules:\n        // 1. If the next node in the list is a sibling of the current node add it to the child list\n        // 2. If the next node is a child of the current node, get the sub-tree structure for the\n        //    child and add it under this node\n        // 3. If the next node has a shallower level, we've reached the end of the child nodes for\n        //    the current parent.\n        if (nextNodeLevel === level) {\n          this._addChildToNode(result, {text});\n        } else if (nextNodeLevel > level) {\n          let children = this._getTreeStructure(nodes.slice(i + 1),\n            nextNodeLevel,\n            expanded)?.children;\n          let child = children ? {text, children} : {text};\n          this._addChildToNode(result, child);\n        } else {\n          this._addChildToNode(result, {text});\n          return result;\n        }\n      }\n    }\n    return result;\n  }\n\n  private _addChildToNode(result: TextTree, child: TextTree) {\n    result.children ? result.children.push(child) : result.children = [child];\n  }\n}\n"]}

package/esm2020/tree/toggle.mjs

@@ -0,0 +1,36 @@
+/**
+ * @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 { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { CdkTreeNodeToggle } from '@angular/cdk/tree';
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Wrapper for the CdkTree's toggle with Material design styles.
+ */
+// tslint:disable-next-line: coercion-types
+export class MatTreeNodeToggle extends CdkTreeNodeToggle {
+    get recursive() { return this._recursive; }
+    set recursive(value) {
+        // TODO: when we remove support for ViewEngine, change this setter to an input
+        // alias in the decorator metadata.
+        this._recursive = coerceBooleanProperty(value);
+    }
+}
+MatTreeNodeToggle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeToggle, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+MatTreeNodeToggle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatTreeNodeToggle, selector: "[matTreeNodeToggle]", inputs: { recursive: ["matTreeNodeToggleRecursive", "recursive"] }, providers: [{ provide: CdkTreeNodeToggle, useExisting: MatTreeNodeToggle }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeNodeToggle, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matTreeNodeToggle]',
+                    providers: [{ provide: CdkTreeNodeToggle, useExisting: MatTreeNodeToggle }]
+                }]
+        }], propDecorators: { recursive: [{
+                type: Input,
+                args: ['matTreeNodeToggleRecursive']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/tree-module.mjs

@@ -0,0 +1,51 @@
+/**
+ * @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 { NgModule } from '@angular/core';
+import { CdkTreeModule } from '@angular/cdk/tree';
+import { MatCommonModule } from '@angular/material/core';
+import { MatNestedTreeNode, MatTreeNodeDef, MatTreeNode } from './node';
+import { MatTree } from './tree';
+import { MatTreeNodeToggle } from './toggle';
+import { MatTreeNodeOutlet } from './outlet';
+import { MatTreeNodePadding } from './padding';
+import * as i0 from "@angular/core";
+const MAT_TREE_DIRECTIVES = [
+    MatNestedTreeNode,
+    MatTreeNodeDef,
+    MatTreeNodePadding,
+    MatTreeNodeToggle,
+    MatTree,
+    MatTreeNode,
+    MatTreeNodeOutlet
+];
+export class MatTreeModule {
+}
+MatTreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MatTreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeModule, declarations: [MatNestedTreeNode,
+        MatTreeNodeDef,
+        MatTreeNodePadding,
+        MatTreeNodeToggle,
+        MatTree,
+        MatTreeNode,
+        MatTreeNodeOutlet], imports: [CdkTreeModule, MatCommonModule], exports: [MatCommonModule, MatNestedTreeNode,
+        MatTreeNodeDef,
+        MatTreeNodePadding,
+        MatTreeNodeToggle,
+        MatTree,
+        MatTreeNode,
+        MatTreeNodeOutlet] });
+MatTreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeModule, imports: [[CdkTreeModule, MatCommonModule], MatCommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatTreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CdkTreeModule, MatCommonModule],
+                    exports: [MatCommonModule, MAT_TREE_DIRECTIVES],
+                    declarations: MAT_TREE_DIRECTIVES,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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