@angular/cdk 13.0.0-next.6 → 13.0.0-rc.1

package/esm2020/table/text-column.mjs

@@ -0,0 +1,153 @@
+/**
+ * @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 { ChangeDetectionStrategy, Component, Inject, Input, Optional, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { CdkCellDef, CdkColumnDef, CdkHeaderCellDef } from './cell';
+import { CdkTable } from './table';
+import { getTableTextColumnMissingParentTableError, getTableTextColumnMissingNameError, } from './table-errors';
+import { TEXT_COLUMN_OPTIONS } from './tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "./table";
+import * as i2 from "./cell";
+/**
+ * Column that simply shows text content for the header and row cells. Assumes that the table
+ * is using the native table implementation (`<table>`).
+ *
+ * By default, the name of this column will be the header text and data property accessor.
+ * The header text can be overridden with the `headerText` input. Cell values can be overridden with
+ * the `dataAccessor` input. Change the text justification to the start or end using the `justify`
+ * input.
+ */
+export class CdkTextColumn {
+    constructor(
+    // `CdkTextColumn` is always requiring a table, but we just assert it manually
+    // for better error reporting.
+    // tslint:disable-next-line: lightweight-tokens
+    _table, _options) {
+        this._table = _table;
+        this._options = _options;
+        /** Alignment of the cell values. */
+        this.justify = 'start';
+        this._options = _options || {};
+    }
+    /** Column name that should be used to reference this column. */
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        this._name = name;
+        // With Ivy, inputs can be initialized before static query results are
+        // available. In that case, we defer the synchronization until "ngOnInit" fires.
+        this._syncColumnDefName();
+    }
+    ngOnInit() {
+        this._syncColumnDefName();
+        if (this.headerText === undefined) {
+            this.headerText = this._createDefaultHeaderText();
+        }
+        if (!this.dataAccessor) {
+            this.dataAccessor =
+                this._options.defaultDataAccessor || ((data, name) => data[name]);
+        }
+        if (this._table) {
+            // Provide the cell and headerCell directly to the table with the static `ViewChild` query,
+            // since the columnDef will not pick up its content by the time the table finishes checking
+            // its content and initializing the rows.
+            this.columnDef.cell = this.cell;
+            this.columnDef.headerCell = this.headerCell;
+            this._table.addColumnDef(this.columnDef);
+        }
+        else if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            throw getTableTextColumnMissingParentTableError();
+        }
+    }
+    ngOnDestroy() {
+        if (this._table) {
+            this._table.removeColumnDef(this.columnDef);
+        }
+    }
+    /**
+     * Creates a default header text. Use the options' header text transformation function if one
+     * has been provided. Otherwise simply capitalize the column name.
+     */
+    _createDefaultHeaderText() {
+        const name = this.name;
+        if (!name && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw getTableTextColumnMissingNameError();
+        }
+        if (this._options && this._options.defaultHeaderTextTransform) {
+            return this._options.defaultHeaderTextTransform(name);
+        }
+        return name[0].toUpperCase() + name.slice(1);
+    }
+    /** Synchronizes the column definition name with the text column name. */
+    _syncColumnDefName() {
+        if (this.columnDef) {
+            this.columnDef.name = this.name;
+        }
+    }
+}
+CdkTextColumn.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkTextColumn, deps: [{ token: i1.CdkTable, optional: true }, { token: TEXT_COLUMN_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+CdkTextColumn.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkTextColumn, selector: "cdk-text-column", inputs: { name: "name", headerText: "headerText", dataAccessor: "dataAccessor", justify: "justify" }, viewQueries: [{ propertyName: "columnDef", first: true, predicate: CdkColumnDef, descendants: true, static: true }, { propertyName: "cell", first: true, predicate: CdkCellDef, descendants: true, static: true }, { propertyName: "headerCell", first: true, predicate: CdkHeaderCellDef, descendants: true, static: true }], ngImport: i0, template: `
+    <ng-container cdkColumnDef>
+      <th cdk-header-cell *cdkHeaderCellDef [style.text-align]="justify">
+        {{headerText}}
+      </th>
+      <td cdk-cell *cdkCellDef="let data" [style.text-align]="justify">
+        {{dataAccessor(data, name)}}
+      </td>
+    </ng-container>
+  `, isInline: true, directives: [{ type: i2.CdkColumnDef, selector: "[cdkColumnDef]", inputs: ["sticky", "cdkColumnDef", "stickyEnd"] }, { type: i2.CdkHeaderCellDef, selector: "[cdkHeaderCellDef]" }, { type: i2.CdkHeaderCell, selector: "cdk-header-cell, th[cdk-header-cell]" }, { type: i2.CdkCellDef, selector: "[cdkCellDef]" }, { type: i2.CdkCell, selector: "cdk-cell, td[cdk-cell]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkTextColumn, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cdk-text-column',
+                    template: `
+    <ng-container cdkColumnDef>
+      <th cdk-header-cell *cdkHeaderCellDef [style.text-align]="justify">
+        {{headerText}}
+      </th>
+      <td cdk-cell *cdkCellDef="let data" [style.text-align]="justify">
+        {{dataAccessor(data, name)}}
+      </td>
+    </ng-container>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    // Change detection is intentionally not set to OnPush. This component's template will be provided
+                    // to the table to be inserted into its view. This is problematic when change detection runs since
+                    // the bindings in this template will be evaluated _after_ the table's view is evaluated, which
+                    // mean's the template in the table's view will not have the updated value (and in fact will cause
+                    // an ExpressionChangedAfterItHasBeenCheckedError).
+                    // tslint:disable-next-line:validate-decorators
+                    changeDetection: ChangeDetectionStrategy.Default,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkTable, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TEXT_COLUMN_OPTIONS]
+                }] }]; }, propDecorators: { name: [{
+                type: Input
+            }], headerText: [{
+                type: Input
+            }], dataAccessor: [{
+                type: Input
+            }], justify: [{
+                type: Input
+            }], columnDef: [{
+                type: ViewChild,
+                args: [CdkColumnDef, { static: true }]
+            }], cell: [{
+                type: ViewChild,
+                args: [CdkCellDef, { static: true }]
+            }], headerCell: [{
+                type: ViewChild,
+                args: [CdkHeaderCellDef, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-column.js","sourceRoot":"","sources":["../../../../../../src/cdk/table/text-column.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  ChangeDetectionStrategy,\n  Component,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {CdkCellDef, CdkColumnDef, CdkHeaderCellDef} from './cell';\nimport {CdkTable} from './table';\nimport {\n  getTableTextColumnMissingParentTableError,\n  getTableTextColumnMissingNameError,\n} from './table-errors';\nimport {TEXT_COLUMN_OPTIONS, TextColumnOptions} from './tokens';\n\n/**\n * Column that simply shows text content for the header and row cells. Assumes that the table\n * is using the native table implementation (`<table>`).\n *\n * By default, the name of this column will be the header text and data property accessor.\n * The header text can be overridden with the `headerText` input. Cell values can be overridden with\n * the `dataAccessor` input. Change the text justification to the start or end using the `justify`\n * input.\n */\n@Component({\n  selector: 'cdk-text-column',\n  template: `\n    <ng-container cdkColumnDef>\n      <th cdk-header-cell *cdkHeaderCellDef [style.text-align]=\"justify\">\n        {{headerText}}\n      </th>\n      <td cdk-cell *cdkCellDef=\"let data\" [style.text-align]=\"justify\">\n        {{dataAccessor(data, name)}}\n      </td>\n    </ng-container>\n  `,\n  encapsulation: ViewEncapsulation.None,\n  // Change detection is intentionally not set to OnPush. This component's template will be provided\n  // to the table to be inserted into its view. This is problematic when change detection runs since\n  // the bindings in this template will be evaluated _after_ the table's view is evaluated, which\n  // mean's the template in the table's view will not have the updated value (and in fact will cause\n  // an ExpressionChangedAfterItHasBeenCheckedError).\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n})\nexport class CdkTextColumn<T> implements OnDestroy, OnInit {\n  /** Column name that should be used to reference this column. */\n  @Input()\n  get name(): string {\n    return this._name;\n  }\n  set name(name: string) {\n    this._name = name;\n\n    // With Ivy, inputs can be initialized before static query results are\n    // available. In that case, we defer the synchronization until \"ngOnInit\" fires.\n    this._syncColumnDefName();\n  }\n  _name: string;\n\n  /**\n   * Text label that should be used for the column header. If this property is not\n   * set, the header text will default to the column name with its first letter capitalized.\n   */\n  @Input() headerText: string;\n\n  /**\n   * Accessor function to retrieve the data rendered for each cell. If this\n   * property is not set, the data cells will render the value found in the data's property matching\n   * the column's name. For example, if the column is named `id`, then the rendered value will be\n   * value defined by the data's `id` property.\n   */\n  @Input() dataAccessor: (data: T, name: string) => string;\n\n  /** Alignment of the cell values. */\n  @Input() justify: 'start' | 'end' = 'start';\n\n  /** @docs-private */\n  @ViewChild(CdkColumnDef, {static: true}) columnDef: CdkColumnDef;\n\n  /**\n   * The column cell is provided to the column during `ngOnInit` with a static query.\n   * Normally, this will be retrieved by the column using `ContentChild`, but that assumes the\n   * column definition was provided in the same view as the table, which is not the case with this\n   * component.\n   * @docs-private\n   */\n  @ViewChild(CdkCellDef, {static: true}) cell: CdkCellDef;\n\n  /**\n   * The column headerCell is provided to the column during `ngOnInit` with a static query.\n   * Normally, this will be retrieved by the column using `ContentChild`, but that assumes the\n   * column definition was provided in the same view as the table, which is not the case with this\n   * component.\n   * @docs-private\n   */\n  @ViewChild(CdkHeaderCellDef, {static: true}) headerCell: CdkHeaderCellDef;\n\n  constructor(\n    // `CdkTextColumn` is always requiring a table, but we just assert it manually\n    // for better error reporting.\n    // tslint:disable-next-line: lightweight-tokens\n    @Optional() private _table: CdkTable<T>,\n    @Optional() @Inject(TEXT_COLUMN_OPTIONS) private _options: TextColumnOptions<T>,\n  ) {\n    this._options = _options || {};\n  }\n\n  ngOnInit() {\n    this._syncColumnDefName();\n\n    if (this.headerText === undefined) {\n      this.headerText = this._createDefaultHeaderText();\n    }\n\n    if (!this.dataAccessor) {\n      this.dataAccessor =\n        this._options.defaultDataAccessor || ((data: T, name: string) => (data as any)[name]);\n    }\n\n    if (this._table) {\n      // Provide the cell and headerCell directly to the table with the static `ViewChild` query,\n      // since the columnDef will not pick up its content by the time the table finishes checking\n      // its content and initializing the rows.\n      this.columnDef.cell = this.cell;\n      this.columnDef.headerCell = this.headerCell;\n      this._table.addColumnDef(this.columnDef);\n    } else if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      throw getTableTextColumnMissingParentTableError();\n    }\n  }\n\n  ngOnDestroy() {\n    if (this._table) {\n      this._table.removeColumnDef(this.columnDef);\n    }\n  }\n\n  /**\n   * Creates a default header text. Use the options' header text transformation function if one\n   * has been provided. Otherwise simply capitalize the column name.\n   */\n  _createDefaultHeaderText() {\n    const name = this.name;\n\n    if (!name && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getTableTextColumnMissingNameError();\n    }\n\n    if (this._options && this._options.defaultHeaderTextTransform) {\n      return this._options.defaultHeaderTextTransform(name);\n    }\n\n    return name[0].toUpperCase() + name.slice(1);\n  }\n\n  /** Synchronizes the column definition name with the text column name. */\n  private _syncColumnDefName() {\n    if (this.columnDef) {\n      this.columnDef.name = this.name;\n    }\n  }\n}\n"]}

package/{esm2015/table/tokens.js → esm2020/table/tokens.mjs}

@@ -13,4 +13,4 @@ import { InjectionToken } from '@angular/core';
 export const CDK_TABLE = new InjectionToken('CDK_TABLE');
 /** Injection token that can be used to specify the text column options. */
 export const TEXT_COLUMN_OPTIONS = new InjectionToken('text-column-options');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay90YWJsZS90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUU3Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsSUFBSSxjQUFjLENBQU0sV0FBVyxDQUFDLENBQUM7QUFjOUQsMkVBQTJFO0FBQzNFLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUM1QixJQUFJLGNBQWMsQ0FBeUIscUJBQXFCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBVc2VkIHRvIHByb3ZpZGUgYSB0YWJsZSB0byBzb21lIG9mIHRoZSBzdWItY29tcG9uZW50cyB3aXRob3V0IGNhdXNpbmcgYSBjaXJjdWxhciBkZXBlbmRlbmN5LlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgY29uc3QgQ0RLX1RBQkxFID0gbmV3IEluamVjdGlvblRva2VuPGFueT4oJ0NES19UQUJMRScpO1xuXG4vKiogQ29uZmlndXJhYmxlIG9wdGlvbnMgZm9yIGBDZGtUZXh0Q29sdW1uYC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGV4dENvbHVtbk9wdGlvbnM8VD4ge1xuICAvKipcbiAgICogRGVmYXVsdCBmdW5jdGlvbiB0aGF0IHByb3ZpZGVzIHRoZSBoZWFkZXIgdGV4dCBiYXNlZCBvbiB0aGUgY29sdW1uIG5hbWUgaWYgYSBoZWFkZXJcbiAgICogdGV4dCBpcyBub3QgcHJvdmlkZWQuXG4gICAqL1xuICBkZWZhdWx0SGVhZGVyVGV4dFRyYW5zZm9ybT86IChuYW1lOiBzdHJpbmcpID0+IHN0cmluZztcblxuICAvKiogRGVmYXVsdCBkYXRhIGFjY2Vzc29yIHRvIHVzZSBpZiBvbmUgaXMgbm90IHByb3ZpZGVkLiAqL1xuICBkZWZhdWx0RGF0YUFjY2Vzc29yPzogKGRhdGE6IFQsIG5hbWU6IHN0cmluZykgPT4gc3RyaW5nO1xufVxuXG4vKiogSW5qZWN0aW9uIHRva2VuIHRoYXQgY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSB0aGUgdGV4dCBjb2x1bW4gb3B0aW9ucy4gKi9cbmV4cG9ydCBjb25zdCBURVhUX0NPTFVNTl9PUFRJT05TID1cbiAgICBuZXcgSW5qZWN0aW9uVG9rZW48VGV4dENvbHVtbk9wdGlvbnM8YW55Pj4oJ3RleHQtY29sdW1uLW9wdGlvbnMnKTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay90YWJsZS90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUU3Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsSUFBSSxjQUFjLENBQU0sV0FBVyxDQUFDLENBQUM7QUFjOUQsMkVBQTJFO0FBQzNFLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLElBQUksY0FBYyxDQUNuRCxxQkFBcUIsQ0FDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBVc2VkIHRvIHByb3ZpZGUgYSB0YWJsZSB0byBzb21lIG9mIHRoZSBzdWItY29tcG9uZW50cyB3aXRob3V0IGNhdXNpbmcgYSBjaXJjdWxhciBkZXBlbmRlbmN5LlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgY29uc3QgQ0RLX1RBQkxFID0gbmV3IEluamVjdGlvblRva2VuPGFueT4oJ0NES19UQUJMRScpO1xuXG4vKiogQ29uZmlndXJhYmxlIG9wdGlvbnMgZm9yIGBDZGtUZXh0Q29sdW1uYC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGV4dENvbHVtbk9wdGlvbnM8VD4ge1xuICAvKipcbiAgICogRGVmYXVsdCBmdW5jdGlvbiB0aGF0IHByb3ZpZGVzIHRoZSBoZWFkZXIgdGV4dCBiYXNlZCBvbiB0aGUgY29sdW1uIG5hbWUgaWYgYSBoZWFkZXJcbiAgICogdGV4dCBpcyBub3QgcHJvdmlkZWQuXG4gICAqL1xuICBkZWZhdWx0SGVhZGVyVGV4dFRyYW5zZm9ybT86IChuYW1lOiBzdHJpbmcpID0+IHN0cmluZztcblxuICAvKiogRGVmYXVsdCBkYXRhIGFjY2Vzc29yIHRvIHVzZSBpZiBvbmUgaXMgbm90IHByb3ZpZGVkLiAqL1xuICBkZWZhdWx0RGF0YUFjY2Vzc29yPzogKGRhdGE6IFQsIG5hbWU6IHN0cmluZykgPT4gc3RyaW5nO1xufVxuXG4vKiogSW5qZWN0aW9uIHRva2VuIHRoYXQgY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSB0aGUgdGV4dCBjb2x1bW4gb3B0aW9ucy4gKi9cbmV4cG9ydCBjb25zdCBURVhUX0NPTFVNTl9PUFRJT05TID0gbmV3IEluamVjdGlvblRva2VuPFRleHRDb2x1bW5PcHRpb25zPGFueT4+KFxuICAndGV4dC1jb2x1bW4tb3B0aW9ucycsXG4pO1xuIl19

package/esm2020/testing/change-detection.mjs

@@ -0,0 +1,102 @@
+/**
+ * @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 { BehaviorSubject } from 'rxjs';
+/** Subject used to dispatch and listen for changes to the auto change detection status . */
+const autoChangeDetectionSubject = new BehaviorSubject({
+    isDisabled: false,
+});
+/** The current subscription to `autoChangeDetectionSubject`. */
+let autoChangeDetectionSubscription;
+/**
+ * The default handler for auto change detection status changes. This handler will be used if the
+ * specific environment does not install its own.
+ * @param status The new auto change detection status.
+ */
+function defaultAutoChangeDetectionHandler(status) {
+    status.onDetectChangesNow?.();
+}
+/**
+ * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status
+ * changes.
+ * @param handler The handler for the auto change detection status.
+ */
+export function handleAutoChangeDetectionStatus(handler) {
+    stopHandlingAutoChangeDetectionStatus();
+    autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler);
+}
+/** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */
+export function stopHandlingAutoChangeDetectionStatus() {
+    autoChangeDetectionSubscription?.unsubscribe();
+    autoChangeDetectionSubscription = null;
+}
+/**
+ * Batches together triggering of change detection over the duration of the given function.
+ * @param fn The function to call with batched change detection.
+ * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch
+ *   operation. If false, change detection will not be triggered.
+ * @return The result of the given function.
+ */
+async function batchChangeDetection(fn, triggerBeforeAndAfter) {
+    // If change detection batching is already in progress, just run the function.
+    if (autoChangeDetectionSubject.getValue().isDisabled) {
+        return await fn();
+    }
+    // If nothing is handling change detection batching, install the default handler.
+    if (!autoChangeDetectionSubscription) {
+        handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);
+    }
+    if (triggerBeforeAndAfter) {
+        await new Promise(resolve => autoChangeDetectionSubject.next({
+            isDisabled: true,
+            onDetectChangesNow: resolve,
+        }));
+        // The function passed in may throw (e.g. if the user wants to make an expectation of an error
+        // being thrown. If this happens, we need to make sure we still re-enable change detection, so
+        // we wrap it in a `finally` block.
+        try {
+            return await fn();
+        }
+        finally {
+            await new Promise(resolve => autoChangeDetectionSubject.next({
+                isDisabled: false,
+                onDetectChangesNow: resolve,
+            }));
+        }
+    }
+    else {
+        autoChangeDetectionSubject.next({ isDisabled: true });
+        // The function passed in may throw (e.g. if the user wants to make an expectation of an error
+        // being thrown. If this happens, we need to make sure we still re-enable change detection, so
+        // we wrap it in a `finally` block.
+        try {
+            return await fn();
+        }
+        finally {
+            autoChangeDetectionSubject.next({ isDisabled: false });
+        }
+    }
+}
+/**
+ * Disables the harness system's auto change detection for the duration of the given function.
+ * @param fn The function to disable auto change detection for.
+ * @return The result of the given function.
+ */
+export async function manualChangeDetection(fn) {
+    return batchChangeDetection(fn, false);
+}
+/**
+ * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change
+ * detection over the entire operation such that change detection occurs exactly once before
+ * resolving the values and once after.
+ * @param values A getter for the async values to resolve in parallel with batched change detection.
+ * @return The resolved values.
+ */
+export async function parallel(values) {
+    return batchChangeDetection(() => Promise.all(values()), true);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"change-detection.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/change-detection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,eAAe,EAAe,MAAM,MAAM,CAAC;AAcnD,4FAA4F;AAC5F,MAAM,0BAA0B,GAAG,IAAI,eAAe,CAA4B;IAChF,UAAU,EAAE,KAAK;CAClB,CAAC,CAAC;AAEH,gEAAgE;AAChE,IAAI,+BAAoD,CAAC;AAEzD;;;;GAIG;AACH,SAAS,iCAAiC,CAAC,MAAiC;IAC1E,MAAM,CAAC,kBAAkB,EAAE,EAAE,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAoD;IAEpD,qCAAqC,EAAE,CAAC;IACxC,+BAA+B,GAAG,0BAA0B,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAClF,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,qCAAqC;IACnD,+BAA+B,EAAE,WAAW,EAAE,CAAC;IAC/C,+BAA+B,GAAG,IAAI,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,oBAAoB,CAAI,EAAoB,EAAE,qBAA8B;IACzF,8EAA8E;IAC9E,IAAI,0BAA0B,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE;QACpD,OAAO,MAAM,EAAE,EAAE,CAAC;KACnB;IAED,iFAAiF;IACjF,IAAI,CAAC,+BAA+B,EAAE;QACpC,+BAA+B,CAAC,iCAAiC,CAAC,CAAC;KACpE;IAED,IAAI,qBAAqB,EAAE;QACzB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAC1B,0BAA0B,CAAC,IAAI,CAAC;YAC9B,UAAU,EAAE,IAAI;YAChB,kBAAkB,EAAE,OAAqB;SAC1C,CAAC,CACH,CAAC;QACF,8FAA8F;QAC9F,8FAA8F;QAC9F,mCAAmC;QACnC,IAAI;YACF,OAAO,MAAM,EAAE,EAAE,CAAC;SACnB;gBAAS;YACR,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAC1B,0BAA0B,CAAC,IAAI,CAAC;gBAC9B,UAAU,EAAE,KAAK;gBACjB,kBAAkB,EAAE,OAAqB;aAC1C,CAAC,CACH,CAAC;SACH;KACF;SAAM;QACL,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC,CAAC;QACpD,8FAA8F;QAC9F,8FAA8F;QAC9F,mCAAmC;QACnC,IAAI;YACF,OAAO,MAAM,EAAE,EAAE,CAAC;SACnB;gBAAS;YACR,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAC;SACtD;KACF;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAI,EAAoB;IACjE,OAAO,oBAAoB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AAkED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAI,MAA0C;IAC1E,OAAO,oBAAoB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACjE,CAAC","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 {BehaviorSubject, Subscription} from 'rxjs';\n\n/** Represents the status of auto change detection. */\nexport interface AutoChangeDetectionStatus {\n  /** Whether auto change detection is disabled. */\n  isDisabled: boolean;\n  /**\n   * An optional callback, if present it indicates that change detection should be run immediately,\n   * while handling the status change. The callback should then be called as soon as change\n   * detection is done.\n   */\n  onDetectChangesNow?: () => void;\n}\n\n/** Subject used to dispatch and listen for changes to the auto change detection status . */\nconst autoChangeDetectionSubject = new BehaviorSubject<AutoChangeDetectionStatus>({\n  isDisabled: false,\n});\n\n/** The current subscription to `autoChangeDetectionSubject`. */\nlet autoChangeDetectionSubscription: Subscription | null;\n\n/**\n * The default handler for auto change detection status changes. This handler will be used if the\n * specific environment does not install its own.\n * @param status The new auto change detection status.\n */\nfunction defaultAutoChangeDetectionHandler(status: AutoChangeDetectionStatus) {\n  status.onDetectChangesNow?.();\n}\n\n/**\n * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status\n * changes.\n * @param handler The handler for the auto change detection status.\n */\nexport function handleAutoChangeDetectionStatus(\n  handler: (status: AutoChangeDetectionStatus) => void,\n) {\n  stopHandlingAutoChangeDetectionStatus();\n  autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler);\n}\n\n/** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */\nexport function stopHandlingAutoChangeDetectionStatus() {\n  autoChangeDetectionSubscription?.unsubscribe();\n  autoChangeDetectionSubscription = null;\n}\n\n/**\n * Batches together triggering of change detection over the duration of the given function.\n * @param fn The function to call with batched change detection.\n * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch\n *   operation. If false, change detection will not be triggered.\n * @return The result of the given function.\n */\nasync function batchChangeDetection<T>(fn: () => Promise<T>, triggerBeforeAndAfter: boolean) {\n  // If change detection batching is already in progress, just run the function.\n  if (autoChangeDetectionSubject.getValue().isDisabled) {\n    return await fn();\n  }\n\n  // If nothing is handling change detection batching, install the default handler.\n  if (!autoChangeDetectionSubscription) {\n    handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);\n  }\n\n  if (triggerBeforeAndAfter) {\n    await new Promise(resolve =>\n      autoChangeDetectionSubject.next({\n        isDisabled: true,\n        onDetectChangesNow: resolve as () => void,\n      }),\n    );\n    // The function passed in may throw (e.g. if the user wants to make an expectation of an error\n    // being thrown. If this happens, we need to make sure we still re-enable change detection, so\n    // we wrap it in a `finally` block.\n    try {\n      return await fn();\n    } finally {\n      await new Promise(resolve =>\n        autoChangeDetectionSubject.next({\n          isDisabled: false,\n          onDetectChangesNow: resolve as () => void,\n        }),\n      );\n    }\n  } else {\n    autoChangeDetectionSubject.next({isDisabled: true});\n    // The function passed in may throw (e.g. if the user wants to make an expectation of an error\n    // being thrown. If this happens, we need to make sure we still re-enable change detection, so\n    // we wrap it in a `finally` block.\n    try {\n      return await fn();\n    } finally {\n      autoChangeDetectionSubject.next({isDisabled: false});\n    }\n  }\n}\n\n/**\n * Disables the harness system's auto change detection for the duration of the given function.\n * @param fn The function to disable auto change detection for.\n * @return The result of the given function.\n */\nexport async function manualChangeDetection<T>(fn: () => Promise<T>) {\n  return batchChangeDetection(fn, false);\n}\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3, T4, T5>(\n  values: () => [\n    T1 | PromiseLike<T1>,\n    T2 | PromiseLike<T2>,\n    T3 | PromiseLike<T3>,\n    T4 | PromiseLike<T4>,\n    T5 | PromiseLike<T5>,\n  ],\n): Promise<[T1, T2, T3, T4, T5]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3, T4>(\n  values: () => [\n    T1 | PromiseLike<T1>,\n    T2 | PromiseLike<T2>,\n    T3 | PromiseLike<T3>,\n    T4 | PromiseLike<T4>,\n  ],\n): Promise<[T1, T2, T3, T4]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3>(\n  values: () => [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>],\n): Promise<[T1, T2, T3]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2>(\n  values: () => [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>],\n): Promise<[T1, T2]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T>(values: () => (T | PromiseLike<T>)[]): Promise<T[]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport async function parallel<T>(values: () => Iterable<T | PromiseLike<T>>): Promise<T[]> {\n  return batchChangeDetection(() => Promise.all(values()), true);\n}\n"]}