@angular/cdk-experimental 13.0.0-next.7 → 13.0.0-rc.2

package/esm2020/selection/select-all.mjs

@@ -0,0 +1,109 @@
+/**
+ * @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 { Directive, Inject, Optional, Self } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { of as observableOf, Subject } from 'rxjs';
+import { switchMap, takeUntil } from 'rxjs/operators';
+import { CdkSelection } from './selection';
+import * as i0 from "@angular/core";
+import * as i1 from "./selection";
+/**
+ * Makes the element a select-all toggle.
+ *
+ * Must be used within a parent `CdkSelection` directive. It toggles the selection states
+ * of all the selection toggles connected with the `CdkSelection` directive.
+ * If the element implements `ControlValueAccessor`, e.g. `MatCheckbox`, the directive
+ * automatically connects it with the select-all state provided by the `CdkSelection` directive. If
+ * not, use `checked$` to get the checked state, `indeterminate$` to get the indeterminate state,
+ * and `toggle()` to change the selection state.
+ */
+export class CdkSelectAll {
+    constructor(_selection, _controlValueAccessor) {
+        this._selection = _selection;
+        this._controlValueAccessor = _controlValueAccessor;
+        /**
+         * The checked state of the toggle.
+         * Resolves to `true` if all the values are selected, `false` if no value is selected.
+         */
+        this.checked = this._selection.change.pipe(switchMap(() => observableOf(this._selection.isAllSelected())));
+        /**
+         * The indeterminate state of the toggle.
+         * Resolves to `true` if part (not all) of the values are selected, `false` if all values or no
+         * value at all are selected.
+         */
+        this.indeterminate = this._selection.change.pipe(switchMap(() => observableOf(this._selection.isPartialSelected())));
+        this._destroyed = new Subject();
+    }
+    /**
+     * Toggles the select-all state.
+     * @param event The click event if the toggle is triggered by a (mouse or keyboard) click. If
+     *     using with a native `<input type="checkbox">`, the parameter is required for the
+     *     indeterminate state to work properly.
+     */
+    toggle(event) {
+        // This is needed when applying the directive on a native <input type="checkbox">
+        // checkbox. The default behavior needs to be prevented in order to support the indeterminate
+        // state. The timeout is also needed so the checkbox can show the latest state.
+        if (event) {
+            event.preventDefault();
+        }
+        setTimeout(() => {
+            this._selection.toggleSelectAll();
+        });
+    }
+    ngOnInit() {
+        this._assertValidParentSelection();
+        this._configureControlValueAccessor();
+    }
+    _configureControlValueAccessor() {
+        if (this._controlValueAccessor && this._controlValueAccessor.length) {
+            this._controlValueAccessor[0].registerOnChange((e) => {
+                if (e === true || e === false) {
+                    this.toggle();
+                }
+            });
+            this.checked.pipe(takeUntil(this._destroyed)).subscribe(state => {
+                this._controlValueAccessor[0].writeValue(state);
+            });
+        }
+    }
+    _assertValidParentSelection() {
+        if (!this._selection && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('CdkSelectAll: missing CdkSelection in the parent');
+        }
+        if (!this._selection.multiple && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('CdkSelectAll: CdkSelection must have cdkSelectionMultiple set to true');
+        }
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+}
+CdkSelectAll.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectAll, deps: [{ token: CdkSelection, optional: true }, { token: NG_VALUE_ACCESSOR, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkSelectAll.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkSelectAll, selector: "[cdkSelectAll]", exportAs: ["cdkSelectAll"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectAll, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkSelectAll]',
+                    exportAs: 'cdkSelectAll',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkSelection, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CdkSelection]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [NG_VALUE_ACCESSOR]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-all.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/selection/select-all.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 {Directive, Inject, OnDestroy, OnInit, Optional, Self} from '@angular/core';\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {Observable, of as observableOf, Subject} from 'rxjs';\nimport {switchMap, takeUntil} from 'rxjs/operators';\n\nimport {CdkSelection} from './selection';\n\n/**\n * Makes the element a select-all toggle.\n *\n * Must be used within a parent `CdkSelection` directive. It toggles the selection states\n * of all the selection toggles connected with the `CdkSelection` directive.\n * If the element implements `ControlValueAccessor`, e.g. `MatCheckbox`, the directive\n * automatically connects it with the select-all state provided by the `CdkSelection` directive. If\n * not, use `checked$` to get the checked state, `indeterminate$` to get the indeterminate state,\n * and `toggle()` to change the selection state.\n */\n@Directive({\n  selector: '[cdkSelectAll]',\n  exportAs: 'cdkSelectAll',\n})\nexport class CdkSelectAll<T> implements OnDestroy, OnInit {\n  /**\n   * The checked state of the toggle.\n   * Resolves to `true` if all the values are selected, `false` if no value is selected.\n   */\n  readonly checked: Observable<boolean> = this._selection.change.pipe(\n    switchMap(() => observableOf(this._selection.isAllSelected())),\n  );\n\n  /**\n   * The indeterminate state of the toggle.\n   * Resolves to `true` if part (not all) of the values are selected, `false` if all values or no\n   * value at all are selected.\n   */\n  readonly indeterminate: Observable<boolean> = this._selection.change.pipe(\n    switchMap(() => observableOf(this._selection.isPartialSelected())),\n  );\n\n  /**\n   * Toggles the select-all state.\n   * @param event The click event if the toggle is triggered by a (mouse or keyboard) click. If\n   *     using with a native `<input type=\"checkbox\">`, the parameter is required for the\n   *     indeterminate state to work properly.\n   */\n  toggle(event?: MouseEvent) {\n    // This is needed when applying the directive on a native <input type=\"checkbox\">\n    // checkbox. The default behavior needs to be prevented in order to support the indeterminate\n    // state. The timeout is also needed so the checkbox can show the latest state.\n    if (event) {\n      event.preventDefault();\n    }\n\n    setTimeout(() => {\n      this._selection.toggleSelectAll();\n    });\n  }\n\n  private readonly _destroyed = new Subject<void>();\n\n  constructor(\n    @Optional() @Inject(CdkSelection) private readonly _selection: CdkSelection<T>,\n    @Optional()\n    @Self()\n    @Inject(NG_VALUE_ACCESSOR)\n    private readonly _controlValueAccessor: ControlValueAccessor[],\n  ) {}\n\n  ngOnInit() {\n    this._assertValidParentSelection();\n    this._configureControlValueAccessor();\n  }\n\n  private _configureControlValueAccessor() {\n    if (this._controlValueAccessor && this._controlValueAccessor.length) {\n      this._controlValueAccessor[0].registerOnChange((e: unknown) => {\n        if (e === true || e === false) {\n          this.toggle();\n        }\n      });\n      this.checked.pipe(takeUntil(this._destroyed)).subscribe(state => {\n        this._controlValueAccessor[0].writeValue(state);\n      });\n    }\n  }\n\n  private _assertValidParentSelection() {\n    if (!this._selection && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('CdkSelectAll: missing CdkSelection in the parent');\n    }\n\n    if (!this._selection.multiple && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('CdkSelectAll: CdkSelection must have cdkSelectionMultiple set to true');\n    }\n  }\n\n  ngOnDestroy() {\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n}\n"]}

package/esm2020/selection/selection-column.mjs

@@ -0,0 +1,134 @@
+/**
+ * @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 { CdkCellDef, CdkColumnDef, CdkHeaderCellDef, CdkTable } from '@angular/cdk/table';
+import { Component, Input, Optional, ViewChild, ChangeDetectionStrategy, ViewEncapsulation, Inject, } from '@angular/core';
+import { CdkSelection } from './selection';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/table";
+import * as i2 from "@angular/common";
+import * as i3 from "./select-all";
+import * as i4 from "./selection-toggle";
+import * as i5 from "./selection";
+/**
+ * Column that adds row selecting checkboxes and a select-all checkbox if `cdkSelectionMultiple` is
+ * `true`.
+ *
+ * Must be used within a parent `CdkSelection` directive.
+ */
+export class CdkSelectionColumn {
+    constructor(_table, selection) {
+        this._table = _table;
+        this.selection = selection;
+    }
+    /** Column name that should be used to reference this column. */
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        this._name = name;
+        this._syncColumnDefName();
+    }
+    ngOnInit() {
+        if (!this.selection && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('CdkSelectionColumn: missing CdkSelection in the parent');
+        }
+        this._syncColumnDefName();
+        if (this._table) {
+            this._columnDef.cell = this._cell;
+            this._columnDef.headerCell = this._headerCell;
+            this._table.addColumnDef(this._columnDef);
+        }
+        else if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            throw Error('CdkSelectionColumn: missing parent table');
+        }
+    }
+    ngOnDestroy() {
+        if (this._table) {
+            this._table.removeColumnDef(this._columnDef);
+        }
+    }
+    _syncColumnDefName() {
+        if (this._columnDef) {
+            this._columnDef.name = this._name;
+        }
+    }
+}
+CdkSelectionColumn.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionColumn, deps: [{ token: CdkTable, optional: true }, { token: CdkSelection, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+CdkSelectionColumn.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkSelectionColumn, selector: "cdk-selection-column", inputs: { name: ["cdkSelectionColumnName", "name"] }, 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 cdkHeaderCell *cdkHeaderCellDef>
+        <input type="checkbox" *ngIf="selection.multiple"
+            cdkSelectAll
+            #allToggler="cdkSelectAll"
+            [checked]="allToggler.checked | async"
+            [indeterminate]="allToggler.indeterminate | async"
+            (click)="allToggler.toggle($event)">
+      </th>
+      <td cdkCell *cdkCellDef="let row; let i = $index">
+        <input type="checkbox"
+            #toggler="cdkSelectionToggle"
+            cdkSelectionToggle
+            [cdkSelectionToggleValue]="row"
+            [cdkSelectionToggleIndex]="i"
+            (click)="toggler.toggle()"
+            [checked]="toggler.checked | async">
+      </td>
+    </ng-container>
+  `, isInline: true, directives: [{ type: i1.CdkColumnDef, selector: "[cdkColumnDef]", inputs: ["sticky", "cdkColumnDef", "stickyEnd"] }, { type: i1.CdkHeaderCellDef, selector: "[cdkHeaderCellDef]" }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.CdkSelectAll, selector: "[cdkSelectAll]", exportAs: ["cdkSelectAll"] }, { type: i1.CdkCellDef, selector: "[cdkCellDef]" }, { type: i4.CdkSelectionToggle, selector: "[cdkSelectionToggle]", inputs: ["cdkSelectionToggleValue", "cdkSelectionToggleIndex"], exportAs: ["cdkSelectionToggle"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionColumn, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cdk-selection-column',
+                    template: `
+    <ng-container cdkColumnDef>
+      <th cdkHeaderCell *cdkHeaderCellDef>
+        <input type="checkbox" *ngIf="selection.multiple"
+            cdkSelectAll
+            #allToggler="cdkSelectAll"
+            [checked]="allToggler.checked | async"
+            [indeterminate]="allToggler.indeterminate | async"
+            (click)="allToggler.toggle($event)">
+      </th>
+      <td cdkCell *cdkCellDef="let row; let i = $index">
+        <input type="checkbox"
+            #toggler="cdkSelectionToggle"
+            cdkSelectionToggle
+            [cdkSelectionToggleValue]="row"
+            [cdkSelectionToggleIndex]="i"
+            (click)="toggler.toggle()"
+            [checked]="toggler.checked | async">
+      </td>
+    </ng-container>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkTable, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CdkTable]
+                }] }, { type: i5.CdkSelection, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CdkSelection]
+                }] }]; }, propDecorators: { name: [{
+                type: Input,
+                args: ['cdkSelectionColumnName']
+            }], _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,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

package/esm2020/selection/selection-module.mjs

@@ -0,0 +1,40 @@
+/**
+ * @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 { CdkTableModule } from '@angular/cdk/table';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { CdkRowSelection } from './row-selection';
+import { CdkSelectAll } from './select-all';
+import { CdkSelection } from './selection';
+import { CdkSelectionColumn } from './selection-column';
+import { CdkSelectionToggle } from './selection-toggle';
+import * as i0 from "@angular/core";
+export class CdkSelectionModule {
+}
+CdkSelectionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CdkSelectionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionModule, declarations: [CdkSelection,
+        CdkSelectionToggle,
+        CdkSelectAll,
+        CdkSelectionColumn,
+        CdkRowSelection], imports: [CommonModule, CdkTableModule], exports: [CdkSelection, CdkSelectionToggle, CdkSelectAll, CdkSelectionColumn, CdkRowSelection] });
+CdkSelectionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionModule, imports: [[CommonModule, CdkTableModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, CdkTableModule],
+                    exports: [CdkSelection, CdkSelectionToggle, CdkSelectAll, CdkSelectionColumn, CdkRowSelection],
+                    declarations: [
+                        CdkSelection,
+                        CdkSelectionToggle,
+                        CdkSelectAll,
+                        CdkSelectionColumn,
+                        CdkRowSelection,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/selection/selection-set.js → esm2020/selection/selection-set.mjs}

@@ -77,4 +77,4 @@ export class SelectionSet {
         return Array.from(this._selectionMap.values());
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-set.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/selection/selection-set.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 {TrackByFunction} from '@angular/core';\nimport {Subject} from 'rxjs';\n\n/**\n * Maintains a set of selected values. One or more values can be added to or removed from the\n * selection.\n */\ninterface TrackBySelection<T> {\n  isSelected(value: SelectableWithIndex<T>): boolean;\n  select(...values: SelectableWithIndex<T>[]): void;\n  deselect(...values: SelectableWithIndex<T>[]): void;\n  changed: Subject<SelectionChange<T>>;\n}\n\n/**\n * A selectable value with an optional index. The index is required when the selection is used with\n * `trackBy`.\n */\nexport interface SelectableWithIndex<T> {\n  value: T;\n  index?: number;\n}\n\n/**\n * Represents the change in the selection set.\n */\nexport interface SelectionChange<T> {\n  before: SelectableWithIndex<T>[];\n  after: SelectableWithIndex<T>[];\n}\n\n/**\n * Maintains a set of selected items. Support selecting and deselecting items, and checking if a\n * value is selected.\n * When constructed with a `trackByFn`, all the items will be identified by applying the `trackByFn`\n * on them. Because `trackByFn` requires the index of the item to be passed in, the `index` field is\n * expected to be set when calling `isSelected`, `select` and `deselect`.\n */\nexport class SelectionSet<T> implements TrackBySelection<T> {\n  private _selectionMap = new Map<T|ReturnType<TrackByFunction<T>>, SelectableWithIndex<T>>();\n  changed = new Subject<SelectionChange<T>>();\n\n  constructor(private _multiple = false, private _trackByFn?: TrackByFunction<T>) {}\n\n  isSelected(value: SelectableWithIndex<T>): boolean {\n    return this._selectionMap.has(this._getTrackedByValue(value));\n  }\n\n  select(...selects: SelectableWithIndex<T>[]) {\n    if (!this._multiple && selects.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: not multiple selection');\n    }\n\n    const before = this._getCurrentSelection();\n\n    if (!this._multiple) {\n      this._selectionMap.clear();\n    }\n\n    const toSelect: SelectableWithIndex<T>[] = [];\n    for (const select of selects) {\n      if (this.isSelected(select)) {\n        continue;\n      }\n\n      toSelect.push(select);\n      this._markSelected(this._getTrackedByValue(select), select);\n    }\n\n    const after = this._getCurrentSelection();\n\n    this.changed.next({before, after});\n  }\n\n  deselect(...selects: SelectableWithIndex<T>[]) {\n    if (!this._multiple && selects.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: not multiple selection');\n    }\n\n    const before = this._getCurrentSelection();\n    const toDeselect: SelectableWithIndex<T>[] = [];\n\n    for (const select of selects) {\n      if (!this.isSelected(select)) {\n        continue;\n      }\n\n      toDeselect.push(select);\n      this._markDeselected(this._getTrackedByValue(select));\n    }\n\n    const after = this._getCurrentSelection();\n    this.changed.next({before, after});\n  }\n\n  private _markSelected(key: T|ReturnType<TrackByFunction<T>>, toSelect: SelectableWithIndex<T>) {\n    this._selectionMap.set(key, toSelect);\n  }\n\n  private _markDeselected(key: T|ReturnType<TrackByFunction<T>>) {\n    this._selectionMap.delete(key);\n  }\n\n  private _getTrackedByValue(select: SelectableWithIndex<T>) {\n    if (!this._trackByFn) {\n      return select.value;\n    }\n\n    if (select.index == null && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: index required when trackByFn is used.');\n    }\n\n    return this._trackByFn(select.index!, select.value);\n  }\n\n  private _getCurrentSelection(): SelectableWithIndex<T>[] {\n    return Array.from(this._selectionMap.values());\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-set.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/selection/selection-set.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 {TrackByFunction} from '@angular/core';\nimport {Subject} from 'rxjs';\n\n/**\n * Maintains a set of selected values. One or more values can be added to or removed from the\n * selection.\n */\ninterface TrackBySelection<T> {\n  isSelected(value: SelectableWithIndex<T>): boolean;\n  select(...values: SelectableWithIndex<T>[]): void;\n  deselect(...values: SelectableWithIndex<T>[]): void;\n  changed: Subject<SelectionChange<T>>;\n}\n\n/**\n * A selectable value with an optional index. The index is required when the selection is used with\n * `trackBy`.\n */\nexport interface SelectableWithIndex<T> {\n  value: T;\n  index?: number;\n}\n\n/**\n * Represents the change in the selection set.\n */\nexport interface SelectionChange<T> {\n  before: SelectableWithIndex<T>[];\n  after: SelectableWithIndex<T>[];\n}\n\n/**\n * Maintains a set of selected items. Support selecting and deselecting items, and checking if a\n * value is selected.\n * When constructed with a `trackByFn`, all the items will be identified by applying the `trackByFn`\n * on them. Because `trackByFn` requires the index of the item to be passed in, the `index` field is\n * expected to be set when calling `isSelected`, `select` and `deselect`.\n */\nexport class SelectionSet<T> implements TrackBySelection<T> {\n  private _selectionMap = new Map<T | ReturnType<TrackByFunction<T>>, SelectableWithIndex<T>>();\n  changed = new Subject<SelectionChange<T>>();\n\n  constructor(private _multiple = false, private _trackByFn?: TrackByFunction<T>) {}\n\n  isSelected(value: SelectableWithIndex<T>): boolean {\n    return this._selectionMap.has(this._getTrackedByValue(value));\n  }\n\n  select(...selects: SelectableWithIndex<T>[]) {\n    if (!this._multiple && selects.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: not multiple selection');\n    }\n\n    const before = this._getCurrentSelection();\n\n    if (!this._multiple) {\n      this._selectionMap.clear();\n    }\n\n    const toSelect: SelectableWithIndex<T>[] = [];\n    for (const select of selects) {\n      if (this.isSelected(select)) {\n        continue;\n      }\n\n      toSelect.push(select);\n      this._markSelected(this._getTrackedByValue(select), select);\n    }\n\n    const after = this._getCurrentSelection();\n\n    this.changed.next({before, after});\n  }\n\n  deselect(...selects: SelectableWithIndex<T>[]) {\n    if (!this._multiple && selects.length > 1 && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: not multiple selection');\n    }\n\n    const before = this._getCurrentSelection();\n    const toDeselect: SelectableWithIndex<T>[] = [];\n\n    for (const select of selects) {\n      if (!this.isSelected(select)) {\n        continue;\n      }\n\n      toDeselect.push(select);\n      this._markDeselected(this._getTrackedByValue(select));\n    }\n\n    const after = this._getCurrentSelection();\n    this.changed.next({before, after});\n  }\n\n  private _markSelected(key: T | ReturnType<TrackByFunction<T>>, toSelect: SelectableWithIndex<T>) {\n    this._selectionMap.set(key, toSelect);\n  }\n\n  private _markDeselected(key: T | ReturnType<TrackByFunction<T>>) {\n    this._selectionMap.delete(key);\n  }\n\n  private _getTrackedByValue(select: SelectableWithIndex<T>) {\n    if (!this._trackByFn) {\n      return select.value;\n    }\n\n    if (select.index == null && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('SelectionSet: index required when trackByFn is used.');\n    }\n\n    return this._trackByFn(select.index!, select.value);\n  }\n\n  private _getCurrentSelection(): SelectableWithIndex<T>[] {\n    return Array.from(this._selectionMap.values());\n  }\n}\n"]}

package/esm2020/selection/selection-toggle.mjs

@@ -0,0 +1,101 @@
+/**
+ * @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 { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Directive, Inject, Input, Optional, Self } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { of as observableOf, Subject } from 'rxjs';
+import { distinctUntilChanged, switchMap, takeUntil } from 'rxjs/operators';
+import { CdkSelection } from './selection';
+import * as i0 from "@angular/core";
+import * as i1 from "./selection";
+/**
+ * Makes the element a selection toggle.
+ *
+ * Must be used within a parent `CdkSelection` directive.
+ * Must be provided with the value. If `trackBy` is used on `CdkSelection`, the index of the value
+ * is required. If the element implements `ControlValueAccessor`, e.g. `MatCheckbox`, the directive
+ * automatically connects it with the selection state provided by the `CdkSelection` directive. If
+ * not, use `checked$` to get the checked state of the value, and `toggle()` to change the selection
+ * state.
+ */
+export class CdkSelectionToggle {
+    constructor(_selection, _controlValueAccessors) {
+        this._selection = _selection;
+        this._controlValueAccessors = _controlValueAccessors;
+        /** The checked state of the selection toggle */
+        this.checked = this._selection.change.pipe(switchMap(() => observableOf(this._isSelected())), distinctUntilChanged());
+        this._destroyed = new Subject();
+    }
+    /** The index of the value in the list. Required when used with `trackBy` */
+    get index() {
+        return this._index;
+    }
+    set index(index) {
+        this._index = coerceNumberProperty(index);
+    }
+    /** Toggles the selection */
+    toggle() {
+        this._selection.toggleSelection(this.value, this.index);
+    }
+    ngOnInit() {
+        this._assertValidParentSelection();
+        this._configureControlValueAccessor();
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    _assertValidParentSelection() {
+        if (!this._selection && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('CdkSelectAll: missing CdkSelection in the parent');
+        }
+    }
+    _configureControlValueAccessor() {
+        if (this._controlValueAccessors && this._controlValueAccessors.length) {
+            this._controlValueAccessors[0].registerOnChange((e) => {
+                if (typeof e === 'boolean') {
+                    this.toggle();
+                }
+            });
+            this.checked.pipe(takeUntil(this._destroyed)).subscribe(state => {
+                this._controlValueAccessors[0].writeValue(state);
+            });
+        }
+    }
+    _isSelected() {
+        return this._selection.isSelected(this.value, this.index);
+    }
+}
+CdkSelectionToggle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionToggle, deps: [{ token: CdkSelection, optional: true }, { token: NG_VALUE_ACCESSOR, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkSelectionToggle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkSelectionToggle, selector: "[cdkSelectionToggle]", inputs: { value: ["cdkSelectionToggleValue", "value"], index: ["cdkSelectionToggleIndex", "index"] }, exportAs: ["cdkSelectionToggle"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkSelectionToggle, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkSelectionToggle]',
+                    exportAs: 'cdkSelectionToggle',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkSelection, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CdkSelection]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [NG_VALUE_ACCESSOR]
+                }] }]; }, propDecorators: { value: [{
+                type: Input,
+                args: ['cdkSelectionToggleValue']
+            }], index: [{
+                type: Input,
+                args: ['cdkSelectionToggleIndex']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLXRvZ2dsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGstZXhwZXJpbWVudGFsL3NlbGVjdGlvbi9zZWxlY3Rpb24tdG9nZ2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxvQkFBb0IsRUFBYyxNQUFNLHVCQUF1QixDQUFDO0FBQ3hFLE9BQU8sRUFBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBcUIsUUFBUSxFQUFFLElBQUksRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUMxRixPQUFPLEVBQXVCLGlCQUFpQixFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDdkUsT0FBTyxFQUFhLEVBQUUsSUFBSSxZQUFZLEVBQUUsT0FBTyxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBQzdELE9BQU8sRUFBQyxvQkFBb0IsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFFMUUsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGFBQWEsQ0FBQzs7O0FBRXpDOzs7Ozs7Ozs7R0FTRztBQUtILE1BQU0sT0FBTyxrQkFBa0I7SUEyQjdCLFlBQzRDLFVBQTJCLEVBSTdELHNCQUE4QztRQUpaLGVBQVUsR0FBVixVQUFVLENBQWlCO1FBSTdELDJCQUFzQixHQUF0QixzQkFBc0IsQ0FBd0I7UUFsQnhELGdEQUFnRDtRQUN2QyxZQUFPLEdBQXdCLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLElBQUksQ0FDakUsU0FBUyxDQUFDLEdBQUcsRUFBRSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQyxFQUNqRCxvQkFBb0IsRUFBRSxDQUN2QixDQUFDO1FBT00sZUFBVSxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7SUFRdEMsQ0FBQztJQTdCSiw0RUFBNEU7SUFDNUUsSUFDSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3JCLENBQUM7SUFDRCxJQUFJLEtBQUssQ0FBQyxLQUF5QjtRQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHLG9CQUFvQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFTRCw0QkFBNEI7SUFDNUIsTUFBTTtRQUNKLElBQUksQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFZRCxRQUFRO1FBQ04sSUFBSSxDQUFDLDJCQUEyQixFQUFFLENBQUM7UUFDbkMsSUFBSSxDQUFDLDhCQUE4QixFQUFFLENBQUM7SUFDeEMsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDN0IsQ0FBQztJQUVPLDJCQUEyQjtRQUNqQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxDQUFDLE9BQU8sU0FBUyxLQUFLLFdBQVcsSUFBSSxTQUFTLENBQUMsRUFBRTtZQUN2RSxNQUFNLEtBQUssQ0FBQyxrREFBa0QsQ0FBQyxDQUFDO1NBQ2pFO0lBQ0gsQ0FBQztJQUVPLDhCQUE4QjtRQUNwQyxJQUFJLElBQUksQ0FBQyxzQkFBc0IsSUFBSSxJQUFJLENBQUMsc0JBQXNCLENBQUMsTUFBTSxFQUFFO1lBQ3JFLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQVUsRUFBRSxFQUFFO2dCQUM3RCxJQUFJLE9BQU8sQ0FBQyxLQUFLLFNBQVMsRUFBRTtvQkFDMUIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO2lCQUNmO1lBQ0gsQ0FBQyxDQUFDLENBQUM7WUFFSCxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUM5RCxJQUFJLENBQUMsc0JBQXNCLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ25ELENBQUMsQ0FBQyxDQUFDO1NBQ0o7SUFDSCxDQUFDO0lBRU8sV0FBVztRQUNqQixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzVELENBQUM7O3VIQW5FVSxrQkFBa0Isa0JBNEJQLFlBQVksNkJBR3hCLGlCQUFpQjsyR0EvQmhCLGtCQUFrQjttR0FBbEIsa0JBQWtCO2tCQUo5QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxzQkFBc0I7b0JBQ2hDLFFBQVEsRUFBRSxvQkFBb0I7aUJBQy9COzswQkE2QkksUUFBUTs7MEJBQUksTUFBTTsyQkFBQyxZQUFZOzswQkFDL0IsUUFBUTs7MEJBQ1IsSUFBSTs7MEJBQ0osTUFBTTsyQkFBQyxpQkFBaUI7NENBN0JPLEtBQUs7c0JBQXRDLEtBQUs7dUJBQUMseUJBQXlCO2dCQUk1QixLQUFLO3NCQURSLEtBQUs7dUJBQUMseUJBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7Y29lcmNlTnVtYmVyUHJvcGVydHksIE51bWJlcklucHV0fSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHtEaXJlY3RpdmUsIEluamVjdCwgSW5wdXQsIE9uRGVzdHJveSwgT25Jbml0LCBPcHRpb25hbCwgU2VsZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbnRyb2xWYWx1ZUFjY2Vzc29yLCBOR19WQUxVRV9BQ0NFU1NPUn0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHtPYnNlcnZhYmxlLCBvZiBhcyBvYnNlcnZhYmxlT2YsIFN1YmplY3R9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtkaXN0aW5jdFVudGlsQ2hhbmdlZCwgc3dpdGNoTWFwLCB0YWtlVW50aWx9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcblxuaW1wb3J0IHtDZGtTZWxlY3Rpb259IGZyb20gJy4vc2VsZWN0aW9uJztcblxuLyoqXG4gKiBNYWtlcyB0aGUgZWxlbWVudCBhIHNlbGVjdGlvbiB0b2dnbGUuXG4gKlxuICogTXVzdCBiZSB1c2VkIHdpdGhpbiBhIHBhcmVudCBgQ2RrU2VsZWN0aW9uYCBkaXJlY3RpdmUuXG4gKiBNdXN0IGJlIHByb3ZpZGVkIHdpdGggdGhlIHZhbHVlLiBJZiBgdHJhY2tCeWAgaXMgdXNlZCBvbiBgQ2RrU2VsZWN0aW9uYCwgdGhlIGluZGV4IG9mIHRoZSB2YWx1ZVxuICogaXMgcmVxdWlyZWQuIElmIHRoZSBlbGVtZW50IGltcGxlbWVudHMgYENvbnRyb2xWYWx1ZUFjY2Vzc29yYCwgZS5nLiBgTWF0Q2hlY2tib3hgLCB0aGUgZGlyZWN0aXZlXG4gKiBhdXRvbWF0aWNhbGx5IGNvbm5lY3RzIGl0IHdpdGggdGhlIHNlbGVjdGlvbiBzdGF0ZSBwcm92aWRlZCBieSB0aGUgYENka1NlbGVjdGlvbmAgZGlyZWN0aXZlLiBJZlxuICogbm90LCB1c2UgYGNoZWNrZWQkYCB0byBnZXQgdGhlIGNoZWNrZWQgc3RhdGUgb2YgdGhlIHZhbHVlLCBhbmQgYHRvZ2dsZSgpYCB0byBjaGFuZ2UgdGhlIHNlbGVjdGlvblxuICogc3RhdGUuXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tjZGtTZWxlY3Rpb25Ub2dnbGVdJyxcbiAgZXhwb3J0QXM6ICdjZGtTZWxlY3Rpb25Ub2dnbGUnLFxufSlcbmV4cG9ydCBjbGFzcyBDZGtTZWxlY3Rpb25Ub2dnbGU8VD4gaW1wbGVtZW50cyBPbkRlc3Ryb3ksIE9uSW5pdCB7XG4gIC8qKiBUaGUgdmFsdWUgdGhhdCBpcyBhc3NvY2lhdGVkIHdpdGggdGhlIHRvZ2dsZSAqL1xuICBASW5wdXQoJ2Nka1NlbGVjdGlvblRvZ2dsZVZhbHVlJykgdmFsdWU6IFQ7XG5cbiAgLyoqIFRoZSBpbmRleCBvZiB0aGUgdmFsdWUgaW4gdGhlIGxpc3QuIFJlcXVpcmVkIHdoZW4gdXNlZCB3aXRoIGB0cmFja0J5YCAqL1xuICBASW5wdXQoJ2Nka1NlbGVjdGlvblRvZ2dsZUluZGV4JylcbiAgZ2V0IGluZGV4KCk6IG51bWJlciB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIHRoaXMuX2luZGV4O1xuICB9XG4gIHNldCBpbmRleChpbmRleDogbnVtYmVyIHwgdW5kZWZpbmVkKSB7XG4gICAgdGhpcy5faW5kZXggPSBjb2VyY2VOdW1iZXJQcm9wZXJ0eShpbmRleCk7XG4gIH1cbiAgcHJvdGVjdGVkIF9pbmRleD86IG51bWJlcjtcblxuICAvKiogVGhlIGNoZWNrZWQgc3RhdGUgb2YgdGhlIHNlbGVjdGlvbiB0b2dnbGUgKi9cbiAgcmVhZG9ubHkgY2hlY2tlZDogT2JzZXJ2YWJsZTxib29sZWFuPiA9IHRoaXMuX3NlbGVjdGlvbi5jaGFuZ2UucGlwZShcbiAgICBzd2l0Y2hNYXAoKCkgPT4gb2JzZXJ2YWJsZU9mKHRoaXMuX2lzU2VsZWN0ZWQoKSkpLFxuICAgIGRpc3RpbmN0VW50aWxDaGFuZ2VkKCksXG4gICk7XG5cbiAgLyoqIFRvZ2dsZXMgdGhlIHNlbGVjdGlvbiAqL1xuICB0b2dnbGUoKSB7XG4gICAgdGhpcy5fc2VsZWN0aW9uLnRvZ2dsZVNlbGVjdGlvbih0aGlzLnZhbHVlLCB0aGlzLmluZGV4KTtcbiAgfVxuXG4gIHByaXZhdGUgX2Rlc3Ryb3llZCA9IG5ldyBTdWJqZWN0PHZvaWQ+KCk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgQE9wdGlvbmFsKCkgQEluamVjdChDZGtTZWxlY3Rpb24pIHByaXZhdGUgX3NlbGVjdGlvbjogQ2RrU2VsZWN0aW9uPFQ+LFxuICAgIEBPcHRpb25hbCgpXG4gICAgQFNlbGYoKVxuICAgIEBJbmplY3QoTkdfVkFMVUVfQUNDRVNTT1IpXG4gICAgcHJpdmF0ZSBfY29udHJvbFZhbHVlQWNjZXNzb3JzOiBDb250cm9sVmFsdWVBY2Nlc3NvcltdLFxuICApIHt9XG5cbiAgbmdPbkluaXQoKSB7XG4gICAgdGhpcy5fYXNzZXJ0VmFsaWRQYXJlbnRTZWxlY3Rpb24oKTtcbiAgICB0aGlzLl9jb25maWd1cmVDb250cm9sVmFsdWVBY2Nlc3NvcigpO1xuICB9XG5cbiAgbmdPbkRlc3Ryb3koKSB7XG4gICAgdGhpcy5fZGVzdHJveWVkLm5leHQoKTtcbiAgICB0aGlzLl9kZXN0cm95ZWQuY29tcGxldGUoKTtcbiAgfVxuXG4gIHByaXZhdGUgX2Fzc2VydFZhbGlkUGFyZW50U2VsZWN0aW9uKCkge1xuICAgIGlmICghdGhpcy5fc2VsZWN0aW9uICYmICh0eXBlb2YgbmdEZXZNb2RlID09PSAndW5kZWZpbmVkJyB8fCBuZ0Rldk1vZGUpKSB7XG4gICAgICB0aHJvdyBFcnJvcignQ2RrU2VsZWN0QWxsOiBtaXNzaW5nIENka1NlbGVjdGlvbiBpbiB0aGUgcGFyZW50Jyk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBfY29uZmlndXJlQ29udHJvbFZhbHVlQWNjZXNzb3IoKSB7XG4gICAgaWYgKHRoaXMuX2NvbnRyb2xWYWx1ZUFjY2Vzc29ycyAmJiB0aGlzLl9jb250cm9sVmFsdWVBY2Nlc3NvcnMubGVuZ3RoKSB7XG4gICAgICB0aGlzLl9jb250cm9sVmFsdWVBY2Nlc3NvcnNbMF0ucmVnaXN0ZXJPbkNoYW5nZSgoZTogdW5rbm93bikgPT4ge1xuICAgICAgICBpZiAodHlwZW9mIGUgPT09ICdib29sZWFuJykge1xuICAgICAgICAgIHRoaXMudG9nZ2xlKCk7XG4gICAgICAgIH1cbiAgICAgIH0pO1xuXG4gICAgICB0aGlzLmNoZWNrZWQucGlwZSh0YWtlVW50aWwodGhpcy5fZGVzdHJveWVkKSkuc3Vic2NyaWJlKHN0YXRlID0+IHtcbiAgICAgICAgdGhpcy5fY29udHJvbFZhbHVlQWNjZXNzb3JzWzBdLndyaXRlVmFsdWUoc3RhdGUpO1xuICAgICAgfSk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBfaXNTZWxlY3RlZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5fc2VsZWN0aW9uLmlzU2VsZWN0ZWQodGhpcy52YWx1ZSwgdGhpcy5pbmRleCk7XG4gIH1cblxuICBzdGF0aWMgbmdBY2NlcHRJbnB1dFR5cGVfaW5kZXg6IE51bWJlcklucHV0O1xufVxuIl19