@angular/cdk
Version:
Angular Material Component Development Kit
337 lines • 36.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/cdk/table/sticky-styler.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
*/
/**
* List of all possible directions that can be used for sticky positioning.
* \@docs-private
* @type {?}
*/
export const STICKY_DIRECTIONS = ['top', 'bottom', 'left', 'right'];
/**
* Applies and removes sticky positioning styles to the `CdkTable` rows and columns cells.
* \@docs-private
*/
export class StickyStyler {
/**
* @param {?} _isNativeHtmlTable Whether the sticky logic should be based on a table
* that uses the native `<table>` element.
* @param {?} _stickCellCss The CSS class that will be applied to every row/cell that has
* sticky positioning applied.
* @param {?} direction The directionality context of the table (ltr/rtl); affects column positioning
* by reversing left/right positions.
* @param {?=} _isBrowser Whether the table is currently being rendered on the server or the client.
*/
constructor(_isNativeHtmlTable, _stickCellCss, direction, _isBrowser = true) {
this._isNativeHtmlTable = _isNativeHtmlTable;
this._stickCellCss = _stickCellCss;
this.direction = direction;
this._isBrowser = _isBrowser;
}
/**
* Clears the sticky positioning styles from the row and its cells by resetting the `position`
* style, setting the zIndex to 0, and unsetting each provided sticky direction.
* @param {?} rows The list of rows that should be cleared from sticking in the provided directions
* @param {?} stickyDirections The directions that should no longer be set as sticky on the rows.
* @return {?}
*/
clearStickyPositioning(rows, stickyDirections) {
for (const row of rows) {
// If the row isn't an element (e.g. if it's an `ng-container`),
// it won't have inline styles or `children` so we skip it.
if (row.nodeType !== row.ELEMENT_NODE) {
continue;
}
this._removeStickyStyle(row, stickyDirections);
for (let i = 0; i < row.children.length; i++) {
/** @type {?} */
const cell = (/** @type {?} */ (row.children[i]));
this._removeStickyStyle(cell, stickyDirections);
}
}
}
/**
* Applies sticky left and right positions to the cells of each row according to the sticky
* states of the rendered column definitions.
* @param {?} rows The rows that should have its set of cells stuck according to the sticky states.
* @param {?} stickyStartStates A list of boolean states where each state represents whether the cell
* in this index position should be stuck to the start of the row.
* @param {?} stickyEndStates A list of boolean states where each state represents whether the cell
* in this index position should be stuck to the end of the row.
* @return {?}
*/
updateStickyColumns(rows, stickyStartStates, stickyEndStates) {
/** @type {?} */
const hasStickyColumns = stickyStartStates.some((/**
* @param {?} state
* @return {?}
*/
state => state)) || stickyEndStates.some((/**
* @param {?} state
* @return {?}
*/
state => state));
if (!rows.length || !hasStickyColumns || !this._isBrowser) {
return;
}
/** @type {?} */
const firstRow = rows[0];
/** @type {?} */
const numCells = firstRow.children.length;
/** @type {?} */
const cellWidths = this._getCellWidths(firstRow);
/** @type {?} */
const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);
/** @type {?} */
const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);
/** @type {?} */
const isRtl = this.direction === 'rtl';
for (const row of rows) {
for (let i = 0; i < numCells; i++) {
/** @type {?} */
const cell = (/** @type {?} */ (row.children[i]));
if (stickyStartStates[i]) {
this._addStickyStyle(cell, isRtl ? 'right' : 'left', startPositions[i]);
}
if (stickyEndStates[i]) {
this._addStickyStyle(cell, isRtl ? 'left' : 'right', endPositions[i]);
}
}
}
}
/**
* Applies sticky positioning to the row's cells if using the native table layout, and to the
* row itself otherwise.
* @param {?} rowsToStick The list of rows that should be stuck according to their corresponding
* sticky state and to the provided top or bottom position.
* @param {?} stickyStates A list of boolean states where each state represents whether the row
* should be stuck in the particular top or bottom position.
* @param {?} position The position direction in which the row should be stuck if that row should be
* sticky.
*
* @return {?}
*/
stickRows(rowsToStick, stickyStates, position) {
// Since we can't measure the rows on the server, we can't stick the rows properly.
if (!this._isBrowser) {
return;
}
// If positioning the rows to the bottom, reverse their order when evaluating the sticky
// position such that the last row stuck will be "bottom: 0px" and so on.
/** @type {?} */
const rows = position === 'bottom' ? rowsToStick.reverse() : rowsToStick;
/** @type {?} */
let stickyHeight = 0;
for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
if (!stickyStates[rowIndex]) {
continue;
}
/** @type {?} */
const row = rows[rowIndex];
if (this._isNativeHtmlTable) {
for (let j = 0; j < row.children.length; j++) {
/** @type {?} */
const cell = (/** @type {?} */ (row.children[j]));
this._addStickyStyle(cell, position, stickyHeight);
}
}
else {
// Flex does not respect the stick positioning on the cells, needs to be applied to the row.
// If this is applied on a native table, Safari causes the header to fly in wrong direction.
this._addStickyStyle(row, position, stickyHeight);
}
if (rowIndex === rows.length - 1) {
// prevent unnecessary reflow from getBoundingClientRect()
return;
}
stickyHeight += row.getBoundingClientRect().height;
}
}
/**
* When using the native table in Safari, sticky footer cells do not stick. The only way to stick
* footer rows is to apply sticky styling to the tfoot container. This should only be done if
* all footer rows are sticky. If not all footer rows are sticky, remove sticky positioning from
* the tfoot element.
* @param {?} tableElement
* @param {?} stickyStates
* @return {?}
*/
updateStickyFooterContainer(tableElement, stickyStates) {
if (!this._isNativeHtmlTable) {
return;
}
/** @type {?} */
const tfoot = (/** @type {?} */ (tableElement.querySelector('tfoot')));
if (stickyStates.some((/**
* @param {?} state
* @return {?}
*/
state => !state))) {
this._removeStickyStyle(tfoot, ['bottom']);
}
else {
this._addStickyStyle(tfoot, 'bottom', 0);
}
}
/**
* Removes the sticky style on the element by removing the sticky cell CSS class, re-evaluating
* the zIndex, removing each of the provided sticky directions, and removing the
* sticky position if there are no more directions.
* @param {?} element
* @param {?} stickyDirections
* @return {?}
*/
_removeStickyStyle(element, stickyDirections) {
for (const dir of stickyDirections) {
element.style[dir] = '';
}
element.style.zIndex = this._getCalculatedZIndex(element);
// If the element no longer has any more sticky directions, remove sticky positioning and
// the sticky CSS class.
/** @type {?} */
const hasDirection = STICKY_DIRECTIONS.some((/**
* @param {?} dir
* @return {?}
*/
dir => !!element.style[dir]));
if (!hasDirection) {
element.style.position = '';
element.classList.remove(this._stickCellCss);
}
}
/**
* Adds the sticky styling to the element by adding the sticky style class, changing position
* to be sticky (and -webkit-sticky), setting the appropriate zIndex, and adding a sticky
* direction and value.
* @param {?} element
* @param {?} dir
* @param {?} dirValue
* @return {?}
*/
_addStickyStyle(element, dir, dirValue) {
element.classList.add(this._stickCellCss);
element.style[dir] = `${dirValue}px`;
element.style.cssText += 'position: -webkit-sticky; position: sticky; ';
element.style.zIndex = this._getCalculatedZIndex(element);
}
/**
* Calculate what the z-index should be for the element, depending on what directions (top,
* bottom, left, right) have been set. It should be true that elements with a top direction
* should have the highest index since these are elements like a table header. If any of those
* elements are also sticky in another direction, then they should appear above other elements
* that are only sticky top (e.g. a sticky column on a sticky header). Bottom-sticky elements
* (e.g. footer rows) should then be next in the ordering such that they are below the header
* but above any non-sticky elements. Finally, left/right sticky elements (e.g. sticky columns)
* should minimally increment so that they are above non-sticky elements but below top and bottom
* elements.
* @param {?} element
* @return {?}
*/
_getCalculatedZIndex(element) {
/** @type {?} */
const zIndexIncrements = {
top: 100,
bottom: 10,
left: 1,
right: 1,
};
/** @type {?} */
let zIndex = 0;
// Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,
// loses the array generic type in the `for of`. But we *also* have to use `Array` because
// typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`
for (const dir of (/** @type {?} */ (STICKY_DIRECTIONS))) {
if (element.style[dir]) {
zIndex += zIndexIncrements[dir];
}
}
return zIndex ? `${zIndex}` : '';
}
/**
* Gets the widths for each cell in the provided row.
* @param {?} row
* @return {?}
*/
_getCellWidths(row) {
/** @type {?} */
const cellWidths = [];
/** @type {?} */
const firstRowCells = row.children;
for (let i = 0; i < firstRowCells.length; i++) {
/** @type {?} */
let cell = (/** @type {?} */ (firstRowCells[i]));
cellWidths.push(cell.getBoundingClientRect().width);
}
return cellWidths;
}
/**
* Determines the left and right positions of each sticky column cell, which will be the
* accumulation of all sticky column cell widths to the left and right, respectively.
* Non-sticky cells do not need to have a value set since their positions will not be applied.
* @param {?} widths
* @param {?} stickyStates
* @return {?}
*/
_getStickyStartColumnPositions(widths, stickyStates) {
/** @type {?} */
const positions = [];
/** @type {?} */
let nextPosition = 0;
for (let i = 0; i < widths.length; i++) {
if (stickyStates[i]) {
positions[i] = nextPosition;
nextPosition += widths[i];
}
}
return positions;
}
/**
* Determines the left and right positions of each sticky column cell, which will be the
* accumulation of all sticky column cell widths to the left and right, respectively.
* Non-sticky cells do not need to have a value set since their positions will not be applied.
* @param {?} widths
* @param {?} stickyStates
* @return {?}
*/
_getStickyEndColumnPositions(widths, stickyStates) {
/** @type {?} */
const positions = [];
/** @type {?} */
let nextPosition = 0;
for (let i = widths.length; i > 0; i--) {
if (stickyStates[i]) {
positions[i] = nextPosition;
nextPosition += widths[i];
}
}
return positions;
}
}
if (false) {
/**
* @type {?}
* @private
*/
StickyStyler.prototype._isNativeHtmlTable;
/**
* @type {?}
* @private
*/
StickyStyler.prototype._stickCellCss;
/** @type {?} */
StickyStyler.prototype.direction;
/**
* @type {?}
* @private
*/
StickyStyler.prototype._isBrowser;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sticky-styler.js","sourceRoot":"","sources":["../../../../../../src/cdk/table/sticky-styler.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\n/**\n * Directions that can be used when setting sticky positioning.\n * @docs-private\n */\nimport {Direction} from '@angular/cdk/bidi';\n\nexport type StickyDirection = 'top' | 'bottom' | 'left' | 'right';\n\n/**\n * List of all possible directions that can be used for sticky positioning.\n * @docs-private\n */\nexport const STICKY_DIRECTIONS: StickyDirection[] = ['top', 'bottom', 'left', 'right'];\n\n/**\n * Applies and removes sticky positioning styles to the `CdkTable` rows and columns cells.\n * @docs-private\n */\nexport class StickyStyler {\n  /**\n   * @param _isNativeHtmlTable Whether the sticky logic should be based on a table\n   *     that uses the native `<table>` element.\n   * @param _stickCellCss The CSS class that will be applied to every row/cell that has\n   *     sticky positioning applied.\n   * @param direction The directionality context of the table (ltr/rtl); affects column positioning\n   *     by reversing left/right positions.\n   * @param _isBrowser Whether the table is currently being rendered on the server or the client.\n   */\n  constructor(private _isNativeHtmlTable: boolean,\n              private _stickCellCss: string,\n              public direction: Direction,\n              private _isBrowser = true) { }\n\n  /**\n   * Clears the sticky positioning styles from the row and its cells by resetting the `position`\n   * style, setting the zIndex to 0, and unsetting each provided sticky direction.\n   * @param rows The list of rows that should be cleared from sticking in the provided directions\n   * @param stickyDirections The directions that should no longer be set as sticky on the rows.\n   */\n  clearStickyPositioning(rows: HTMLElement[], stickyDirections: StickyDirection[]) {\n    for (const row of rows) {\n      // If the row isn't an element (e.g. if it's an `ng-container`),\n      // it won't have inline styles or `children` so we skip it.\n      if (row.nodeType !== row.ELEMENT_NODE) {\n        continue;\n      }\n\n      this._removeStickyStyle(row, stickyDirections);\n\n      for (let i = 0; i < row.children.length; i++) {\n        const cell = row.children[i] as HTMLElement;\n        this._removeStickyStyle(cell, stickyDirections);\n      }\n    }\n  }\n\n  /**\n   * Applies sticky left and right positions to the cells of each row according to the sticky\n   * states of the rendered column definitions.\n   * @param rows The rows that should have its set of cells stuck according to the sticky states.\n   * @param stickyStartStates A list of boolean states where each state represents whether the cell\n   *     in this index position should be stuck to the start of the row.\n   * @param stickyEndStates A list of boolean states where each state represents whether the cell\n   *     in this index position should be stuck to the end of the row.\n   */\n  updateStickyColumns(\n      rows: HTMLElement[], stickyStartStates: boolean[], stickyEndStates: boolean[]) {\n    const hasStickyColumns =\n        stickyStartStates.some(state => state) || stickyEndStates.some(state => state);\n    if (!rows.length || !hasStickyColumns || !this._isBrowser) {\n      return;\n    }\n\n    const firstRow = rows[0];\n    const numCells = firstRow.children.length;\n    const cellWidths: number[] = this._getCellWidths(firstRow);\n\n    const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);\n    const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);\n    const isRtl = this.direction === 'rtl';\n\n    for (const row of rows) {\n      for (let i = 0; i < numCells; i++) {\n        const cell = row.children[i] as HTMLElement;\n        if (stickyStartStates[i]) {\n          this._addStickyStyle(cell, isRtl ? 'right' : 'left', startPositions[i]);\n        }\n\n        if (stickyEndStates[i]) {\n          this._addStickyStyle(cell, isRtl ? 'left' : 'right', endPositions[i]);\n        }\n      }\n    }\n  }\n\n  /**\n   * Applies sticky positioning to the row's cells if using the native table layout, and to the\n   * row itself otherwise.\n   * @param rowsToStick The list of rows that should be stuck according to their corresponding\n   *     sticky state and to the provided top or bottom position.\n   * @param stickyStates A list of boolean states where each state represents whether the row\n   *     should be stuck in the particular top or bottom position.\n   * @param position The position direction in which the row should be stuck if that row should be\n   *     sticky.\n   *\n   */\n  stickRows(rowsToStick: HTMLElement[], stickyStates: boolean[], position: 'top' | 'bottom') {\n    // Since we can't measure the rows on the server, we can't stick the rows properly.\n    if (!this._isBrowser) {\n      return;\n    }\n\n    // If positioning the rows to the bottom, reverse their order when evaluating the sticky\n    // position such that the last row stuck will be \"bottom: 0px\" and so on.\n    const rows = position === 'bottom' ? rowsToStick.reverse() : rowsToStick;\n\n    let stickyHeight = 0;\n    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {\n      if (!stickyStates[rowIndex]) {\n        continue;\n      }\n\n      const row = rows[rowIndex];\n      if (this._isNativeHtmlTable) {\n        for (let j = 0; j < row.children.length; j++) {\n          const cell = row.children[j] as HTMLElement;\n          this._addStickyStyle(cell, position, stickyHeight);\n        }\n      } else {\n        // Flex does not respect the stick positioning on the cells, needs to be applied to the row.\n        // If this is applied on a native table, Safari causes the header to fly in wrong direction.\n        this._addStickyStyle(row, position, stickyHeight);\n      }\n\n      if (rowIndex === rows.length - 1) {\n        // prevent unnecessary reflow from getBoundingClientRect()\n        return;\n      }\n      stickyHeight += row.getBoundingClientRect().height;\n    }\n  }\n\n  /**\n   * When using the native table in Safari, sticky footer cells do not stick. The only way to stick\n   * footer rows is to apply sticky styling to the tfoot container. This should only be done if\n   * all footer rows are sticky. If not all footer rows are sticky, remove sticky positioning from\n   * the tfoot element.\n   */\n  updateStickyFooterContainer(tableElement: Element, stickyStates: boolean[]) {\n    if (!this._isNativeHtmlTable) {\n      return;\n    }\n\n    const tfoot = tableElement.querySelector('tfoot')!;\n    if (stickyStates.some(state => !state)) {\n      this._removeStickyStyle(tfoot, ['bottom']);\n    } else {\n      this._addStickyStyle(tfoot, 'bottom', 0);\n    }\n  }\n\n  /**\n   * Removes the sticky style on the element by removing the sticky cell CSS class, re-evaluating\n   * the zIndex, removing each of the provided sticky directions, and removing the\n   * sticky position if there are no more directions.\n   */\n  _removeStickyStyle(element: HTMLElement, stickyDirections: StickyDirection[]) {\n    for (const dir of stickyDirections) {\n      element.style[dir] = '';\n    }\n    element.style.zIndex = this._getCalculatedZIndex(element);\n\n    // If the element no longer has any more sticky directions, remove sticky positioning and\n    // the sticky CSS class.\n    const hasDirection = STICKY_DIRECTIONS.some(dir => !!element.style[dir]);\n    if (!hasDirection) {\n      element.style.position = '';\n      element.classList.remove(this._stickCellCss);\n    }\n  }\n\n  /**\n   * Adds the sticky styling to the element by adding the sticky style class, changing position\n   * to be sticky (and -webkit-sticky), setting the appropriate zIndex, and adding a sticky\n   * direction and value.\n   */\n  _addStickyStyle(element: HTMLElement, dir: StickyDirection, dirValue: number) {\n    element.classList.add(this._stickCellCss);\n    element.style[dir] = `${dirValue}px`;\n    element.style.cssText += 'position: -webkit-sticky; position: sticky; ';\n    element.style.zIndex = this._getCalculatedZIndex(element);\n  }\n\n  /**\n   * Calculate what the z-index should be for the element, depending on what directions (top,\n   * bottom, left, right) have been set. It should be true that elements with a top direction\n   * should have the highest index since these are elements like a table header. If any of those\n   * elements are also sticky in another direction, then they should appear above other elements\n   * that are only sticky top (e.g. a sticky column on a sticky header). Bottom-sticky elements\n   * (e.g. footer rows) should then be next in the ordering such that they are below the header\n   * but above any non-sticky elements. Finally, left/right sticky elements (e.g. sticky columns)\n   * should minimally increment so that they are above non-sticky elements but below top and bottom\n   * elements.\n   */\n  _getCalculatedZIndex(element: HTMLElement): string {\n    const zIndexIncrements = {\n      top: 100,\n      bottom: 10,\n      left: 1,\n      right: 1,\n    };\n\n    let zIndex = 0;\n    // Use `Iterable` instead of `Array` because TypeScript, as of 3.6.3,\n    // loses the array generic type in the `for of`. But we *also* have to use `Array` because\n    // typescript won't iterate over an `Iterable` unless you compile with `--downlevelIteration`\n    for (const dir of STICKY_DIRECTIONS as Iterable<StickyDirection> & Array<StickyDirection>) {\n      if (element.style[dir]) {\n        zIndex += zIndexIncrements[dir];\n      }\n    }\n\n    return zIndex ? `${zIndex}` : '';\n  }\n\n  /** Gets the widths for each cell in the provided row. */\n  _getCellWidths(row: HTMLElement): number[] {\n    const cellWidths: number[] = [];\n    const firstRowCells = row.children;\n    for (let i = 0; i < firstRowCells.length; i++) {\n      let cell: HTMLElement = firstRowCells[i] as HTMLElement;\n      cellWidths.push(cell.getBoundingClientRect().width);\n    }\n\n    return cellWidths;\n  }\n\n  /**\n   * Determines the left and right positions of each sticky column cell, which will be the\n   * accumulation of all sticky column cell widths to the left and right, respectively.\n   * Non-sticky cells do not need to have a value set since their positions will not be applied.\n   */\n  _getStickyStartColumnPositions(widths: number[], stickyStates: boolean[]): number[] {\n    const positions: number[] = [];\n    let nextPosition = 0;\n\n    for (let i = 0; i < widths.length; i++) {\n      if (stickyStates[i]) {\n        positions[i] = nextPosition;\n        nextPosition += widths[i];\n      }\n    }\n\n    return positions;\n  }\n\n  /**\n   * Determines the left and right positions of each sticky column cell, which will be the\n   * accumulation of all sticky column cell widths to the left and right, respectively.\n   * Non-sticky cells do not need to have a value set since their positions will not be applied.\n   */\n  _getStickyEndColumnPositions(widths: number[], stickyStates: boolean[]): number[] {\n    const positions: number[] = [];\n    let nextPosition = 0;\n\n    for (let i = widths.length; i > 0; i--) {\n      if (stickyStates[i]) {\n        positions[i] = nextPosition;\n        nextPosition += widths[i];\n      }\n    }\n\n    return positions;\n  }\n}\n"]}