@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/sort/sort-header.js

@@ -9,6 +9,7 @@ import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, Optional, ViewEncapsulation, Inject, ElementRef, } from '@angular/core';
 import { mixinDisabled } from '@angular/material/core';
 import { FocusMonitor } from '@angular/cdk/a11y';
+import { ENTER, SPACE } from '@angular/cdk/keycodes';
 import { merge } from 'rxjs';
 import { MatSort } from './sort';
 import { matSortAnimations } from './sort-animations';
@@ -28,213 +29,218 @@ const _MatSortHeaderMixinBase = mixinDisabled(MatSortHeaderBase);
  * If used on header cells in a CdkTable, it will automatically default its id from its containing
  * column definition.
  */
-let MatSortHeader = /** @class */ (() => {
-    class MatSortHeader extends _MatSortHeaderMixinBase {
-        constructor(_intl, changeDetectorRef, _sort, _columnDef, _focusMonitor, _elementRef) {
-            // Note that we use a string token for the `_columnDef`, because the value is provided both by
-            // `material/table` and `cdk/table` and we can't have the CDK depending on Material,
-            // and we want to avoid having the sort header depending on the CDK table because
-            // of this single reference.
-            super();
-            this._intl = _intl;
-            this._sort = _sort;
-            this._columnDef = _columnDef;
-            this._focusMonitor = _focusMonitor;
-            this._elementRef = _elementRef;
-            /**
-             * Flag set to true when the indicator should be displayed while the sort is not active. Used to
-             * provide an affordance that the header is sortable by showing on focus and hover.
-             */
-            this._showIndicatorHint = false;
-            /** The direction the arrow should be facing according to the current state. */
-            this._arrowDirection = '';
-            /**
-             * Whether the view state animation should show the transition between the `from` and `to` states.
-             */
-            this._disableViewStateAnimation = false;
-            /** Sets the position of the arrow that displays when sorted. */
-            this.arrowPosition = 'after';
-            if (!_sort) {
-                throw getSortHeaderNotContainedWithinSortError();
-            }
-            this._rerenderSubscription = merge(_sort.sortChange, _sort._stateChanges, _intl.changes)
-                .subscribe(() => {
-                if (this._isSorted()) {
-                    this._updateArrowDirection();
-                }
-                // If this header was recently active and now no longer sorted, animate away the arrow.
-                if (!this._isSorted() && this._viewState && this._viewState.toState === 'active') {
-                    this._disableViewStateAnimation = false;
-                    this._setAnimationTransitionState({ fromState: 'active', toState: this._arrowDirection });
-                }
-                changeDetectorRef.markForCheck();
-            });
-        }
-        /** Overrides the disable clear value of the containing MatSort for this MatSortable. */
-        get disableClear() { return this._disableClear; }
-        set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }
-        ngOnInit() {
-            if (!this.id && this._columnDef) {
-                this.id = this._columnDef.name;
-            }
-            // Initialize the direction of the arrow and set the view state to be immediately that state.
-            this._updateArrowDirection();
-            this._setAnimationTransitionState({ toState: this._isSorted() ? 'active' : this._arrowDirection });
-            this._sort.register(this);
-        }
-        ngAfterViewInit() {
-            // We use the focus monitor because we also want to style
-            // things differently based on the focus origin.
-            this._focusMonitor.monitor(this._elementRef, true)
-                .subscribe(origin => this._setIndicatorHintVisible(!!origin));
-        }
-        ngOnDestroy() {
-            this._focusMonitor.stopMonitoring(this._elementRef);
-            this._sort.deregister(this);
-            this._rerenderSubscription.unsubscribe();
-        }
+export class MatSortHeader extends _MatSortHeaderMixinBase {
+    constructor(_intl, changeDetectorRef, _sort, _columnDef, _focusMonitor, _elementRef) {
+        // Note that we use a string token for the `_columnDef`, because the value is provided both by
+        // `material/table` and `cdk/table` and we can't have the CDK depending on Material,
+        // and we want to avoid having the sort header depending on the CDK table because
+        // of this single reference.
+        super();
+        this._intl = _intl;
+        this._sort = _sort;
+        this._columnDef = _columnDef;
+        this._focusMonitor = _focusMonitor;
+        this._elementRef = _elementRef;
         /**
-         * Sets the "hint" state such that the arrow will be semi-transparently displayed as a hint to the
-         * user showing what the active sort will become. If set to false, the arrow will fade away.
+         * Flag set to true when the indicator should be displayed while the sort is not active. Used to
+         * provide an affordance that the header is sortable by showing on focus and hover.
          */
-        _setIndicatorHintVisible(visible) {
-            // No-op if the sort header is disabled - should not make the hint visible.
-            if (this._isDisabled() && visible) {
-                return;
-            }
-            this._showIndicatorHint = visible;
-            if (!this._isSorted()) {
-                this._updateArrowDirection();
-                if (this._showIndicatorHint) {
-                    this._setAnimationTransitionState({ fromState: this._arrowDirection, toState: 'hint' });
-                }
-                else {
-                    this._setAnimationTransitionState({ fromState: 'hint', toState: this._arrowDirection });
-                }
-            }
-        }
+        this._showIndicatorHint = false;
+        /** The direction the arrow should be facing according to the current state. */
+        this._arrowDirection = '';
         /**
-         * Sets the animation transition view state for the arrow's position and opacity. If the
-         * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that
-         * no animation appears.
+         * Whether the view state animation should show the transition between the `from` and `to` states.
          */
-        _setAnimationTransitionState(viewState) {
-            this._viewState = viewState;
-            // If the animation for arrow position state (opacity/translation) should be disabled,
-            // remove the fromState so that it jumps right to the toState.
-            if (this._disableViewStateAnimation) {
-                this._viewState = { toState: viewState.toState };
-            }
+        this._disableViewStateAnimation = false;
+        /** Sets the position of the arrow that displays when sorted. */
+        this.arrowPosition = 'after';
+        if (!_sort) {
+            throw getSortHeaderNotContainedWithinSortError();
         }
-        /** Triggers the sort on this sort header and removes the indicator hint. */
-        _handleClick() {
-            if (this._isDisabled()) {
-                return;
+        this._rerenderSubscription = merge(_sort.sortChange, _sort._stateChanges, _intl.changes)
+            .subscribe(() => {
+            if (this._isSorted()) {
+                this._updateArrowDirection();
             }
-            this._sort.sort(this);
-            // Do not show the animation if the header was already shown in the right position.
-            if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {
-                this._disableViewStateAnimation = true;
+            // If this header was recently active and now no longer sorted, animate away the arrow.
+            if (!this._isSorted() && this._viewState && this._viewState.toState === 'active') {
+                this._disableViewStateAnimation = false;
+                this._setAnimationTransitionState({ fromState: 'active', toState: this._arrowDirection });
             }
-            // If the arrow is now sorted, animate the arrow into place. Otherwise, animate it away into
-            // the direction it is facing.
-            const viewState = this._isSorted() ?
-                { fromState: this._arrowDirection, toState: 'active' } :
-                { fromState: 'active', toState: this._arrowDirection };
-            this._setAnimationTransitionState(viewState);
-            this._showIndicatorHint = false;
+            changeDetectorRef.markForCheck();
+        });
+    }
+    /** Overrides the disable clear value of the containing MatSort for this MatSortable. */
+    get disableClear() { return this._disableClear; }
+    set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }
+    ngOnInit() {
+        if (!this.id && this._columnDef) {
+            this.id = this._columnDef.name;
         }
-        /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */
-        _isSorted() {
-            return this._sort.active == this.id &&
-                (this._sort.direction === 'asc' || this._sort.direction === 'desc');
+        // Initialize the direction of the arrow and set the view state to be immediately that state.
+        this._updateArrowDirection();
+        this._setAnimationTransitionState({ toState: this._isSorted() ? 'active' : this._arrowDirection });
+        this._sort.register(this);
+    }
+    ngAfterViewInit() {
+        // We use the focus monitor because we also want to style
+        // things differently based on the focus origin.
+        this._focusMonitor.monitor(this._elementRef, true)
+            .subscribe(origin => this._setIndicatorHintVisible(!!origin));
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        this._sort.deregister(this);
+        this._rerenderSubscription.unsubscribe();
+    }
+    /**
+     * Sets the "hint" state such that the arrow will be semi-transparently displayed as a hint to the
+     * user showing what the active sort will become. If set to false, the arrow will fade away.
+     */
+    _setIndicatorHintVisible(visible) {
+        // No-op if the sort header is disabled - should not make the hint visible.
+        if (this._isDisabled() && visible) {
+            return;
         }
-        /** Returns the animation state for the arrow direction (indicator and pointers). */
-        _getArrowDirectionState() {
-            return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;
+        this._showIndicatorHint = visible;
+        if (!this._isSorted()) {
+            this._updateArrowDirection();
+            if (this._showIndicatorHint) {
+                this._setAnimationTransitionState({ fromState: this._arrowDirection, toState: 'hint' });
+            }
+            else {
+                this._setAnimationTransitionState({ fromState: 'hint', toState: this._arrowDirection });
+            }
         }
-        /** Returns the arrow position state (opacity, translation). */
-        _getArrowViewState() {
-            const fromState = this._viewState.fromState;
-            return (fromState ? `${fromState}-to-` : '') + this._viewState.toState;
+    }
+    /**
+     * Sets the animation transition view state for the arrow's position and opacity. If the
+     * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that
+     * no animation appears.
+     */
+    _setAnimationTransitionState(viewState) {
+        this._viewState = viewState;
+        // If the animation for arrow position state (opacity/translation) should be disabled,
+        // remove the fromState so that it jumps right to the toState.
+        if (this._disableViewStateAnimation) {
+            this._viewState = { toState: viewState.toState };
         }
-        /**
-         * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be
-         * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently
-         * active sorted direction. The reason this is updated through a function is because the direction
-         * should only be changed at specific times - when deactivated but the hint is displayed and when
-         * the sort is active and the direction changes. Otherwise the arrow's direction should linger
-         * in cases such as the sort becoming deactivated but we want to animate the arrow away while
-         * preserving its direction, even though the next sort direction is actually different and should
-         * only be changed once the arrow displays again (hint or activation).
-         */
-        _updateArrowDirection() {
-            this._arrowDirection = this._isSorted() ?
-                this._sort.direction :
-                (this.start || this._sort.start);
+    }
+    /** Triggers the sort on this sort header and removes the indicator hint. */
+    _toggleOnInteraction() {
+        this._sort.sort(this);
+        // Do not show the animation if the header was already shown in the right position.
+        if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {
+            this._disableViewStateAnimation = true;
         }
-        _isDisabled() {
-            return this._sort.disabled || this.disabled;
+        // If the arrow is now sorted, animate the arrow into place. Otherwise, animate it away into
+        // the direction it is facing.
+        const viewState = this._isSorted() ?
+            { fromState: this._arrowDirection, toState: 'active' } :
+            { fromState: 'active', toState: this._arrowDirection };
+        this._setAnimationTransitionState(viewState);
+        this._showIndicatorHint = false;
+    }
+    _handleClick() {
+        if (!this._isDisabled()) {
+            this._toggleOnInteraction();
         }
-        /**
-         * Gets the aria-sort attribute that should be applied to this sort header. If this header
-         * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
-         * says that the aria-sort property should only be present on one header at a time, so removing
-         * ensures this is true.
-         */
-        _getAriaSortAttribute() {
-            if (!this._isSorted()) {
-                return null;
-            }
-            return this._sort.direction == 'asc' ? 'ascending' : 'descending';
+    }
+    _handleKeydown(event) {
+        if (!this._isDisabled() && (event.keyCode === SPACE || event.keyCode === ENTER)) {
+            event.preventDefault();
+            this._toggleOnInteraction();
         }
-        /** Whether the arrow inside the sort header should be rendered. */
-        _renderArrow() {
-            return !this._isDisabled() || this._isSorted();
+    }
+    /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */
+    _isSorted() {
+        return this._sort.active == this.id &&
+            (this._sort.direction === 'asc' || this._sort.direction === 'desc');
+    }
+    /** Returns the animation state for the arrow direction (indicator and pointers). */
+    _getArrowDirectionState() {
+        return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;
+    }
+    /** Returns the arrow position state (opacity, translation). */
+    _getArrowViewState() {
+        const fromState = this._viewState.fromState;
+        return (fromState ? `${fromState}-to-` : '') + this._viewState.toState;
+    }
+    /**
+     * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be
+     * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently
+     * active sorted direction. The reason this is updated through a function is because the direction
+     * should only be changed at specific times - when deactivated but the hint is displayed and when
+     * the sort is active and the direction changes. Otherwise the arrow's direction should linger
+     * in cases such as the sort becoming deactivated but we want to animate the arrow away while
+     * preserving its direction, even though the next sort direction is actually different and should
+     * only be changed once the arrow displays again (hint or activation).
+     */
+    _updateArrowDirection() {
+        this._arrowDirection = this._isSorted() ?
+            this._sort.direction :
+            (this.start || this._sort.start);
+    }
+    _isDisabled() {
+        return this._sort.disabled || this.disabled;
+    }
+    /**
+     * Gets the aria-sort attribute that should be applied to this sort header. If this header
+     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
+     * says that the aria-sort property should only be present on one header at a time, so removing
+     * ensures this is true.
+     */
+    _getAriaSortAttribute() {
+        if (!this._isSorted()) {
+            return 'none';
         }
+        return this._sort.direction == 'asc' ? 'ascending' : 'descending';
     }
-    MatSortHeader.decorators = [
-        { type: Component, args: [{
-                    selector: '[mat-sort-header]',
-                    exportAs: 'matSortHeader',
-                    template: "<div class=\"mat-sort-header-container\"\n     [class.mat-sort-header-sorted]=\"_isSorted()\"\n     [class.mat-sort-header-position-before]=\"arrowPosition == 'before'\">\n  <button class=\"mat-sort-header-button mat-focus-indicator\" type=\"button\"\n          [attr.disabled]=\"_isDisabled() || null\"\n          [attr.aria-label]=\"_intl.sortButtonLabel(id)\">\n    <ng-content></ng-content>\n  </button>\n\n  <!-- Disable animations while a current animation is running -->\n  <div class=\"mat-sort-header-arrow\"\n       *ngIf=\"_renderArrow()\"\n       [@arrowOpacity]=\"_getArrowViewState()\"\n       [@arrowPosition]=\"_getArrowViewState()\"\n       [@allowChildren]=\"_getArrowDirectionState()\"\n       (@arrowPosition.start)=\"_disableViewStateAnimation = true\"\n       (@arrowPosition.done)=\"_disableViewStateAnimation = false\">\n    <div class=\"mat-sort-header-stem\"></div>\n    <div class=\"mat-sort-header-indicator\" [@indicator]=\"_getArrowDirectionState()\">\n      <div class=\"mat-sort-header-pointer-left\" [@leftPointer]=\"_getArrowDirectionState()\"></div>\n      <div class=\"mat-sort-header-pointer-right\" [@rightPointer]=\"_getArrowDirectionState()\"></div>\n      <div class=\"mat-sort-header-pointer-middle\"></div>\n    </div>\n  </div>\n</div>\n",
-                    host: {
-                        'class': 'mat-sort-header',
-                        '(click)': '_handleClick()',
-                        '(mouseenter)': '_setIndicatorHintVisible(true)',
-                        '(mouseleave)': '_setIndicatorHintVisible(false)',
-                        '[attr.aria-sort]': '_getAriaSortAttribute()',
-                        '[class.mat-sort-header-disabled]': '_isDisabled()',
-                    },
-                    encapsulation: ViewEncapsulation.None,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    inputs: ['disabled'],
-                    animations: [
-                        matSortAnimations.indicator,
-                        matSortAnimations.leftPointer,
-                        matSortAnimations.rightPointer,
-                        matSortAnimations.arrowOpacity,
-                        matSortAnimations.arrowPosition,
-                        matSortAnimations.allowChildren,
-                    ],
-                    styles: [".mat-sort-header-container{display:flex;cursor:pointer;align-items:center}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-button{border:none;background:0 0;display:flex;align-items:center;padding:0;cursor:inherit;outline:0;font:inherit;color:currentColor}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-button,[mat-sort-header].cdk-program-focused .mat-sort-header-button{border-bottom:solid 1px currentColor}.mat-sort-header-button::-moz-focus-inner{border:0}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}\n"]
-                },] }
-    ];
-    MatSortHeader.ctorParameters = () => [
-        { type: MatSortHeaderIntl },
-        { type: ChangeDetectorRef },
-        { type: MatSort, decorators: [{ type: Optional }] },
-        { type: undefined, decorators: [{ type: Inject, args: ['MAT_SORT_HEADER_COLUMN_DEF',] }, { type: Optional }] },
-        { type: FocusMonitor },
-        { type: ElementRef }
-    ];
-    MatSortHeader.propDecorators = {
-        id: [{ type: Input, args: ['mat-sort-header',] }],
-        arrowPosition: [{ type: Input }],
-        start: [{ type: Input }],
-        disableClear: [{ type: Input }]
-    };
-    return MatSortHeader;
-})();
-export { MatSortHeader };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort-header.js","sourceRoot":"","sources":["../../../../../../src/material/sort/sort-header.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  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  ViewEncapsulation,\n  Inject,\n  ElementRef,\n  AfterViewInit,\n} from '@angular/core';\nimport {CanDisable, CanDisableCtor, mixinDisabled} from '@angular/material/core';\nimport {FocusMonitor} from '@angular/cdk/a11y';\nimport {merge, Subscription} from 'rxjs';\nimport {MatSort, MatSortable} from './sort';\nimport {matSortAnimations} from './sort-animations';\nimport {SortDirection} from './sort-direction';\nimport {getSortHeaderNotContainedWithinSortError} from './sort-errors';\nimport {MatSortHeaderIntl} from './sort-header-intl';\n\n\n// Boilerplate for applying mixins to the sort header.\n/** @docs-private */\nclass MatSortHeaderBase {}\nconst _MatSortHeaderMixinBase: CanDisableCtor & typeof MatSortHeaderBase =\n    mixinDisabled(MatSortHeaderBase);\n\n/**\n * Valid positions for the arrow to be in for its opacity and translation. If the state is a\n * sort direction, the position of the arrow will be above/below and opacity 0. If the state is\n * hint, the arrow will be in the center with a slight opacity. Active state means the arrow will\n * be fully opaque in the center.\n *\n * @docs-private\n */\nexport type ArrowViewState = SortDirection | 'hint' | 'active';\n\n/**\n * States describing the arrow's animated position (animating fromState to toState).\n * If the fromState is not defined, there will be no animated transition to the toState.\n * @docs-private\n */\nexport interface ArrowViewStateTransition {\n  fromState?: ArrowViewState;\n  toState: ArrowViewState;\n}\n\n/** Column definition associated with a `MatSortHeader`. */\ninterface MatSortHeaderColumnDef {\n  name: string;\n}\n\n/**\n * Applies sorting behavior (click to change sort) and styles to an element, including an\n * arrow to display the current sort direction.\n *\n * Must be provided with an id and contained within a parent MatSort directive.\n *\n * If used on header cells in a CdkTable, it will automatically default its id from its containing\n * column definition.\n */\n@Component({\n  selector: '[mat-sort-header]',\n  exportAs: 'matSortHeader',\n  templateUrl: 'sort-header.html',\n  styleUrls: ['sort-header.css'],\n  host: {\n    'class': 'mat-sort-header',\n    '(click)': '_handleClick()',\n    '(mouseenter)': '_setIndicatorHintVisible(true)',\n    '(mouseleave)': '_setIndicatorHintVisible(false)',\n    '[attr.aria-sort]': '_getAriaSortAttribute()',\n    '[class.mat-sort-header-disabled]': '_isDisabled()',\n  },\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  inputs: ['disabled'],\n  animations: [\n    matSortAnimations.indicator,\n    matSortAnimations.leftPointer,\n    matSortAnimations.rightPointer,\n    matSortAnimations.arrowOpacity,\n    matSortAnimations.arrowPosition,\n    matSortAnimations.allowChildren,\n  ]\n})\nexport class MatSortHeader extends _MatSortHeaderMixinBase\n    implements CanDisable, MatSortable, OnDestroy, OnInit, AfterViewInit {\n  private _rerenderSubscription: Subscription;\n\n  /**\n   * Flag set to true when the indicator should be displayed while the sort is not active. Used to\n   * provide an affordance that the header is sortable by showing on focus and hover.\n   */\n  _showIndicatorHint: boolean = false;\n\n  /**\n   * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`\n   * position through the animation. If animations are currently disabled, the fromState is removed\n   * so that there is no animation displayed.\n   */\n  _viewState: ArrowViewStateTransition;\n\n  /** The direction the arrow should be facing according to the current state. */\n  _arrowDirection: SortDirection = '';\n\n  /**\n   * Whether the view state animation should show the transition between the `from` and `to` states.\n   */\n  _disableViewStateAnimation = false;\n\n  /**\n   * ID of this sort header. If used within the context of a CdkColumnDef, this will default to\n   * the column's name.\n   */\n  @Input('mat-sort-header') id: string;\n\n  /** Sets the position of the arrow that displays when sorted. */\n  @Input() arrowPosition: 'before' | 'after' = 'after';\n\n  /** Overrides the sort start value of the containing MatSort for this MatSortable. */\n  @Input() start: 'asc' | 'desc';\n\n  /** Overrides the disable clear value of the containing MatSort for this MatSortable. */\n  @Input()\n  get disableClear(): boolean { return this._disableClear; }\n  set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }\n  private _disableClear: boolean;\n\n  constructor(public _intl: MatSortHeaderIntl,\n              changeDetectorRef: ChangeDetectorRef,\n              @Optional() public _sort: MatSort,\n              @Inject('MAT_SORT_HEADER_COLUMN_DEF') @Optional()\n                  public _columnDef: MatSortHeaderColumnDef,\n              private _focusMonitor: FocusMonitor,\n              private _elementRef: ElementRef<HTMLElement>) {\n    // Note that we use a string token for the `_columnDef`, because the value is provided both by\n    // `material/table` and `cdk/table` and we can't have the CDK depending on Material,\n    // and we want to avoid having the sort header depending on the CDK table because\n    // of this single reference.\n    super();\n\n    if (!_sort) {\n      throw getSortHeaderNotContainedWithinSortError();\n    }\n\n    this._rerenderSubscription = merge(_sort.sortChange, _sort._stateChanges, _intl.changes)\n        .subscribe(() => {\n          if (this._isSorted()) {\n            this._updateArrowDirection();\n          }\n\n          // If this header was recently active and now no longer sorted, animate away the arrow.\n          if (!this._isSorted() && this._viewState && this._viewState.toState === 'active') {\n            this._disableViewStateAnimation = false;\n            this._setAnimationTransitionState({fromState: 'active', toState: this._arrowDirection});\n          }\n\n          changeDetectorRef.markForCheck();\n        });\n  }\n\n  ngOnInit() {\n    if (!this.id && this._columnDef) {\n      this.id = this._columnDef.name;\n    }\n\n    // Initialize the direction of the arrow and set the view state to be immediately that state.\n    this._updateArrowDirection();\n    this._setAnimationTransitionState(\n        {toState: this._isSorted() ? 'active' : this._arrowDirection});\n\n    this._sort.register(this);\n  }\n\n  ngAfterViewInit() {\n    // We use the focus monitor because we also want to style\n    // things differently based on the focus origin.\n    this._focusMonitor.monitor(this._elementRef, true)\n        .subscribe(origin => this._setIndicatorHintVisible(!!origin));\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n    this._sort.deregister(this);\n    this._rerenderSubscription.unsubscribe();\n  }\n\n  /**\n   * Sets the \"hint\" state such that the arrow will be semi-transparently displayed as a hint to the\n   * user showing what the active sort will become. If set to false, the arrow will fade away.\n   */\n  _setIndicatorHintVisible(visible: boolean) {\n    // No-op if the sort header is disabled - should not make the hint visible.\n    if (this._isDisabled() && visible) { return; }\n\n    this._showIndicatorHint = visible;\n\n    if (!this._isSorted()) {\n      this._updateArrowDirection();\n      if (this._showIndicatorHint) {\n        this._setAnimationTransitionState({fromState: this._arrowDirection, toState: 'hint'});\n      } else {\n        this._setAnimationTransitionState({fromState: 'hint', toState: this._arrowDirection});\n      }\n    }\n  }\n\n  /**\n   * Sets the animation transition view state for the arrow's position and opacity. If the\n   * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that\n   * no animation appears.\n   */\n  _setAnimationTransitionState(viewState: ArrowViewStateTransition) {\n    this._viewState = viewState;\n\n    // If the animation for arrow position state (opacity/translation) should be disabled,\n    // remove the fromState so that it jumps right to the toState.\n    if (this._disableViewStateAnimation) {\n      this._viewState = {toState: viewState.toState};\n    }\n  }\n\n  /** Triggers the sort on this sort header and removes the indicator hint. */\n  _handleClick() {\n    if (this._isDisabled()) { return; }\n\n    this._sort.sort(this);\n\n    // Do not show the animation if the header was already shown in the right position.\n    if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {\n      this._disableViewStateAnimation = true;\n    }\n\n    // If the arrow is now sorted, animate the arrow into place. Otherwise, animate it away into\n    // the direction it is facing.\n    const viewState: ArrowViewStateTransition = this._isSorted() ?\n        {fromState: this._arrowDirection, toState: 'active'} :\n        {fromState: 'active', toState: this._arrowDirection};\n    this._setAnimationTransitionState(viewState);\n\n    this._showIndicatorHint = false;\n  }\n\n  /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */\n  _isSorted() {\n    return this._sort.active == this.id &&\n        (this._sort.direction === 'asc' || this._sort.direction === 'desc');\n  }\n\n  /** Returns the animation state for the arrow direction (indicator and pointers). */\n  _getArrowDirectionState() {\n    return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;\n  }\n\n  /** Returns the arrow position state (opacity, translation). */\n  _getArrowViewState() {\n    const fromState = this._viewState.fromState;\n    return (fromState ? `${fromState}-to-` : '') + this._viewState.toState;\n  }\n\n  /**\n   * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be\n   * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently\n   * active sorted direction. The reason this is updated through a function is because the direction\n   * should only be changed at specific times - when deactivated but the hint is displayed and when\n   * the sort is active and the direction changes. Otherwise the arrow's direction should linger\n   * in cases such as the sort becoming deactivated but we want to animate the arrow away while\n   * preserving its direction, even though the next sort direction is actually different and should\n   * only be changed once the arrow displays again (hint or activation).\n   */\n  _updateArrowDirection() {\n    this._arrowDirection = this._isSorted() ?\n        this._sort.direction :\n        (this.start || this._sort.start);\n  }\n\n  _isDisabled() {\n    return this._sort.disabled || this.disabled;\n  }\n\n  /**\n   * Gets the aria-sort attribute that should be applied to this sort header. If this header\n   * is not sorted, returns null so that the attribute is removed from the host element. Aria spec\n   * says that the aria-sort property should only be present on one header at a time, so removing\n   * ensures this is true.\n   */\n  _getAriaSortAttribute() {\n    if (!this._isSorted()) { return null; }\n\n    return this._sort.direction == 'asc' ? 'ascending' : 'descending';\n  }\n\n  /** Whether the arrow inside the sort header should be rendered. */\n  _renderArrow() {\n    return !this._isDisabled() || this._isSorted();\n  }\n\n  static ngAcceptInputType_disableClear: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}
+    /** Whether the arrow inside the sort header should be rendered. */
+    _renderArrow() {
+        return !this._isDisabled() || this._isSorted();
+    }
+}
+MatSortHeader.decorators = [
+    { type: Component, args: [{
+                selector: '[mat-sort-header]',
+                exportAs: 'matSortHeader',
+                template: "<!--\n  We set the `tabindex` on an element inside the table header, rather than the header itself,\n  because of a bug in NVDA where having a `tabindex` on a `th` breaks keyboard navigation in the\n  table (see https://github.com/nvaccess/nvda/issues/7718). This allows for the header to both\n  be focusable, and have screen readers read out its `aria-sort` state. We prefer this approach\n  over having a button with an `aria-label` inside the header, because the button's `aria-label`\n  will be read out as the user is navigating the table's cell (see #13012).\n\n  The approach is based off of: https://dequeuniversity.com/library/aria/tables/sf-sortable-grid\n-->\n<div class=\"mat-sort-header-container mat-focus-indicator\"\n     [class.mat-sort-header-sorted]=\"_isSorted()\"\n     [class.mat-sort-header-position-before]=\"arrowPosition == 'before'\"\n     [attr.tabindex]=\"_isDisabled() ? null : 0\"\n     role=\"button\">\n\n  <!--\n    TODO(crisbeto): this div isn't strictly necessary, but we have to keep it due to a large\n    number of screenshot diff failures. It should be removed eventually. Note that the difference\n    isn't visible with a shorter header, but once it breaks up into multiple lines, this element\n    causes it to be center-aligned, whereas removing it will keep the text to the left.\n  -->\n  <div class=\"mat-sort-header-content\">\n    <ng-content></ng-content>\n  </div>\n\n  <!-- Disable animations while a current animation is running -->\n  <div class=\"mat-sort-header-arrow\"\n       *ngIf=\"_renderArrow()\"\n       [@arrowOpacity]=\"_getArrowViewState()\"\n       [@arrowPosition]=\"_getArrowViewState()\"\n       [@allowChildren]=\"_getArrowDirectionState()\"\n       (@arrowPosition.start)=\"_disableViewStateAnimation = true\"\n       (@arrowPosition.done)=\"_disableViewStateAnimation = false\">\n    <div class=\"mat-sort-header-stem\"></div>\n    <div class=\"mat-sort-header-indicator\" [@indicator]=\"_getArrowDirectionState()\">\n      <div class=\"mat-sort-header-pointer-left\" [@leftPointer]=\"_getArrowDirectionState()\"></div>\n      <div class=\"mat-sort-header-pointer-right\" [@rightPointer]=\"_getArrowDirectionState()\"></div>\n      <div class=\"mat-sort-header-pointer-middle\"></div>\n    </div>\n  </div>\n</div>\n",
+                host: {
+                    'class': 'mat-sort-header',
+                    '(click)': '_handleClick()',
+                    '(keydown)': '_handleKeydown($event)',
+                    '(mouseenter)': '_setIndicatorHintVisible(true)',
+                    '(mouseleave)': '_setIndicatorHintVisible(false)',
+                    '[attr.aria-sort]': '_getAriaSortAttribute()',
+                    '[class.mat-sort-header-disabled]': '_isDisabled()',
+                },
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                inputs: ['disabled'],
+                animations: [
+                    matSortAnimations.indicator,
+                    matSortAnimations.leftPointer,
+                    matSortAnimations.rightPointer,
+                    matSortAnimations.arrowOpacity,
+                    matSortAnimations.arrowPosition,
+                    matSortAnimations.allowChildren,
+                ],
+                styles: [".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}\n"]
+            },] }
+];
+MatSortHeader.ctorParameters = () => [
+    { type: MatSortHeaderIntl },
+    { type: ChangeDetectorRef },
+    { type: MatSort, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Inject, args: ['MAT_SORT_HEADER_COLUMN_DEF',] }, { type: Optional }] },
+    { type: FocusMonitor },
+    { type: ElementRef }
+];
+MatSortHeader.propDecorators = {
+    id: [{ type: Input, args: ['mat-sort-header',] }],
+    arrowPosition: [{ type: Input }],
+    start: [{ type: Input }],
+    disableClear: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort-header.js","sourceRoot":"","sources":["../../../../../../src/material/sort/sort-header.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  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  ViewEncapsulation,\n  Inject,\n  ElementRef,\n  AfterViewInit,\n} from '@angular/core';\nimport {CanDisable, CanDisableCtor, mixinDisabled} from '@angular/material/core';\nimport {FocusMonitor} from '@angular/cdk/a11y';\nimport {ENTER, SPACE} from '@angular/cdk/keycodes';\nimport {merge, Subscription} from 'rxjs';\nimport {MatSort, MatSortable} from './sort';\nimport {matSortAnimations} from './sort-animations';\nimport {SortDirection} from './sort-direction';\nimport {getSortHeaderNotContainedWithinSortError} from './sort-errors';\nimport {MatSortHeaderIntl} from './sort-header-intl';\n\n\n// Boilerplate for applying mixins to the sort header.\n/** @docs-private */\nclass MatSortHeaderBase {}\nconst _MatSortHeaderMixinBase: CanDisableCtor & typeof MatSortHeaderBase =\n    mixinDisabled(MatSortHeaderBase);\n\n/**\n * Valid positions for the arrow to be in for its opacity and translation. If the state is a\n * sort direction, the position of the arrow will be above/below and opacity 0. If the state is\n * hint, the arrow will be in the center with a slight opacity. Active state means the arrow will\n * be fully opaque in the center.\n *\n * @docs-private\n */\nexport type ArrowViewState = SortDirection | 'hint' | 'active';\n\n/**\n * States describing the arrow's animated position (animating fromState to toState).\n * If the fromState is not defined, there will be no animated transition to the toState.\n * @docs-private\n */\nexport interface ArrowViewStateTransition {\n  fromState?: ArrowViewState;\n  toState: ArrowViewState;\n}\n\n/** Column definition associated with a `MatSortHeader`. */\ninterface MatSortHeaderColumnDef {\n  name: string;\n}\n\n/**\n * Applies sorting behavior (click to change sort) and styles to an element, including an\n * arrow to display the current sort direction.\n *\n * Must be provided with an id and contained within a parent MatSort directive.\n *\n * If used on header cells in a CdkTable, it will automatically default its id from its containing\n * column definition.\n */\n@Component({\n  selector: '[mat-sort-header]',\n  exportAs: 'matSortHeader',\n  templateUrl: 'sort-header.html',\n  styleUrls: ['sort-header.css'],\n  host: {\n    'class': 'mat-sort-header',\n    '(click)': '_handleClick()',\n    '(keydown)': '_handleKeydown($event)',\n    '(mouseenter)': '_setIndicatorHintVisible(true)',\n    '(mouseleave)': '_setIndicatorHintVisible(false)',\n    '[attr.aria-sort]': '_getAriaSortAttribute()',\n    '[class.mat-sort-header-disabled]': '_isDisabled()',\n  },\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  inputs: ['disabled'],\n  animations: [\n    matSortAnimations.indicator,\n    matSortAnimations.leftPointer,\n    matSortAnimations.rightPointer,\n    matSortAnimations.arrowOpacity,\n    matSortAnimations.arrowPosition,\n    matSortAnimations.allowChildren,\n  ]\n})\nexport class MatSortHeader extends _MatSortHeaderMixinBase\n    implements CanDisable, MatSortable, OnDestroy, OnInit, AfterViewInit {\n  private _rerenderSubscription: Subscription;\n\n  /**\n   * Flag set to true when the indicator should be displayed while the sort is not active. Used to\n   * provide an affordance that the header is sortable by showing on focus and hover.\n   */\n  _showIndicatorHint: boolean = false;\n\n  /**\n   * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`\n   * position through the animation. If animations are currently disabled, the fromState is removed\n   * so that there is no animation displayed.\n   */\n  _viewState: ArrowViewStateTransition;\n\n  /** The direction the arrow should be facing according to the current state. */\n  _arrowDirection: SortDirection = '';\n\n  /**\n   * Whether the view state animation should show the transition between the `from` and `to` states.\n   */\n  _disableViewStateAnimation = false;\n\n  /**\n   * ID of this sort header. If used within the context of a CdkColumnDef, this will default to\n   * the column's name.\n   */\n  @Input('mat-sort-header') id: string;\n\n  /** Sets the position of the arrow that displays when sorted. */\n  @Input() arrowPosition: 'before' | 'after' = 'after';\n\n  /** Overrides the sort start value of the containing MatSort for this MatSortable. */\n  @Input() start: 'asc' | 'desc';\n\n  /** Overrides the disable clear value of the containing MatSort for this MatSortable. */\n  @Input()\n  get disableClear(): boolean { return this._disableClear; }\n  set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }\n  private _disableClear: boolean;\n\n  constructor(public _intl: MatSortHeaderIntl,\n              changeDetectorRef: ChangeDetectorRef,\n              @Optional() public _sort: MatSort,\n              @Inject('MAT_SORT_HEADER_COLUMN_DEF') @Optional()\n                  public _columnDef: MatSortHeaderColumnDef,\n              private _focusMonitor: FocusMonitor,\n              private _elementRef: ElementRef<HTMLElement>) {\n    // Note that we use a string token for the `_columnDef`, because the value is provided both by\n    // `material/table` and `cdk/table` and we can't have the CDK depending on Material,\n    // and we want to avoid having the sort header depending on the CDK table because\n    // of this single reference.\n    super();\n\n    if (!_sort) {\n      throw getSortHeaderNotContainedWithinSortError();\n    }\n\n    this._rerenderSubscription = merge(_sort.sortChange, _sort._stateChanges, _intl.changes)\n        .subscribe(() => {\n          if (this._isSorted()) {\n            this._updateArrowDirection();\n          }\n\n          // If this header was recently active and now no longer sorted, animate away the arrow.\n          if (!this._isSorted() && this._viewState && this._viewState.toState === 'active') {\n            this._disableViewStateAnimation = false;\n            this._setAnimationTransitionState({fromState: 'active', toState: this._arrowDirection});\n          }\n\n          changeDetectorRef.markForCheck();\n        });\n  }\n\n  ngOnInit() {\n    if (!this.id && this._columnDef) {\n      this.id = this._columnDef.name;\n    }\n\n    // Initialize the direction of the arrow and set the view state to be immediately that state.\n    this._updateArrowDirection();\n    this._setAnimationTransitionState(\n        {toState: this._isSorted() ? 'active' : this._arrowDirection});\n\n    this._sort.register(this);\n  }\n\n  ngAfterViewInit() {\n    // We use the focus monitor because we also want to style\n    // things differently based on the focus origin.\n    this._focusMonitor.monitor(this._elementRef, true)\n        .subscribe(origin => this._setIndicatorHintVisible(!!origin));\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n    this._sort.deregister(this);\n    this._rerenderSubscription.unsubscribe();\n  }\n\n  /**\n   * Sets the \"hint\" state such that the arrow will be semi-transparently displayed as a hint to the\n   * user showing what the active sort will become. If set to false, the arrow will fade away.\n   */\n  _setIndicatorHintVisible(visible: boolean) {\n    // No-op if the sort header is disabled - should not make the hint visible.\n    if (this._isDisabled() && visible) { return; }\n\n    this._showIndicatorHint = visible;\n\n    if (!this._isSorted()) {\n      this._updateArrowDirection();\n      if (this._showIndicatorHint) {\n        this._setAnimationTransitionState({fromState: this._arrowDirection, toState: 'hint'});\n      } else {\n        this._setAnimationTransitionState({fromState: 'hint', toState: this._arrowDirection});\n      }\n    }\n  }\n\n  /**\n   * Sets the animation transition view state for the arrow's position and opacity. If the\n   * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that\n   * no animation appears.\n   */\n  _setAnimationTransitionState(viewState: ArrowViewStateTransition) {\n    this._viewState = viewState;\n\n    // If the animation for arrow position state (opacity/translation) should be disabled,\n    // remove the fromState so that it jumps right to the toState.\n    if (this._disableViewStateAnimation) {\n      this._viewState = {toState: viewState.toState};\n    }\n  }\n\n  /** Triggers the sort on this sort header and removes the indicator hint. */\n  _toggleOnInteraction() {\n\n    this._sort.sort(this);\n\n    // Do not show the animation if the header was already shown in the right position.\n    if (this._viewState.toState === 'hint' || this._viewState.toState === 'active') {\n      this._disableViewStateAnimation = true;\n    }\n\n    // If the arrow is now sorted, animate the arrow into place. Otherwise, animate it away into\n    // the direction it is facing.\n    const viewState: ArrowViewStateTransition = this._isSorted() ?\n        {fromState: this._arrowDirection, toState: 'active'} :\n        {fromState: 'active', toState: this._arrowDirection};\n    this._setAnimationTransitionState(viewState);\n\n    this._showIndicatorHint = false;\n  }\n\n  _handleClick() {\n    if (!this._isDisabled()) {\n      this._toggleOnInteraction();\n    }\n  }\n\n  _handleKeydown(event: KeyboardEvent) {\n    if (!this._isDisabled() && (event.keyCode === SPACE || event.keyCode === ENTER)) {\n      event.preventDefault();\n      this._toggleOnInteraction();\n    }\n  }\n\n  /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */\n  _isSorted() {\n    return this._sort.active == this.id &&\n        (this._sort.direction === 'asc' || this._sort.direction === 'desc');\n  }\n\n  /** Returns the animation state for the arrow direction (indicator and pointers). */\n  _getArrowDirectionState() {\n    return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;\n  }\n\n  /** Returns the arrow position state (opacity, translation). */\n  _getArrowViewState() {\n    const fromState = this._viewState.fromState;\n    return (fromState ? `${fromState}-to-` : '') + this._viewState.toState;\n  }\n\n  /**\n   * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be\n   * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently\n   * active sorted direction. The reason this is updated through a function is because the direction\n   * should only be changed at specific times - when deactivated but the hint is displayed and when\n   * the sort is active and the direction changes. Otherwise the arrow's direction should linger\n   * in cases such as the sort becoming deactivated but we want to animate the arrow away while\n   * preserving its direction, even though the next sort direction is actually different and should\n   * only be changed once the arrow displays again (hint or activation).\n   */\n  _updateArrowDirection() {\n    this._arrowDirection = this._isSorted() ?\n        this._sort.direction :\n        (this.start || this._sort.start);\n  }\n\n  _isDisabled() {\n    return this._sort.disabled || this.disabled;\n  }\n\n  /**\n   * Gets the aria-sort attribute that should be applied to this sort header. If this header\n   * is not sorted, returns null so that the attribute is removed from the host element. Aria spec\n   * says that the aria-sort property should only be present on one header at a time, so removing\n   * ensures this is true.\n   */\n  _getAriaSortAttribute() {\n    if (!this._isSorted()) {\n      return 'none';\n    }\n\n    return this._sort.direction == 'asc' ? 'ascending' : 'descending';\n  }\n\n  /** Whether the arrow inside the sort header should be rendered. */\n  _renderArrow() {\n    return !this._isDisabled() || this._isSorted();\n  }\n\n  static ngAcceptInputType_disableClear: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}

package/esm2015/sort/sort-module.js

@@ -10,18 +10,14 @@ import { MatSortHeader } from './sort-header';
 import { MatSort } from './sort';
 import { MAT_SORT_HEADER_INTL_PROVIDER } from './sort-header-intl';
 import { CommonModule } from '@angular/common';
-let MatSortModule = /** @class */ (() => {
-    class MatSortModule {
-    }
-    MatSortModule.decorators = [
-        { type: NgModule, args: [{
-                    imports: [CommonModule],
-                    exports: [MatSort, MatSortHeader],
-                    declarations: [MatSort, MatSortHeader],
-                    providers: [MAT_SORT_HEADER_INTL_PROVIDER]
-                },] }
-    ];
-    return MatSortModule;
-})();
-export { MatSortModule };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbWF0ZXJpYWwvc29ydC9zb3J0LW1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDNUMsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLFFBQVEsQ0FBQztBQUMvQixPQUFPLEVBQUMsNkJBQTZCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUNqRSxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFHN0M7SUFBQSxNQU1hLGFBQWE7OztnQkFOekIsUUFBUSxTQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsT0FBTyxFQUFFLGFBQWEsQ0FBQztvQkFDakMsWUFBWSxFQUFFLENBQUMsT0FBTyxFQUFFLGFBQWEsQ0FBQztvQkFDdEMsU0FBUyxFQUFFLENBQUMsNkJBQTZCLENBQUM7aUJBQzNDOztJQUMyQixvQkFBQztLQUFBO1NBQWhCLGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge01hdFNvcnRIZWFkZXJ9IGZyb20gJy4vc29ydC1oZWFkZXInO1xuaW1wb3J0IHtNYXRTb3J0fSBmcm9tICcuL3NvcnQnO1xuaW1wb3J0IHtNQVRfU09SVF9IRUFERVJfSU5UTF9QUk9WSURFUn0gZnJvbSAnLi9zb3J0LWhlYWRlci1pbnRsJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBleHBvcnRzOiBbTWF0U29ydCwgTWF0U29ydEhlYWRlcl0sXG4gIGRlY2xhcmF0aW9uczogW01hdFNvcnQsIE1hdFNvcnRIZWFkZXJdLFxuICBwcm92aWRlcnM6IFtNQVRfU09SVF9IRUFERVJfSU5UTF9QUk9WSURFUl1cbn0pXG5leHBvcnQgY2xhc3MgTWF0U29ydE1vZHVsZSB7fVxuIl19
+export class MatSortModule {
+}
+MatSortModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [CommonModule],
+                exports: [MatSort, MatSortHeader],
+                declarations: [MatSort, MatSortHeader],
+                providers: [MAT_SORT_HEADER_INTL_PROVIDER]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbWF0ZXJpYWwvc29ydC9zb3J0LW1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDNUMsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLFFBQVEsQ0FBQztBQUMvQixPQUFPLEVBQUMsNkJBQTZCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUNqRSxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFTN0MsTUFBTSxPQUFPLGFBQWE7OztZQU56QixRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO2dCQUN2QixPQUFPLEVBQUUsQ0FBQyxPQUFPLEVBQUUsYUFBYSxDQUFDO2dCQUNqQyxZQUFZLEVBQUUsQ0FBQyxPQUFPLEVBQUUsYUFBYSxDQUFDO2dCQUN0QyxTQUFTLEVBQUUsQ0FBQyw2QkFBNkIsQ0FBQzthQUMzQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TWF0U29ydEhlYWRlcn0gZnJvbSAnLi9zb3J0LWhlYWRlcic7XG5pbXBvcnQge01hdFNvcnR9IGZyb20gJy4vc29ydCc7XG5pbXBvcnQge01BVF9TT1JUX0hFQURFUl9JTlRMX1BST1ZJREVSfSBmcm9tICcuL3NvcnQtaGVhZGVyLWludGwnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtNYXRTb3J0LCBNYXRTb3J0SGVhZGVyXSxcbiAgZGVjbGFyYXRpb25zOiBbTWF0U29ydCwgTWF0U29ydEhlYWRlcl0sXG4gIHByb3ZpZGVyczogW01BVF9TT1JUX0hFQURFUl9JTlRMX1BST1ZJREVSXVxufSlcbmV4cG9ydCBjbGFzcyBNYXRTb3J0TW9kdWxlIHt9XG4iXX0=