@kato-lee/cdk 14.2.7

package/esm2020/table/sticky-styler.mjs

@@ -0,0 +1,345 @@
+/**
+ * @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
+ */
+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.
+     * @param _needsPositionStickyOnElement Whether we need to specify position: sticky on cells
+     *     using inline styles. If false, it is assumed that position: sticky is included in
+     *     the component stylesheet for _stickCellCss.
+     * @param _positionListener A listener that is notified of changes to sticky rows/columns
+     *     and their dimensions.
+     */
+    constructor(_isNativeHtmlTable, _stickCellCss, direction, _coalescedStyleScheduler, _isBrowser = true, _needsPositionStickyOnElement = true, _positionListener) {
+        this._isNativeHtmlTable = _isNativeHtmlTable;
+        this._stickCellCss = _stickCellCss;
+        this.direction = direction;
+        this._coalescedStyleScheduler = _coalescedStyleScheduler;
+        this._isBrowser = _isBrowser;
+        this._needsPositionStickyOnElement = _needsPositionStickyOnElement;
+        this._positionListener = _positionListener;
+        this._cachedCellWidths = [];
+        this._borderCellCss = {
+            'top': `${_stickCellCss}-border-elem-top`,
+            'bottom': `${_stickCellCss}-border-elem-bottom`,
+            'left': `${_stickCellCss}-border-elem-left`,
+            'right': `${_stickCellCss}-border-elem-right`,
+        };
+    }
+    /**
+     * 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.
+     */
+    clearStickyPositioning(rows, stickyDirections) {
+        const elementsToClear = [];
+        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;
+            }
+            elementsToClear.push(row);
+            for (let i = 0; i < row.children.length; i++) {
+                elementsToClear.push(row.children[i]);
+            }
+        }
+        // Coalesce with sticky row/column updates (and potentially other changes like column resize).
+        this._coalescedStyleScheduler.schedule(() => {
+            for (const element of elementsToClear) {
+                this._removeStickyStyle(element, 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.
+     * @param recalculateCellWidths Whether the sticky styler should recalculate the width of each
+     *     column cell. If `false` cached widths will be used instead.
+     */
+    updateStickyColumns(rows, stickyStartStates, stickyEndStates, recalculateCellWidths = true) {
+        if (!rows.length ||
+            !this._isBrowser ||
+            !(stickyStartStates.some(state => state) || stickyEndStates.some(state => state))) {
+            if (this._positionListener) {
+                this._positionListener.stickyColumnsUpdated({ sizes: [] });
+                this._positionListener.stickyEndColumnsUpdated({ sizes: [] });
+            }
+            return;
+        }
+        const firstRow = rows[0];
+        const numCells = firstRow.children.length;
+        const cellWidths = this._getCellWidths(firstRow, recalculateCellWidths);
+        const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);
+        const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);
+        const lastStickyStart = stickyStartStates.lastIndexOf(true);
+        const firstStickyEnd = stickyEndStates.indexOf(true);
+        // Coalesce with sticky row updates (and potentially other changes like column resize).
+        this._coalescedStyleScheduler.schedule(() => {
+            const isRtl = this.direction === 'rtl';
+            const start = isRtl ? 'right' : 'left';
+            const end = isRtl ? 'left' : 'right';
+            for (const row of rows) {
+                for (let i = 0; i < numCells; i++) {
+                    const cell = row.children[i];
+                    if (stickyStartStates[i]) {
+                        this._addStickyStyle(cell, start, startPositions[i], i === lastStickyStart);
+                    }
+                    if (stickyEndStates[i]) {
+                        this._addStickyStyle(cell, end, endPositions[i], i === firstStickyEnd);
+                    }
+                }
+            }
+            if (this._positionListener) {
+                this._positionListener.stickyColumnsUpdated({
+                    sizes: lastStickyStart === -1
+                        ? []
+                        : cellWidths
+                            .slice(0, lastStickyStart + 1)
+                            .map((width, index) => (stickyStartStates[index] ? width : null)),
+                });
+                this._positionListener.stickyEndColumnsUpdated({
+                    sizes: firstStickyEnd === -1
+                        ? []
+                        : cellWidths
+                            .slice(firstStickyEnd)
+                            .map((width, index) => (stickyEndStates[index + firstStickyEnd] ? width : null))
+                            .reverse(),
+                });
+            }
+        });
+    }
+    /**
+     * 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.
+     *
+     */
+    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. Note that the
+        // sticky states need to be reversed as well.
+        const rows = position === 'bottom' ? rowsToStick.slice().reverse() : rowsToStick;
+        const states = position === 'bottom' ? stickyStates.slice().reverse() : stickyStates;
+        // Measure row heights all at once before adding sticky styles to reduce layout thrashing.
+        const stickyOffsets = [];
+        const stickyCellHeights = [];
+        const elementsToStick = [];
+        for (let rowIndex = 0, stickyOffset = 0; rowIndex < rows.length; rowIndex++) {
+            if (!states[rowIndex]) {
+                continue;
+            }
+            stickyOffsets[rowIndex] = stickyOffset;
+            const row = rows[rowIndex];
+            elementsToStick[rowIndex] = this._isNativeHtmlTable
+                ? Array.from(row.children)
+                : [row];
+            const height = row.getBoundingClientRect().height;
+            stickyOffset += height;
+            stickyCellHeights[rowIndex] = height;
+        }
+        const borderedRowIndex = states.lastIndexOf(true);
+        // Coalesce with other sticky row updates (top/bottom), sticky columns updates
+        // (and potentially other changes like column resize).
+        this._coalescedStyleScheduler.schedule(() => {
+            for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                if (!states[rowIndex]) {
+                    continue;
+                }
+                const offset = stickyOffsets[rowIndex];
+                const isBorderedRowIndex = rowIndex === borderedRowIndex;
+                for (const element of elementsToStick[rowIndex]) {
+                    this._addStickyStyle(element, position, offset, isBorderedRowIndex);
+                }
+            }
+            if (position === 'top') {
+                this._positionListener?.stickyHeaderRowsUpdated({
+                    sizes: stickyCellHeights,
+                    offsets: stickyOffsets,
+                    elements: elementsToStick,
+                });
+            }
+            else {
+                this._positionListener?.stickyFooterRowsUpdated({
+                    sizes: stickyCellHeights,
+                    offsets: stickyOffsets,
+                    elements: elementsToStick,
+                });
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    updateStickyFooterContainer(tableElement, stickyStates) {
+        if (!this._isNativeHtmlTable) {
+            return;
+        }
+        const tfoot = tableElement.querySelector('tfoot');
+        // Coalesce with other sticky updates (and potentially other changes like column resize).
+        this._coalescedStyleScheduler.schedule(() => {
+            if (stickyStates.some(state => !state)) {
+                this._removeStickyStyle(tfoot, ['bottom']);
+            }
+            else {
+                this._addStickyStyle(tfoot, 'bottom', 0, false);
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    _removeStickyStyle(element, stickyDirections) {
+        for (const dir of stickyDirections) {
+            element.style[dir] = '';
+            element.classList.remove(this._borderCellCss[dir]);
+        }
+        // If the element no longer has any more sticky directions, remove sticky positioning and
+        // the sticky CSS class.
+        // Short-circuit checking element.style[dir] for stickyDirections as they
+        // were already removed above.
+        const hasDirection = STICKY_DIRECTIONS.some(dir => stickyDirections.indexOf(dir) === -1 && element.style[dir]);
+        if (hasDirection) {
+            element.style.zIndex = this._getCalculatedZIndex(element);
+        }
+        else {
+            // When not hasDirection, _getCalculatedZIndex will always return ''.
+            element.style.zIndex = '';
+            if (this._needsPositionStickyOnElement) {
+                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.
+     */
+    _addStickyStyle(element, dir, dirValue, isBorderElement) {
+        element.classList.add(this._stickCellCss);
+        if (isBorderElement) {
+            element.classList.add(this._borderCellCss[dir]);
+        }
+        element.style[dir] = `${dirValue}px`;
+        element.style.zIndex = this._getCalculatedZIndex(element);
+        if (this._needsPositionStickyOnElement) {
+            element.style.cssText += 'position: -webkit-sticky; position: sticky; ';
+        }
+    }
+    /**
+     * 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.
+     */
+    _getCalculatedZIndex(element) {
+        const zIndexIncrements = {
+            top: 100,
+            bottom: 10,
+            left: 1,
+            right: 1,
+        };
+        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 STICKY_DIRECTIONS) {
+            if (element.style[dir]) {
+                zIndex += zIndexIncrements[dir];
+            }
+        }
+        return zIndex ? `${zIndex}` : '';
+    }
+    /** Gets the widths for each cell in the provided row. */
+    _getCellWidths(row, recalculateCellWidths = true) {
+        if (!recalculateCellWidths && this._cachedCellWidths.length) {
+            return this._cachedCellWidths;
+        }
+        const cellWidths = [];
+        const firstRowCells = row.children;
+        for (let i = 0; i < firstRowCells.length; i++) {
+            let cell = firstRowCells[i];
+            cellWidths.push(cell.getBoundingClientRect().width);
+        }
+        this._cachedCellWidths = cellWidths;
+        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.
+     */
+    _getStickyStartColumnPositions(widths, stickyStates) {
+        const positions = [];
+        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.
+     */
+    _getStickyEndColumnPositions(widths, stickyStates) {
+        const positions = [];
+        let nextPosition = 0;
+        for (let i = widths.length; i > 0; i--) {
+            if (stickyStates[i]) {
+                positions[i] = nextPosition;
+                nextPosition += widths[i];
+            }
+        }
+        return positions;
+    }
+}
+//# 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';\nimport {_CoalescedStyleScheduler} from './coalesced-style-scheduler';\nimport {StickyPositioningListener} from './sticky-position-listener';\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  private _cachedCellWidths: number[] = [];\n  private readonly _borderCellCss: Readonly<{[d in StickyDirection]: string}>;\n\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   * @param _needsPositionStickyOnElement Whether we need to specify position: sticky on cells\n   *     using inline styles. If false, it is assumed that position: sticky is included in\n   *     the component stylesheet for _stickCellCss.\n   * @param _positionListener A listener that is notified of changes to sticky rows/columns\n   *     and their dimensions.\n   */\n  constructor(\n    private _isNativeHtmlTable: boolean,\n    private _stickCellCss: string,\n    public direction: Direction,\n    private _coalescedStyleScheduler: _CoalescedStyleScheduler,\n    private _isBrowser = true,\n    private readonly _needsPositionStickyOnElement = true,\n    private readonly _positionListener?: StickyPositioningListener,\n  ) {\n    this._borderCellCss = {\n      'top': `${_stickCellCss}-border-elem-top`,\n      'bottom': `${_stickCellCss}-border-elem-bottom`,\n      'left': `${_stickCellCss}-border-elem-left`,\n      'right': `${_stickCellCss}-border-elem-right`,\n    };\n  }\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    const elementsToClear: HTMLElement[] = [];\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      elementsToClear.push(row);\n      for (let i = 0; i < row.children.length; i++) {\n        elementsToClear.push(row.children[i] as HTMLElement);\n      }\n    }\n\n    // Coalesce with sticky row/column updates (and potentially other changes like column resize).\n    this._coalescedStyleScheduler.schedule(() => {\n      for (const element of elementsToClear) {\n        this._removeStickyStyle(element, 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   * @param recalculateCellWidths Whether the sticky styler should recalculate the width of each\n   *     column cell. If `false` cached widths will be used instead.\n   */\n  updateStickyColumns(\n    rows: HTMLElement[],\n    stickyStartStates: boolean[],\n    stickyEndStates: boolean[],\n    recalculateCellWidths = true,\n  ) {\n    if (\n      !rows.length ||\n      !this._isBrowser ||\n      !(stickyStartStates.some(state => state) || stickyEndStates.some(state => state))\n    ) {\n      if (this._positionListener) {\n        this._positionListener.stickyColumnsUpdated({sizes: []});\n        this._positionListener.stickyEndColumnsUpdated({sizes: []});\n      }\n\n      return;\n    }\n\n    const firstRow = rows[0];\n    const numCells = firstRow.children.length;\n    const cellWidths: number[] = this._getCellWidths(firstRow, recalculateCellWidths);\n\n    const startPositions = this._getStickyStartColumnPositions(cellWidths, stickyStartStates);\n    const endPositions = this._getStickyEndColumnPositions(cellWidths, stickyEndStates);\n\n    const lastStickyStart = stickyStartStates.lastIndexOf(true);\n    const firstStickyEnd = stickyEndStates.indexOf(true);\n\n    // Coalesce with sticky row updates (and potentially other changes like column resize).\n    this._coalescedStyleScheduler.schedule(() => {\n      const isRtl = this.direction === 'rtl';\n      const start = isRtl ? 'right' : 'left';\n      const end = isRtl ? 'left' : 'right';\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, start, startPositions[i], i === lastStickyStart);\n          }\n\n          if (stickyEndStates[i]) {\n            this._addStickyStyle(cell, end, endPositions[i], i === firstStickyEnd);\n          }\n        }\n      }\n\n      if (this._positionListener) {\n        this._positionListener.stickyColumnsUpdated({\n          sizes:\n            lastStickyStart === -1\n              ? []\n              : cellWidths\n                  .slice(0, lastStickyStart + 1)\n                  .map((width, index) => (stickyStartStates[index] ? width : null)),\n        });\n        this._positionListener.stickyEndColumnsUpdated({\n          sizes:\n            firstStickyEnd === -1\n              ? []\n              : cellWidths\n                  .slice(firstStickyEnd)\n                  .map((width, index) => (stickyEndStates[index + firstStickyEnd] ? width : null))\n                  .reverse(),\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. Note that the\n    // sticky states need to be reversed as well.\n    const rows = position === 'bottom' ? rowsToStick.slice().reverse() : rowsToStick;\n    const states = position === 'bottom' ? stickyStates.slice().reverse() : stickyStates;\n\n    // Measure row heights all at once before adding sticky styles to reduce layout thrashing.\n    const stickyOffsets: number[] = [];\n    const stickyCellHeights: (number | undefined)[] = [];\n    const elementsToStick: HTMLElement[][] = [];\n    for (let rowIndex = 0, stickyOffset = 0; rowIndex < rows.length; rowIndex++) {\n      if (!states[rowIndex]) {\n        continue;\n      }\n\n      stickyOffsets[rowIndex] = stickyOffset;\n      const row = rows[rowIndex];\n      elementsToStick[rowIndex] = this._isNativeHtmlTable\n        ? (Array.from(row.children) as HTMLElement[])\n        : [row];\n\n      const height = row.getBoundingClientRect().height;\n      stickyOffset += height;\n      stickyCellHeights[rowIndex] = height;\n    }\n\n    const borderedRowIndex = states.lastIndexOf(true);\n\n    // Coalesce with other sticky row updates (top/bottom), sticky columns updates\n    // (and potentially other changes like column resize).\n    this._coalescedStyleScheduler.schedule(() => {\n      for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {\n        if (!states[rowIndex]) {\n          continue;\n        }\n\n        const offset = stickyOffsets[rowIndex];\n        const isBorderedRowIndex = rowIndex === borderedRowIndex;\n        for (const element of elementsToStick[rowIndex]) {\n          this._addStickyStyle(element, position, offset, isBorderedRowIndex);\n        }\n      }\n\n      if (position === 'top') {\n        this._positionListener?.stickyHeaderRowsUpdated({\n          sizes: stickyCellHeights,\n          offsets: stickyOffsets,\n          elements: elementsToStick,\n        });\n      } else {\n        this._positionListener?.stickyFooterRowsUpdated({\n          sizes: stickyCellHeights,\n          offsets: stickyOffsets,\n          elements: elementsToStick,\n        });\n      }\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\n    // Coalesce with other sticky updates (and potentially other changes like column resize).\n    this._coalescedStyleScheduler.schedule(() => {\n      if (stickyStates.some(state => !state)) {\n        this._removeStickyStyle(tfoot, ['bottom']);\n      } else {\n        this._addStickyStyle(tfoot, 'bottom', 0, false);\n      }\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      element.classList.remove(this._borderCellCss[dir]);\n    }\n\n    // If the element no longer has any more sticky directions, remove sticky positioning and\n    // the sticky CSS class.\n    // Short-circuit checking element.style[dir] for stickyDirections as they\n    // were already removed above.\n    const hasDirection = STICKY_DIRECTIONS.some(\n      dir => stickyDirections.indexOf(dir) === -1 && element.style[dir],\n    );\n    if (hasDirection) {\n      element.style.zIndex = this._getCalculatedZIndex(element);\n    } else {\n      // When not hasDirection, _getCalculatedZIndex will always return ''.\n      element.style.zIndex = '';\n      if (this._needsPositionStickyOnElement) {\n        element.style.position = '';\n      }\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(\n    element: HTMLElement,\n    dir: StickyDirection,\n    dirValue: number,\n    isBorderElement: boolean,\n  ) {\n    element.classList.add(this._stickCellCss);\n    if (isBorderElement) {\n      element.classList.add(this._borderCellCss[dir]);\n    }\n    element.style[dir] = `${dirValue}px`;\n    element.style.zIndex = this._getCalculatedZIndex(element);\n    if (this._needsPositionStickyOnElement) {\n      element.style.cssText += 'position: -webkit-sticky; position: sticky; ';\n    }\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> & 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, recalculateCellWidths = true): number[] {\n    if (!recalculateCellWidths && this._cachedCellWidths.length) {\n      return this._cachedCellWidths;\n    }\n\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    this._cachedCellWidths = cellWidths;\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"]}

package/esm2020/table/table-errors.mjs

@@ -0,0 +1,67 @@
+/**
+ * @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
+ */
+/**
+ * Returns an error to be thrown when attempting to find an nonexistent column.
+ * @param id Id whose lookup failed.
+ * @docs-private
+ */
+export function getTableUnknownColumnError(id) {
+    return Error(`Could not find column with id "${id}".`);
+}
+/**
+ * Returns an error to be thrown when two column definitions have the same name.
+ * @docs-private
+ */
+export function getTableDuplicateColumnNameError(name) {
+    return Error(`Duplicate column definition name provided: "${name}".`);
+}
+/**
+ * Returns an error to be thrown when there are multiple rows that are missing a when function.
+ * @docs-private
+ */
+export function getTableMultipleDefaultRowDefsError() {
+    return Error(`There can only be one default row without a when predicate function.`);
+}
+/**
+ * Returns an error to be thrown when there are no matching row defs for a particular set of data.
+ * @docs-private
+ */
+export function getTableMissingMatchingRowDefError(data) {
+    return Error(`Could not find a matching row definition for the` +
+        `provided row data: ${JSON.stringify(data)}`);
+}
+/**
+ * Returns an error to be thrown when there is no row definitions present in the content.
+ * @docs-private
+ */
+export function getTableMissingRowDefsError() {
+    return Error('Missing definitions for header, footer, and row; ' +
+        'cannot determine which columns should be rendered.');
+}
+/**
+ * Returns an error to be thrown when the data source does not match the compatible types.
+ * @docs-private
+ */
+export function getTableUnknownDataSourceError() {
+    return Error(`Provided data source did not match an array, Observable, or DataSource`);
+}
+/**
+ * Returns an error to be thrown when the text column cannot find a parent table to inject.
+ * @docs-private
+ */
+export function getTableTextColumnMissingParentTableError() {
+    return Error(`Text column could not find a parent table for registration.`);
+}
+/**
+ * Returns an error to be thrown when a table text column doesn't have a name.
+ * @docs-private
+ */
+export function getTableTextColumnMissingNameError() {
+    return Error(`Table text column must have a name.`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/table/table-module.mjs

@@ -0,0 +1,94 @@
+/**
+ * @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 { NgModule } from '@angular/core';
+import { HeaderRowOutlet, DataRowOutlet, CdkTable, CdkRecycleRows, FooterRowOutlet, NoDataRowOutlet, } from './table';
+import { CdkCellOutlet, CdkFooterRow, CdkFooterRowDef, CdkHeaderRow, CdkHeaderRowDef, CdkRow, CdkRowDef, CdkNoDataRow, } from './row';
+import { CdkColumnDef, CdkHeaderCellDef, CdkHeaderCell, CdkCell, CdkCellDef, CdkFooterCellDef, CdkFooterCell, } from './cell';
+import { CdkTextColumn } from './text-column';
+import { ScrollingModule } from '@kato-lee/cdk/scrolling';
+import * as i0 from "@angular/core";
+const EXPORTED_DECLARATIONS = [
+    CdkTable,
+    CdkRowDef,
+    CdkCellDef,
+    CdkCellOutlet,
+    CdkHeaderCellDef,
+    CdkFooterCellDef,
+    CdkColumnDef,
+    CdkCell,
+    CdkRow,
+    CdkHeaderCell,
+    CdkFooterCell,
+    CdkHeaderRow,
+    CdkHeaderRowDef,
+    CdkFooterRow,
+    CdkFooterRowDef,
+    DataRowOutlet,
+    HeaderRowOutlet,
+    FooterRowOutlet,
+    CdkTextColumn,
+    CdkNoDataRow,
+    CdkRecycleRows,
+    NoDataRowOutlet,
+];
+export class CdkTableModule {
+}
+CdkTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CdkTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.0", ngImport: i0, type: CdkTableModule, declarations: [CdkTable,
+        CdkRowDef,
+        CdkCellDef,
+        CdkCellOutlet,
+        CdkHeaderCellDef,
+        CdkFooterCellDef,
+        CdkColumnDef,
+        CdkCell,
+        CdkRow,
+        CdkHeaderCell,
+        CdkFooterCell,
+        CdkHeaderRow,
+        CdkHeaderRowDef,
+        CdkFooterRow,
+        CdkFooterRowDef,
+        DataRowOutlet,
+        HeaderRowOutlet,
+        FooterRowOutlet,
+        CdkTextColumn,
+        CdkNoDataRow,
+        CdkRecycleRows,
+        NoDataRowOutlet], imports: [ScrollingModule], exports: [CdkTable,
+        CdkRowDef,
+        CdkCellDef,
+        CdkCellOutlet,
+        CdkHeaderCellDef,
+        CdkFooterCellDef,
+        CdkColumnDef,
+        CdkCell,
+        CdkRow,
+        CdkHeaderCell,
+        CdkFooterCell,
+        CdkHeaderRow,
+        CdkHeaderRowDef,
+        CdkFooterRow,
+        CdkFooterRowDef,
+        DataRowOutlet,
+        HeaderRowOutlet,
+        FooterRowOutlet,
+        CdkTextColumn,
+        CdkNoDataRow,
+        CdkRecycleRows,
+        NoDataRowOutlet] });
+CdkTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkTableModule, imports: [ScrollingModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: EXPORTED_DECLARATIONS,
+                    declarations: EXPORTED_DECLARATIONS,
+                    imports: [ScrollingModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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