@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/sort/sort.js

@@ -16,111 +16,107 @@ class MatSortBase {
 }
 const _MatSortMixinBase = mixinInitialized(mixinDisabled(MatSortBase));
 /** Container for MatSortables to manage the sort state and provide default sort parameters. */
-let MatSort = /** @class */ (() => {
-    class MatSort extends _MatSortMixinBase {
-        constructor() {
-            super(...arguments);
-            /** Collection of all registered sortables that this directive manages. */
-            this.sortables = new Map();
-            /** Used to notify any child components listening to state changes. */
-            this._stateChanges = new Subject();
-            /**
-             * The direction to set when an MatSortable is initially sorted.
-             * May be overriden by the MatSortable's sort start.
-             */
-            this.start = 'asc';
-            this._direction = '';
-            /** Event emitted when the user changes either the active sort or sort direction. */
-            this.sortChange = new EventEmitter();
-        }
-        /** The sort direction of the currently active MatSortable. */
-        get direction() { return this._direction; }
-        set direction(direction) {
-            if (isDevMode() && direction && direction !== 'asc' && direction !== 'desc') {
-                throw getSortInvalidDirectionError(direction);
-            }
-            this._direction = direction;
-        }
-        /**
-         * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
-         * May be overriden by the MatSortable's disable clear input.
-         */
-        get disableClear() { return this._disableClear; }
-        set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }
+export class MatSort extends _MatSortMixinBase {
+    constructor() {
+        super(...arguments);
+        /** Collection of all registered sortables that this directive manages. */
+        this.sortables = new Map();
+        /** Used to notify any child components listening to state changes. */
+        this._stateChanges = new Subject();
         /**
-         * Register function to be used by the contained MatSortables. Adds the MatSortable to the
-         * collection of MatSortables.
+         * The direction to set when an MatSortable is initially sorted.
+         * May be overriden by the MatSortable's sort start.
          */
-        register(sortable) {
-            if (!sortable.id) {
-                throw getSortHeaderMissingIdError();
-            }
-            if (this.sortables.has(sortable.id)) {
-                throw getSortDuplicateSortableIdError(sortable.id);
-            }
-            this.sortables.set(sortable.id, sortable);
+        this.start = 'asc';
+        this._direction = '';
+        /** Event emitted when the user changes either the active sort or sort direction. */
+        this.sortChange = new EventEmitter();
+    }
+    /** The sort direction of the currently active MatSortable. */
+    get direction() { return this._direction; }
+    set direction(direction) {
+        if (isDevMode() && direction && direction !== 'asc' && direction !== 'desc') {
+            throw getSortInvalidDirectionError(direction);
         }
-        /**
-         * Unregister function to be used by the contained MatSortables. Removes the MatSortable from the
-         * collection of contained MatSortables.
-         */
-        deregister(sortable) {
-            this.sortables.delete(sortable.id);
+        this._direction = direction;
+    }
+    /**
+     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
+     * May be overriden by the MatSortable's disable clear input.
+     */
+    get disableClear() { return this._disableClear; }
+    set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }
+    /**
+     * Register function to be used by the contained MatSortables. Adds the MatSortable to the
+     * collection of MatSortables.
+     */
+    register(sortable) {
+        if (!sortable.id) {
+            throw getSortHeaderMissingIdError();
         }
-        /** Sets the active sort id and determines the new sort direction. */
-        sort(sortable) {
-            if (this.active != sortable.id) {
-                this.active = sortable.id;
-                this.direction = sortable.start ? sortable.start : this.start;
-            }
-            else {
-                this.direction = this.getNextSortDirection(sortable);
-            }
-            this.sortChange.emit({ active: this.active, direction: this.direction });
+        if (this.sortables.has(sortable.id)) {
+            throw getSortDuplicateSortableIdError(sortable.id);
         }
-        /** Returns the next sort direction of the active sortable, checking for potential overrides. */
-        getNextSortDirection(sortable) {
-            if (!sortable) {
-                return '';
-            }
-            // Get the sort direction cycle with the potential sortable overrides.
-            const disableClear = sortable.disableClear != null ? sortable.disableClear : this.disableClear;
-            let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);
-            // Get and return the next direction in the cycle
-            let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;
-            if (nextDirectionIndex >= sortDirectionCycle.length) {
-                nextDirectionIndex = 0;
-            }
-            return sortDirectionCycle[nextDirectionIndex];
+        this.sortables.set(sortable.id, sortable);
+    }
+    /**
+     * Unregister function to be used by the contained MatSortables. Removes the MatSortable from the
+     * collection of contained MatSortables.
+     */
+    deregister(sortable) {
+        this.sortables.delete(sortable.id);
+    }
+    /** Sets the active sort id and determines the new sort direction. */
+    sort(sortable) {
+        if (this.active != sortable.id) {
+            this.active = sortable.id;
+            this.direction = sortable.start ? sortable.start : this.start;
         }
-        ngOnInit() {
-            this._markInitialized();
+        else {
+            this.direction = this.getNextSortDirection(sortable);
         }
-        ngOnChanges() {
-            this._stateChanges.next();
+        this.sortChange.emit({ active: this.active, direction: this.direction });
+    }
+    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
+    getNextSortDirection(sortable) {
+        if (!sortable) {
+            return '';
         }
-        ngOnDestroy() {
-            this._stateChanges.complete();
+        // Get the sort direction cycle with the potential sortable overrides.
+        const disableClear = sortable.disableClear != null ? sortable.disableClear : this.disableClear;
+        let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);
+        // Get and return the next direction in the cycle
+        let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;
+        if (nextDirectionIndex >= sortDirectionCycle.length) {
+            nextDirectionIndex = 0;
         }
+        return sortDirectionCycle[nextDirectionIndex];
+    }
+    ngOnInit() {
+        this._markInitialized();
     }
-    MatSort.decorators = [
-        { type: Directive, args: [{
-                    selector: '[matSort]',
-                    exportAs: 'matSort',
-                    host: { 'class': 'mat-sort' },
-                    inputs: ['disabled: matSortDisabled']
-                },] }
-    ];
-    MatSort.propDecorators = {
-        active: [{ type: Input, args: ['matSortActive',] }],
-        start: [{ type: Input, args: ['matSortStart',] }],
-        direction: [{ type: Input, args: ['matSortDirection',] }],
-        disableClear: [{ type: Input, args: ['matSortDisableClear',] }],
-        sortChange: [{ type: Output, args: ['matSortChange',] }]
-    };
-    return MatSort;
-})();
-export { MatSort };
+    ngOnChanges() {
+        this._stateChanges.next();
+    }
+    ngOnDestroy() {
+        this._stateChanges.complete();
+    }
+}
+MatSort.decorators = [
+    { type: Directive, args: [{
+                selector: '[matSort]',
+                exportAs: 'matSort',
+                host: { 'class': 'mat-sort' },
+                inputs: ['disabled: matSortDisabled']
+            },] }
+];
+MatSort.propDecorators = {
+    active: [{ type: Input, args: ['matSortActive',] }],
+    start: [{ type: Input, args: ['matSortStart',] }],
+    direction: [{ type: Input, args: ['matSortDirection',] }],
+    disableClear: [{ type: Input, args: ['matSortDisableClear',] }],
+    sortChange: [{ type: Output, args: ['matSortChange',] }]
+};
 /** Returns the sort direction cycle to use given the provided parameters of order and clear. */
 function getSortDirectionCycle(start, disableClear) {
     let sortOrder = ['asc', 'desc'];
@@ -132,4 +128,4 @@ function getSortDirectionCycle(start, disableClear) {
     }
     return sortOrder;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../../../../src/material/sort/sort.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAe,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAC1E,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EACL,SAAS,EAIT,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAKL,aAAa,EACb,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAE7B,OAAO,EACL,+BAA+B,EAC/B,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,eAAe,CAAC;AAuBvB,8CAA8C;AAC9C,oBAAoB;AACpB,MAAM,WAAW;CAAG;AACpB,MAAM,iBAAiB,GACnB,gBAAgB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC;AAEjD,+FAA+F;AAC/F;IAAA,MAMa,OAAQ,SAAQ,iBAAiB;QAN9C;;YAQE,0EAA0E;YAC1E,cAAS,GAAG,IAAI,GAAG,EAAuB,CAAC;YAE3C,sEAAsE;YAC7D,kBAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;YAK7C;;;eAGG;YACoB,UAAK,GAAmB,KAAK,CAAC;YAW7C,eAAU,GAAkB,EAAE,CAAC;YAWvC,oFAAoF;YAClD,eAAU,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAiE9F,CAAC;QAtFC,8DAA8D;QAC9D,IACI,SAAS,KAAoB,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAC1D,IAAI,SAAS,CAAC,SAAwB;YACpC,IAAI,SAAS,EAAE,IAAI,SAAS,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,EAAE;gBAC3E,MAAM,4BAA4B,CAAC,SAAS,CAAC,CAAC;aAC/C;YACD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC9B,CAAC;QAGD;;;WAGG;QACH,IACI,YAAY,KAAc,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1D,IAAI,YAAY,CAAC,CAAU,IAAI,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAM/E;;;WAGG;QACH,QAAQ,CAAC,QAAqB;YAC5B,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE;gBAChB,MAAM,2BAA2B,EAAE,CAAC;aACrC;YAED,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE;gBACnC,MAAM,+BAA+B,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;aACpD;YACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QAC5C,CAAC;QAED;;;WAGG;QACH,UAAU,CAAC,QAAqB;YAC9B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACrC,CAAC;QAED,qEAAqE;QACrE,IAAI,CAAC,QAAqB;YACxB,IAAI,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,EAAE,EAAE;gBAC9B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC;gBAC1B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;aAC/D;iBAAM;gBACL,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;aACtD;YAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAC,CAAC,CAAC;QACzE,CAAC;QAED,gGAAgG;QAChG,oBAAoB,CAAC,QAAqB;YACxC,IAAI,CAAC,QAAQ,EAAE;gBAAE,OAAO,EAAE,CAAC;aAAE;YAE7B,sEAAsE;YACtE,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;YAC/F,IAAI,kBAAkB,GAAG,qBAAqB,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YAE3F,iDAAiD;YACjD,IAAI,kBAAkB,GAAG,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACxE,IAAI,kBAAkB,IAAI,kBAAkB,CAAC,MAAM,EAAE;gBAAE,kBAAkB,GAAG,CAAC,CAAC;aAAE;YAChF,OAAO,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;QAChD,CAAC;QAED,QAAQ;YACN,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;QAED,WAAW;YACT,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC5B,CAAC;QAED,WAAW;YACT,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QAChC,CAAC;;;gBAzGF,SAAS,SAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,SAAS;oBACnB,IAAI,EAAE,EAAC,OAAO,EAAE,UAAU,EAAC;oBAC3B,MAAM,EAAE,CAAC,2BAA2B,CAAC;iBACtC;;;yBAUE,KAAK,SAAC,eAAe;wBAMrB,KAAK,SAAC,cAAc;4BAGpB,KAAK,SAAC,kBAAkB;+BAcxB,KAAK,SAAC,qBAAqB;6BAM3B,MAAM,SAAC,eAAe;;IAiEzB,cAAC;KAAA;SAvGY,OAAO;AAyGpB,gGAAgG;AAChG,SAAS,qBAAqB,CAAC,KAAqB,EACrB,YAAqB;IAClD,IAAI,SAAS,GAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACjD,IAAI,KAAK,IAAI,MAAM,EAAE;QAAE,SAAS,CAAC,OAAO,EAAE,CAAC;KAAE;IAC7C,IAAI,CAAC,YAAY,EAAE;QAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;KAAE;IAE1C,OAAO,SAAS,CAAC;AACnB,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 {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {\n  Directive,\n  EventEmitter,\n  Input,\n  isDevMode,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\nimport {\n  CanDisable,\n  CanDisableCtor,\n  HasInitialized,\n  HasInitializedCtor,\n  mixinDisabled,\n  mixinInitialized,\n} from '@angular/material/core';\nimport {Subject} from 'rxjs';\nimport {SortDirection} from './sort-direction';\nimport {\n  getSortDuplicateSortableIdError,\n  getSortHeaderMissingIdError,\n  getSortInvalidDirectionError,\n} from './sort-errors';\n\n/** Interface for a directive that holds sorting state consumed by `MatSortHeader`. */\nexport interface MatSortable {\n  /** The id of the column being sorted. */\n  id: string;\n\n  /** Starting sort direction. */\n  start: 'asc' | 'desc';\n\n  /** Whether to disable clearing the sorting state. */\n  disableClear: boolean;\n}\n\n/** The current sort state. */\nexport interface Sort {\n  /** The id of the column being sorted. */\n  active: string;\n\n  /** The sort direction. */\n  direction: SortDirection;\n}\n\n// Boilerplate for applying mixins to MatSort.\n/** @docs-private */\nclass MatSortBase {}\nconst _MatSortMixinBase: HasInitializedCtor & CanDisableCtor & typeof MatSortBase =\n    mixinInitialized(mixinDisabled(MatSortBase));\n\n/** Container for MatSortables to manage the sort state and provide default sort parameters. */\n@Directive({\n  selector: '[matSort]',\n  exportAs: 'matSort',\n  host: {'class': 'mat-sort'},\n  inputs: ['disabled: matSortDisabled']\n})\nexport class MatSort extends _MatSortMixinBase\n    implements CanDisable, HasInitialized, OnChanges, OnDestroy, OnInit {\n  /** Collection of all registered sortables that this directive manages. */\n  sortables = new Map<string, MatSortable>();\n\n  /** Used to notify any child components listening to state changes. */\n  readonly _stateChanges = new Subject<void>();\n\n  /** The id of the most recently sorted MatSortable. */\n  @Input('matSortActive') active: string;\n\n  /**\n   * The direction to set when an MatSortable is initially sorted.\n   * May be overriden by the MatSortable's sort start.\n   */\n  @Input('matSortStart') start: 'asc' | 'desc' = 'asc';\n\n  /** The sort direction of the currently active MatSortable. */\n  @Input('matSortDirection')\n  get direction(): SortDirection { return this._direction; }\n  set direction(direction: SortDirection) {\n    if (isDevMode() && direction && direction !== 'asc' && direction !== 'desc') {\n      throw getSortInvalidDirectionError(direction);\n    }\n    this._direction = direction;\n  }\n  private _direction: SortDirection = '';\n\n  /**\n   * Whether to disable the user from clearing the sort by finishing the sort direction cycle.\n   * May be overriden by the MatSortable's disable clear input.\n   */\n  @Input('matSortDisableClear')\n  get disableClear(): boolean { return this._disableClear; }\n  set disableClear(v: boolean) { this._disableClear = coerceBooleanProperty(v); }\n  private _disableClear: boolean;\n\n  /** Event emitted when the user changes either the active sort or sort direction. */\n  @Output('matSortChange') readonly sortChange: EventEmitter<Sort> = new EventEmitter<Sort>();\n\n  /**\n   * Register function to be used by the contained MatSortables. Adds the MatSortable to the\n   * collection of MatSortables.\n   */\n  register(sortable: MatSortable): void {\n    if (!sortable.id) {\n      throw getSortHeaderMissingIdError();\n    }\n\n    if (this.sortables.has(sortable.id)) {\n      throw getSortDuplicateSortableIdError(sortable.id);\n    }\n    this.sortables.set(sortable.id, sortable);\n  }\n\n  /**\n   * Unregister function to be used by the contained MatSortables. Removes the MatSortable from the\n   * collection of contained MatSortables.\n   */\n  deregister(sortable: MatSortable): void {\n    this.sortables.delete(sortable.id);\n  }\n\n  /** Sets the active sort id and determines the new sort direction. */\n  sort(sortable: MatSortable): void {\n    if (this.active != sortable.id) {\n      this.active = sortable.id;\n      this.direction = sortable.start ? sortable.start : this.start;\n    } else {\n      this.direction = this.getNextSortDirection(sortable);\n    }\n\n    this.sortChange.emit({active: this.active, direction: this.direction});\n  }\n\n  /** Returns the next sort direction of the active sortable, checking for potential overrides. */\n  getNextSortDirection(sortable: MatSortable): SortDirection {\n    if (!sortable) { return ''; }\n\n    // Get the sort direction cycle with the potential sortable overrides.\n    const disableClear = sortable.disableClear != null ? sortable.disableClear : this.disableClear;\n    let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);\n\n    // Get and return the next direction in the cycle\n    let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;\n    if (nextDirectionIndex >= sortDirectionCycle.length) { nextDirectionIndex = 0; }\n    return sortDirectionCycle[nextDirectionIndex];\n  }\n\n  ngOnInit() {\n    this._markInitialized();\n  }\n\n  ngOnChanges() {\n    this._stateChanges.next();\n  }\n\n  ngOnDestroy() {\n    this._stateChanges.complete();\n  }\n\n  static ngAcceptInputType_disableClear: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n\n/** Returns the sort direction cycle to use given the provided parameters of order and clear. */\nfunction getSortDirectionCycle(start: 'asc' | 'desc',\n                               disableClear: boolean): SortDirection[] {\n  let sortOrder: SortDirection[] = ['asc', 'desc'];\n  if (start == 'desc') { sortOrder.reverse(); }\n  if (!disableClear) { sortOrder.push(''); }\n\n  return sortOrder;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../../../../src/material/sort/sort.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 {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {\n  Directive,\n  EventEmitter,\n  Input,\n  isDevMode,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\nimport {\n  CanDisable,\n  CanDisableCtor,\n  HasInitialized,\n  HasInitializedCtor,\n  mixinDisabled,\n  mixinInitialized,\n} from '@angular/material/core';\nimport {Subject} from 'rxjs';\nimport {SortDirection} from './sort-direction';\nimport {\n  getSortDuplicateSortableIdError,\n  getSortHeaderMissingIdError,\n  getSortInvalidDirectionError,\n} from './sort-errors';\n\n/** Interface for a directive that holds sorting state consumed by `MatSortHeader`. */\nexport interface MatSortable {\n  /** The id of the column being sorted. */\n  id: string;\n\n  /** Starting sort direction. */\n  start: 'asc' | 'desc';\n\n  /** Whether to disable clearing the sorting state. */\n  disableClear: boolean;\n}\n\n/** The current sort state. */\nexport interface Sort {\n  /** The id of the column being sorted. */\n  active: string;\n\n  /** The sort direction. */\n  direction: SortDirection;\n}\n\n// Boilerplate for applying mixins to MatSort.\n/** @docs-private */\nclass MatSortBase {}\nconst _MatSortMixinBase: HasInitializedCtor & CanDisableCtor & typeof MatSortBase =\n    mixinInitialized(mixinDisabled(MatSortBase));\n\n/** Container for MatSortables to manage the sort state and provide default sort parameters. */\n@Directive({\n  selector: '[matSort]',\n  exportAs: 'matSort',\n  host: {'class': 'mat-sort'},\n  inputs: ['disabled: matSortDisabled']\n})\nexport class MatSort extends _MatSortMixinBase\n    implements CanDisable, HasInitialized, OnChanges, OnDestroy, OnInit {\n  /** Collection of all registered sortables that this directive manages. */\n  sortables = new Map<string, MatSortable>();\n\n  /** Used to notify any child components listening to state changes. */\n  readonly _stateChanges = new Subject<void>();\n\n  /** The id of the most recently sorted MatSortable. */\n  @Input('matSortActive') active: string;\n\n  /**\n   * The direction to set when an MatSortable is initially sorted.\n   * May be overriden by the MatSortable's sort start.\n   */\n  @Input('matSortStart') start: 'asc' | 'desc' = 'asc';\n\n  /** The sort direction of the currently active MatSortable. */\n  @Input('matSortDirection')\n  get direction(): SortDirection { return this._direction; }\n  set direction(direction: SortDirection) {\n    if (isDevMode() && direction && direction !== 'asc' && direction !== 'desc') {\n      throw getSortInvalidDirectionError(direction);\n    }\n    this._direction = direction;\n  }\n  private _direction: SortDirection = '';\n\n  /**\n   * Whether to disable the user from clearing the sort by finishing the sort direction cycle.\n   * May be overriden by the MatSortable's disable clear input.\n   */\n  @Input('matSortDisableClear')\n  get disableClear(): boolean { return this._disableClear; }\n  set disableClear(v: boolean) { this._disableClear = coerceBooleanProperty(v); }\n  private _disableClear: boolean;\n\n  /** Event emitted when the user changes either the active sort or sort direction. */\n  @Output('matSortChange') readonly sortChange: EventEmitter<Sort> = new EventEmitter<Sort>();\n\n  /**\n   * Register function to be used by the contained MatSortables. Adds the MatSortable to the\n   * collection of MatSortables.\n   */\n  register(sortable: MatSortable): void {\n    if (!sortable.id) {\n      throw getSortHeaderMissingIdError();\n    }\n\n    if (this.sortables.has(sortable.id)) {\n      throw getSortDuplicateSortableIdError(sortable.id);\n    }\n    this.sortables.set(sortable.id, sortable);\n  }\n\n  /**\n   * Unregister function to be used by the contained MatSortables. Removes the MatSortable from the\n   * collection of contained MatSortables.\n   */\n  deregister(sortable: MatSortable): void {\n    this.sortables.delete(sortable.id);\n  }\n\n  /** Sets the active sort id and determines the new sort direction. */\n  sort(sortable: MatSortable): void {\n    if (this.active != sortable.id) {\n      this.active = sortable.id;\n      this.direction = sortable.start ? sortable.start : this.start;\n    } else {\n      this.direction = this.getNextSortDirection(sortable);\n    }\n\n    this.sortChange.emit({active: this.active, direction: this.direction});\n  }\n\n  /** Returns the next sort direction of the active sortable, checking for potential overrides. */\n  getNextSortDirection(sortable: MatSortable): SortDirection {\n    if (!sortable) { return ''; }\n\n    // Get the sort direction cycle with the potential sortable overrides.\n    const disableClear = sortable.disableClear != null ? sortable.disableClear : this.disableClear;\n    let sortDirectionCycle = getSortDirectionCycle(sortable.start || this.start, disableClear);\n\n    // Get and return the next direction in the cycle\n    let nextDirectionIndex = sortDirectionCycle.indexOf(this.direction) + 1;\n    if (nextDirectionIndex >= sortDirectionCycle.length) { nextDirectionIndex = 0; }\n    return sortDirectionCycle[nextDirectionIndex];\n  }\n\n  ngOnInit() {\n    this._markInitialized();\n  }\n\n  ngOnChanges() {\n    this._stateChanges.next();\n  }\n\n  ngOnDestroy() {\n    this._stateChanges.complete();\n  }\n\n  static ngAcceptInputType_disableClear: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n\n/** Returns the sort direction cycle to use given the provided parameters of order and clear. */\nfunction getSortDirectionCycle(start: 'asc' | 'desc',\n                               disableClear: boolean): SortDirection[] {\n  let sortOrder: SortDirection[] = ['asc', 'desc'];\n  if (start == 'desc') { sortOrder.reverse(); }\n  if (!disableClear) { sortOrder.push(''); }\n\n  return sortOrder;\n}\n"]}

package/esm2015/sort/testing/sort-harness.js

@@ -9,37 +9,33 @@ import { __awaiter } from "tslib";
 import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
 import { MatSortHeaderHarness } from './sort-header-harness';
 /** Harness for interacting with a standard `mat-sort` in tests. */
-let MatSortHarness = /** @class */ (() => {
-    class MatSortHarness extends ComponentHarness {
-        /**
-         * Gets a `HarnessPredicate` that can be used to search for a `mat-sort` with specific attributes.
-         * @param options Options for narrowing the search.
-         * @return a `HarnessPredicate` configured with the given options.
-         */
-        static with(options = {}) {
-            return new HarnessPredicate(MatSortHarness, options);
-        }
-        /** Gets all of the sort headers in the `mat-sort`. */
-        getSortHeaders(filter = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this.locatorForAll(MatSortHeaderHarness.with(filter))();
-            });
-        }
-        /** Gets the selected header in the `mat-sort`. */
-        getActiveHeader() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const headers = yield this.getSortHeaders();
-                for (let i = 0; i < headers.length; i++) {
-                    if (yield headers[i].isActive()) {
-                        return headers[i];
-                    }
+export class MatSortHarness extends ComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `mat-sort` with specific attributes.
+     * @param options Options for narrowing the search.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatSortHarness, options);
+    }
+    /** Gets all of the sort headers in the `mat-sort`. */
+    getSortHeaders(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.locatorForAll(MatSortHeaderHarness.with(filter))();
+        });
+    }
+    /** Gets the selected header in the `mat-sort`. */
+    getActiveHeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = yield this.getSortHeaders();
+            for (let i = 0; i < headers.length; i++) {
+                if (yield headers[i].isActive()) {
+                    return headers[i];
                 }
-                return null;
-            });
-        }
+            }
+            return null;
+        });
     }
-    MatSortHarness.hostSelector = '.mat-sort';
-    return MatSortHarness;
-})();
-export { MatSortHarness };
-//# sourceMappingURL=data:application/json;base64,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
+}
+MatSortHarness.hostSelector = '.mat-sort';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/sort/testing/sort-header-harness.js

@@ -8,71 +8,70 @@
 import { __awaiter } from "tslib";
 import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
 /** Harness for interacting with a standard Angular Material sort header in tests. */
-let MatSortHeaderHarness = /** @class */ (() => {
-    class MatSortHeaderHarness extends ComponentHarness {
-        constructor() {
-            super(...arguments);
-            this._button = this.locatorFor('.mat-sort-header-button');
-        }
-        /**
-         * Gets a `HarnessPredicate` that can be used to
-         * search for a sort header with specific attributes.
-         */
-        static with(options = {}) {
-            return new HarnessPredicate(MatSortHeaderHarness, options)
-                .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label))
-                .addOption('sortDirection', options.sortDirection, (harness, sortDirection) => {
-                return HarnessPredicate.stringMatches(harness.getSortDirection(), sortDirection);
-            });
-        }
-        /** Gets the label of the sort header. */
-        getLabel() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this._button()).text();
-            });
-        }
-        /** Gets the sorting direction of the header. */
-        getSortDirection() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const host = yield this.host();
-                const ariaSort = yield host.getAttribute('aria-sort');
-                if (ariaSort === 'ascending') {
-                    return 'asc';
-                }
-                else if (ariaSort === 'descending') {
-                    return 'desc';
-                }
-                return '';
-            });
-        }
-        /** Gets the aria-label of the sort header. */
-        getAriaLabel() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this._button()).getAttribute('aria-label');
-            });
-        }
-        /** Gets whether the sort header is currently being sorted by. */
-        isActive() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return !!(yield this.getSortDirection());
-            });
-        }
-        /** Whether the sort header is disabled. */
-        isDisabled() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const button = yield this._button();
-                return (yield button.getAttribute('disabled')) != null;
-            });
-        }
-        /** Clicks the header to change its sorting direction. Only works if the header is enabled. */
-        click() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).click();
-            });
-        }
+export class MatSortHeaderHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._container = this.locatorFor('.mat-sort-header-container');
     }
-    MatSortHeaderHarness.hostSelector = '.mat-sort-header';
-    return MatSortHeaderHarness;
-})();
-export { MatSortHeaderHarness };
-//# sourceMappingURL=data:application/json;base64,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
+    /**
+     * Gets a `HarnessPredicate` that can be used to
+     * search for a sort header with specific attributes.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatSortHeaderHarness, options)
+            .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label))
+            .addOption('sortDirection', options.sortDirection, (harness, sortDirection) => {
+            return HarnessPredicate.stringMatches(harness.getSortDirection(), sortDirection);
+        });
+    }
+    /** Gets the label of the sort header. */
+    getLabel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._container()).text();
+        });
+    }
+    /** Gets the sorting direction of the header. */
+    getSortDirection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const host = yield this.host();
+            const ariaSort = yield host.getAttribute('aria-sort');
+            if (ariaSort === 'ascending') {
+                return 'asc';
+            }
+            else if (ariaSort === 'descending') {
+                return 'desc';
+            }
+            return '';
+        });
+    }
+    /**
+     * Gets the aria-label of the sort header.
+     * @deprecated The sort header no longer has an `aria-label`. This method will be removed.
+     * @breaking-change 11.0.0
+     */
+    getAriaLabel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._container()).getAttribute('aria-label');
+        });
+    }
+    /** Gets whether the sort header is currently being sorted by. */
+    isActive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.getSortDirection());
+        });
+    }
+    /** Whether the sort header is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-sort-header-disabled');
+        });
+    }
+    /** Clicks the header to change its sorting direction. Only works if the header is enabled. */
+    click() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).click();
+        });
+    }
+}
+MatSortHeaderHarness.hostSelector = '.mat-sort-header';
+//# sourceMappingURL=data:application/json;base64,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