@angular/material/esm2015/sort/sort-header.js

Angular Material

/**
 * @fileoverview added by tsickle
 * Generated from: src/material/sort/sort-header.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, Optional, ViewEncapsulation, Inject, ElementRef, } from '@angular/core';
import { mixinDisabled } from '@angular/material/core';
import { FocusMonitor } from '@angular/cdk/a11y';
import { merge } from 'rxjs';
import { MatSort } from './sort';
import { matSortAnimations } from './sort-animations';
import { getSortHeaderNotContainedWithinSortError } from './sort-errors';
import { MatSortHeaderIntl } from './sort-header-intl';
// Boilerplate for applying mixins to the sort header.
/**
 * \@docs-private
 */
class MatSortHeaderBase {
}
/** @type {?} */
const _MatSortHeaderMixinBase = mixinDisabled(MatSortHeaderBase);
/**
 * States describing the arrow's animated position (animating fromState to toState).
 * If the fromState is not defined, there will be no animated transition to the toState.
 * \@docs-private
 * @record
 */
export function ArrowViewStateTransition() { }
if (false) {
    /** @type {?|undefined} */
    ArrowViewStateTransition.prototype.fromState;
    /** @type {?} */
    ArrowViewStateTransition.prototype.toState;
}
/**
 * Column definition associated with a `MatSortHeader`.
 * @record
 */
function MatSortHeaderColumnDef() { }
if (false) {
    /** @type {?} */
    MatSortHeaderColumnDef.prototype.name;
}
/**
 * Applies sorting behavior (click to change sort) and styles to an element, including an
 * arrow to display the current sort direction.
 *
 * Must be provided with an id and contained within a parent MatSort directive.
 *
 * If used on header cells in a CdkTable, it will automatically default its id from its containing
 * column definition.
 */
export class MatSortHeader extends _MatSortHeaderMixinBase {
    /**
     * @param {?} _intl
     * @param {?} changeDetectorRef
     * @param {?} _sort
     * @param {?} _columnDef
     * @param {?=} _focusMonitor
     * @param {?=} _elementRef
     */
    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((/**
         * @return {?}
         */
        () => {
            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();
        }));
        if (_focusMonitor && _elementRef) {
            // We use the focus monitor because we also want to style
            // things differently based on the focus origin.
            _focusMonitor.monitor(_elementRef, true)
                .subscribe((/**
             * @param {?} origin
             * @return {?}
             */
            origin => this._setIndicatorHintVisible(!!origin)));
        }
    }
    /**
     * Overrides the disable clear value of the containing MatSort for this MatSortable.
     * @return {?}
     */
    get disableClear() { return this._disableClear; }
    /**
     * @param {?} v
     * @return {?}
     */
    set disableClear(v) { this._disableClear = coerceBooleanProperty(v); }
    /**
     * @return {?}
     */
    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);
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        // @breaking-change 10.0.0 Remove null check for _focusMonitor and _elementRef.
        if (this._focusMonitor && this._elementRef) {
            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.
     * @param {?} visible
     * @return {?}
     */
    _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 });
            }
        }
    }
    /**
     * 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.
     * @param {?} viewState
     * @return {?}
     */
    _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 };
        }
    }
    /**
     * Triggers the sort on this sort header and removes the indicator hint.
     * @return {?}
     */
    _handleClick() {
        if (this._isDisabled()) {
            return;
        }
        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 the arrow is now sorted, animate the arrow into place. Otherwise, animate it away into
        // the direction it is facing.
        /** @type {?} */
        const viewState = this._isSorted() ?
            { fromState: this._arrowDirection, toState: 'active' } :
            { fromState: 'active', toState: this._arrowDirection };
        this._setAnimationTransitionState(viewState);
        this._showIndicatorHint = false;
    }
    /**
     * Whether this MatSortHeader is currently sorted in either ascending or descending order.
     * @return {?}
     */
    _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).
     * @return {?}
     */
    _getArrowDirectionState() {
        return `${this._isSorted() ? 'active-' : ''}${this._arrowDirection}`;
    }
    /**
     * Returns the arrow position state (opacity, translation).
     * @return {?}
     */
    _getArrowViewState() {
        /** @type {?} */
        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).
     * @return {?}
     */
    _updateArrowDirection() {
        this._arrowDirection = this._isSorted() ?
            this._sort.direction :
            (this.start || this._sort.start);
    }
    /**
     * @return {?}
     */
    _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.
     * @return {?}
     */
    _getAriaSortAttribute() {
        if (!this._isSorted()) {
            return null;
        }
        return this._sort.direction == 'asc' ? 'ascending' : 'descending';
    }
    /**
     * Whether the arrow inside the sort header should be rendered.
     * @return {?}
     */
    _renderArrow() {
        return !this._isDisabled() || this._isSorted();
    }
}
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\" 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"]
            }] }
];
/** @nocollapse */
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 }]
};
if (false) {
    /** @type {?} */
    MatSortHeader.ngAcceptInputType_disableClear;
    /** @type {?} */
    MatSortHeader.ngAcceptInputType_disabled;
    /**
     * @type {?}
     * @private
     */
    MatSortHeader.prototype._rerenderSubscription;
    /**
     * 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.
     * @type {?}
     */
    MatSortHeader.prototype._showIndicatorHint;
    /**
     * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`
     * position through the animation. If animations are currently disabled, the fromState is removed
     * so that there is no animation displayed.
     * @type {?}
     */
    MatSortHeader.prototype._viewState;
    /**
     * The direction the arrow should be facing according to the current state.
     * @type {?}
     */
    MatSortHeader.prototype._arrowDirection;
    /**
     * Whether the view state animation should show the transition between the `from` and `to` states.
     * @type {?}
     */
    MatSortHeader.prototype._disableViewStateAnimation;
    /**
     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
     * the column's name.
     * @type {?}
     */
    MatSortHeader.prototype.id;
    /**
     * Sets the position of the arrow that displays when sorted.
     * @type {?}
     */
    MatSortHeader.prototype.arrowPosition;
    /**
     * Overrides the sort start value of the containing MatSort for this MatSortable.
     * @type {?}
     */
    MatSortHeader.prototype.start;
    /**
     * @type {?}
     * @private
     */
    MatSortHeader.prototype._disableClear;
    /** @type {?} */
    MatSortHeader.prototype._intl;
    /** @type {?} */
    MatSortHeader.prototype._sort;
    /** @type {?} */
    MatSortHeader.prototype._columnDef;
    /**
     * @deprecated _focusMonitor and _elementRef to become required parameters.
     * \@breaking-change 10.0.0
     * @type {?}
     * @private
     */
    MatSortHeader.prototype._focusMonitor;
    /**
     * @type {?}
     * @private
     */
    MatSortHeader.prototype._elementRef;
}
//# 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} 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 {\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              /**\n               * @deprecated _focusMonitor and _elementRef to become required parameters.\n               * @breaking-change 10.0.0\n               */\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    if (_focusMonitor && _elementRef) {\n      // We use the focus monitor because we also want to style\n      // things differently based on the focus origin.\n      _focusMonitor.monitor(_elementRef, true)\n          .subscribe(origin => this._setIndicatorHintVisible(!!origin));\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  ngOnDestroy() {\n    // @breaking-change 10.0.0 Remove null check for _focusMonitor and _elementRef.\n    if (this._focusMonitor && this._elementRef) {\n      this._focusMonitor.stopMonitoring(this._elementRef);\n    }\n\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"]}