text: /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,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, } from '@angular/core';
  import { mixinDisabled } from '@angular/material/core';
  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
   */
  export class MatSortHeaderBase {
  }
  /** @type {?} */
  export 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
       */
      constructor(_intl, changeDetectorRef, _sort, _columnDef) {
          // 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;
          /**
           * 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.
       * @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() {
          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';
      }
  }
  MatSortHeader.decorators = [
      { type: Component, args: [{selector: '[mat-sort-header]',
                  exportAs: 'matSortHeader',
                  template: "<div class=\"mat-sort-header-container\" [class.mat-sort-header-sorted]=\"_isSorted()\" [class.mat-sort-header-position-before]=\"arrowPosition == 'before'\"><button class=\"mat-sort-header-button\" type=\"button\" [attr.disabled]=\"_isDisabled() || null\" [attr.aria-label]=\"_intl.sortButtonLabel(id)\" (focus)=\"_setIndicatorHintVisible(true)\" (blur)=\"_setIndicatorHintVisible(false)\"><ng-content></ng-content></button><div class=\"mat-sort-header-arrow\" [@arrowOpacity]=\"_getArrowViewState()\" [@arrowPosition]=\"_getArrowViewState()\" [@allowChildren]=\"_getArrowDirectionState()\" (@arrowPosition.start)=\"_disableViewStateAnimation = true\" (@arrowPosition.done)=\"_disableViewStateAnimation = false\"><div class=\"mat-sort-header-stem\"></div><div class=\"mat-sort-header-indicator\" [@indicator]=\"_getArrowDirectionState()\"><div class=\"mat-sort-header-pointer-left\" [@leftPointer]=\"_getArrowDirectionState()\"></div><div class=\"mat-sort-header-pointer-right\" [@rightPointer]=\"_getArrowDirectionState()\"></div><div class=\"mat-sort-header-pointer-middle\"></div></div></div></div>",
                  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-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}@media (-ms-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)}@media (-ms-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}@media (-ms-high-contrast:active){.mat-sort-header-pointer-left,.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}"],
                  host: {
                      '(click)': '_handleClick()',
                      '(mouseenter)': '_setIndicatorHintVisible(true)',
                      '(longpress)': '_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,
                  ]
              },] },
  ];
  /** @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 }] }
  ];
  MatSortHeader.propDecorators = {
      id: [{ type: Input, args: ['mat-sort-header',] }],
      arrowPosition: [{ type: Input }],
      start: [{ type: Input }],
      disableClear: [{ type: Input }]
  };
  if (false) {
      /**
       * @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;
  }
  //# sourceMappingURL=sort-header.js.map