@kato-lee/cdk 14.2.7

package/esm2020/table/row.mjs

@@ -0,0 +1,262 @@
+/**
+ * @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 { ChangeDetectionStrategy, Component, Directive, IterableDiffers, TemplateRef, ViewContainerRef, ViewEncapsulation, Inject, Optional, } from '@angular/core';
+import { mixinHasStickyInput } from './can-stick';
+import { CDK_TABLE } from './tokens';
+import * as i0 from "@angular/core";
+/**
+ * The row template that can be used by the mat-table. Should not be used outside of the
+ * material library.
+ */
+export const CDK_ROW_TEMPLATE = `<ng-container cdkCellOutlet></ng-container>`;
+/**
+ * Base class for the CdkHeaderRowDef and CdkRowDef that handles checking their columns inputs
+ * for changes and notifying the table.
+ */
+export class BaseRowDef {
+    constructor(
+    /** @docs-private */ template, _differs) {
+        this.template = template;
+        this._differs = _differs;
+    }
+    ngOnChanges(changes) {
+        // Create a new columns differ if one does not yet exist. Initialize it based on initial value
+        // of the columns property or an empty array if none is provided.
+        if (!this._columnsDiffer) {
+            const columns = (changes['columns'] && changes['columns'].currentValue) || [];
+            this._columnsDiffer = this._differs.find(columns).create();
+            this._columnsDiffer.diff(columns);
+        }
+    }
+    /**
+     * Returns the difference between the current columns and the columns from the last diff, or null
+     * if there is no difference.
+     */
+    getColumnsDiff() {
+        return this._columnsDiffer.diff(this.columns);
+    }
+    /** Gets this row def's relevant cell template from the provided column def. */
+    extractCellTemplate(column) {
+        if (this instanceof CdkHeaderRowDef) {
+            return column.headerCell.template;
+        }
+        if (this instanceof CdkFooterRowDef) {
+            return column.footerCell.template;
+        }
+        else {
+            return column.cell.template;
+        }
+    }
+}
+BaseRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: BaseRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive });
+BaseRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: BaseRowDef, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: BaseRowDef, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }]; } });
+// Boilerplate for applying mixins to CdkHeaderRowDef.
+/** @docs-private */
+class CdkHeaderRowDefBase extends BaseRowDef {
+}
+const _CdkHeaderRowDefBase = mixinHasStickyInput(CdkHeaderRowDefBase);
+/**
+ * Header row definition for the CDK table.
+ * Captures the header row's template and other header properties such as the columns to display.
+ */
+export class CdkHeaderRowDef extends _CdkHeaderRowDefBase {
+    constructor(template, _differs, _table) {
+        super(template, _differs);
+        this._table = _table;
+    }
+    // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.
+    // Explicitly define it so that the method is called as part of the Angular lifecycle.
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+    }
+}
+CdkHeaderRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkHeaderRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkHeaderRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkHeaderRowDef, selector: "[cdkHeaderRowDef]", inputs: { columns: ["cdkHeaderRowDef", "columns"], sticky: ["cdkHeaderRowDefSticky", "sticky"] }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkHeaderRowDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkHeaderRowDef]',
+                    inputs: ['columns: cdkHeaderRowDef', 'sticky: cdkHeaderRowDefSticky'],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CDK_TABLE]
+                }, {
+                    type: Optional
+                }] }]; } });
+// Boilerplate for applying mixins to CdkFooterRowDef.
+/** @docs-private */
+class CdkFooterRowDefBase extends BaseRowDef {
+}
+const _CdkFooterRowDefBase = mixinHasStickyInput(CdkFooterRowDefBase);
+/**
+ * Footer row definition for the CDK table.
+ * Captures the footer row's template and other footer properties such as the columns to display.
+ */
+export class CdkFooterRowDef extends _CdkFooterRowDefBase {
+    constructor(template, _differs, _table) {
+        super(template, _differs);
+        this._table = _table;
+    }
+    // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.
+    // Explicitly define it so that the method is called as part of the Angular lifecycle.
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+    }
+}
+CdkFooterRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkFooterRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkFooterRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkFooterRowDef, selector: "[cdkFooterRowDef]", inputs: { columns: ["cdkFooterRowDef", "columns"], sticky: ["cdkFooterRowDefSticky", "sticky"] }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkFooterRowDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkFooterRowDef]',
+                    inputs: ['columns: cdkFooterRowDef', 'sticky: cdkFooterRowDefSticky'],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CDK_TABLE]
+                }, {
+                    type: Optional
+                }] }]; } });
+/**
+ * Data row definition for the CDK table.
+ * Captures the header row's template and other row properties such as the columns to display and
+ * a when predicate that describes when this row should be used.
+ */
+export class CdkRowDef extends BaseRowDef {
+    // TODO(andrewseguin): Add an input for providing a switch function to determine
+    //   if this template should be used.
+    constructor(template, _differs, _table) {
+        super(template, _differs);
+        this._table = _table;
+    }
+}
+CdkRowDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkRowDef, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: CDK_TABLE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkRowDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkRowDef, selector: "[cdkRowDef]", inputs: { columns: ["cdkRowDefColumns", "columns"], when: ["cdkRowDefWhen", "when"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkRowDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkRowDef]',
+                    inputs: ['columns: cdkRowDefColumns', 'when: cdkRowDefWhen'],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CDK_TABLE]
+                }, {
+                    type: Optional
+                }] }]; } });
+/**
+ * Outlet for rendering cells inside of a row or header row.
+ * @docs-private
+ */
+export class CdkCellOutlet {
+    constructor(_viewContainer) {
+        this._viewContainer = _viewContainer;
+        CdkCellOutlet.mostRecentCellOutlet = this;
+    }
+    ngOnDestroy() {
+        // If this was the last outlet being rendered in the view, remove the reference
+        // from the static property after it has been destroyed to avoid leaking memory.
+        if (CdkCellOutlet.mostRecentCellOutlet === this) {
+            CdkCellOutlet.mostRecentCellOutlet = null;
+        }
+    }
+}
+/**
+ * Static property containing the latest constructed instance of this class.
+ * Used by the CDK table when each CdkHeaderRow and CdkRow component is created using
+ * createEmbeddedView. After one of these components are created, this property will provide
+ * a handle to provide that component's cells and context. After init, the CdkCellOutlet will
+ * construct the cells with the provided context.
+ */
+CdkCellOutlet.mostRecentCellOutlet = null;
+CdkCellOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkCellOutlet, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+CdkCellOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkCellOutlet, selector: "[cdkCellOutlet]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkCellOutlet, decorators: [{
+            type: Directive,
+            args: [{ selector: '[cdkCellOutlet]' }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; } });
+/** Header template container that contains the cell outlet. Adds the right class and role. */
+export class CdkHeaderRow {
+}
+CdkHeaderRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkHeaderRow, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CdkHeaderRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: CdkHeaderRow, selector: "cdk-header-row, tr[cdk-header-row]", host: { attributes: { "role": "row" }, classAttribute: "cdk-header-row" }, ngImport: i0, template: "<ng-container cdkCellOutlet></ng-container>", isInline: true, dependencies: [{ kind: "directive", type: CdkCellOutlet, selector: "[cdkCellOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkHeaderRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cdk-header-row, tr[cdk-header-row]',
+                    template: CDK_ROW_TEMPLATE,
+                    host: {
+                        'class': 'cdk-header-row',
+                        'role': 'row',
+                    },
+                    // See note on CdkTable for explanation on why this uses the default change detection strategy.
+                    // tslint:disable-next-line:validate-decorators
+                    changeDetection: ChangeDetectionStrategy.Default,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }] });
+/** Footer template container that contains the cell outlet. Adds the right class and role. */
+export class CdkFooterRow {
+}
+CdkFooterRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkFooterRow, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CdkFooterRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: CdkFooterRow, selector: "cdk-footer-row, tr[cdk-footer-row]", host: { attributes: { "role": "row" }, classAttribute: "cdk-footer-row" }, ngImport: i0, template: "<ng-container cdkCellOutlet></ng-container>", isInline: true, dependencies: [{ kind: "directive", type: CdkCellOutlet, selector: "[cdkCellOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkFooterRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cdk-footer-row, tr[cdk-footer-row]',
+                    template: CDK_ROW_TEMPLATE,
+                    host: {
+                        'class': 'cdk-footer-row',
+                        'role': 'row',
+                    },
+                    // See note on CdkTable for explanation on why this uses the default change detection strategy.
+                    // tslint:disable-next-line:validate-decorators
+                    changeDetection: ChangeDetectionStrategy.Default,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }] });
+/** Data row template container that contains the cell outlet. Adds the right class and role. */
+export class CdkRow {
+}
+CdkRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkRow, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CdkRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: CdkRow, selector: "cdk-row, tr[cdk-row]", host: { attributes: { "role": "row" }, classAttribute: "cdk-row" }, ngImport: i0, template: "<ng-container cdkCellOutlet></ng-container>", isInline: true, dependencies: [{ kind: "directive", type: CdkCellOutlet, selector: "[cdkCellOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cdk-row, tr[cdk-row]',
+                    template: CDK_ROW_TEMPLATE,
+                    host: {
+                        'class': 'cdk-row',
+                        'role': 'row',
+                    },
+                    // See note on CdkTable for explanation on why this uses the default change detection strategy.
+                    // tslint:disable-next-line:validate-decorators
+                    changeDetection: ChangeDetectionStrategy.Default,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }] });
+/** Row that can be used to display a message when no data is shown in the table. */
+export class CdkNoDataRow {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+        this._contentClassName = 'cdk-no-data-row';
+    }
+}
+CdkNoDataRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkNoDataRow, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+CdkNoDataRow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkNoDataRow, selector: "ng-template[cdkNoDataRow]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkNoDataRow, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[cdkNoDataRow]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"row.js","sourceRoot":"","sources":["../../../../../../src/cdk/table/row.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 {\n  ChangeDetectionStrategy,\n  Component,\n  Directive,\n  IterableChanges,\n  IterableDiffer,\n  IterableDiffers,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n  TemplateRef,\n  ViewContainerRef,\n  ViewEncapsulation,\n  Inject,\n  Optional,\n} from '@angular/core';\nimport {CanStick, CanStickCtor, mixinHasStickyInput} from './can-stick';\nimport {CdkCellDef, CdkColumnDef} from './cell';\nimport {CDK_TABLE} from './tokens';\n\n/**\n * The row template that can be used by the mat-table. Should not be used outside of the\n * material library.\n */\nexport const CDK_ROW_TEMPLATE = `<ng-container cdkCellOutlet></ng-container>`;\n\n/**\n * Base class for the CdkHeaderRowDef and CdkRowDef that handles checking their columns inputs\n * for changes and notifying the table.\n */\n@Directive()\nexport abstract class BaseRowDef implements OnChanges {\n  /** The columns to be displayed on this row. */\n  columns: Iterable<string>;\n\n  /** Differ used to check if any changes were made to the columns. */\n  protected _columnsDiffer: IterableDiffer<any>;\n\n  constructor(\n    /** @docs-private */ public template: TemplateRef<any>,\n    protected _differs: IterableDiffers,\n  ) {}\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Create a new columns differ if one does not yet exist. Initialize it based on initial value\n    // of the columns property or an empty array if none is provided.\n    if (!this._columnsDiffer) {\n      const columns = (changes['columns'] && changes['columns'].currentValue) || [];\n      this._columnsDiffer = this._differs.find(columns).create();\n      this._columnsDiffer.diff(columns);\n    }\n  }\n\n  /**\n   * Returns the difference between the current columns and the columns from the last diff, or null\n   * if there is no difference.\n   */\n  getColumnsDiff(): IterableChanges<any> | null {\n    return this._columnsDiffer.diff(this.columns);\n  }\n\n  /** Gets this row def's relevant cell template from the provided column def. */\n  extractCellTemplate(column: CdkColumnDef): TemplateRef<any> {\n    if (this instanceof CdkHeaderRowDef) {\n      return column.headerCell.template;\n    }\n    if (this instanceof CdkFooterRowDef) {\n      return column.footerCell.template;\n    } else {\n      return column.cell.template;\n    }\n  }\n}\n\n// Boilerplate for applying mixins to CdkHeaderRowDef.\n/** @docs-private */\nclass CdkHeaderRowDefBase extends BaseRowDef {}\nconst _CdkHeaderRowDefBase: CanStickCtor & typeof CdkHeaderRowDefBase =\n  mixinHasStickyInput(CdkHeaderRowDefBase);\n\n/**\n * Header row definition for the CDK table.\n * Captures the header row's template and other header properties such as the columns to display.\n */\n@Directive({\n  selector: '[cdkHeaderRowDef]',\n  inputs: ['columns: cdkHeaderRowDef', 'sticky: cdkHeaderRowDefSticky'],\n})\nexport class CdkHeaderRowDef extends _CdkHeaderRowDefBase implements CanStick, OnChanges {\n  constructor(\n    template: TemplateRef<any>,\n    _differs: IterableDiffers,\n    @Inject(CDK_TABLE) @Optional() public _table?: any,\n  ) {\n    super(template, _differs);\n  }\n\n  // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.\n  // Explicitly define it so that the method is called as part of the Angular lifecycle.\n  override ngOnChanges(changes: SimpleChanges): void {\n    super.ngOnChanges(changes);\n  }\n}\n\n// Boilerplate for applying mixins to CdkFooterRowDef.\n/** @docs-private */\nclass CdkFooterRowDefBase extends BaseRowDef {}\nconst _CdkFooterRowDefBase: CanStickCtor & typeof CdkFooterRowDefBase =\n  mixinHasStickyInput(CdkFooterRowDefBase);\n\n/**\n * Footer row definition for the CDK table.\n * Captures the footer row's template and other footer properties such as the columns to display.\n */\n@Directive({\n  selector: '[cdkFooterRowDef]',\n  inputs: ['columns: cdkFooterRowDef', 'sticky: cdkFooterRowDefSticky'],\n})\nexport class CdkFooterRowDef extends _CdkFooterRowDefBase implements CanStick, OnChanges {\n  constructor(\n    template: TemplateRef<any>,\n    _differs: IterableDiffers,\n    @Inject(CDK_TABLE) @Optional() public _table?: any,\n  ) {\n    super(template, _differs);\n  }\n\n  // Prerender fails to recognize that ngOnChanges in a part of this class through inheritance.\n  // Explicitly define it so that the method is called as part of the Angular lifecycle.\n  override ngOnChanges(changes: SimpleChanges): void {\n    super.ngOnChanges(changes);\n  }\n}\n\n/**\n * Data row definition for the CDK table.\n * Captures the header row's template and other row properties such as the columns to display and\n * a when predicate that describes when this row should be used.\n */\n@Directive({\n  selector: '[cdkRowDef]',\n  inputs: ['columns: cdkRowDefColumns', 'when: cdkRowDefWhen'],\n})\nexport class CdkRowDef<T> extends BaseRowDef {\n  /**\n   * Function that should return true if this row template should be used for the provided index\n   * and row data. If left undefined, this row will be considered the default row template to use\n   * when no other when functions return true for the data.\n   * For every row, there must be at least one when function that passes or an undefined to default.\n   */\n  when: (index: number, rowData: T) => boolean;\n\n  // TODO(andrewseguin): Add an input for providing a switch function to determine\n  //   if this template should be used.\n  constructor(\n    template: TemplateRef<any>,\n    _differs: IterableDiffers,\n    @Inject(CDK_TABLE) @Optional() public _table?: any,\n  ) {\n    super(template, _differs);\n  }\n}\n\n/** Context provided to the row cells when `multiTemplateDataRows` is false */\nexport interface CdkCellOutletRowContext<T> {\n  /** Data for the row that this cell is located within. */\n  $implicit?: T;\n\n  /** Index of the data object in the provided data array. */\n  index?: number;\n\n  /** Length of the number of total rows. */\n  count?: number;\n\n  /** True if this cell is contained in the first row. */\n  first?: boolean;\n\n  /** True if this cell is contained in the last row. */\n  last?: boolean;\n\n  /** True if this cell is contained in a row with an even-numbered index. */\n  even?: boolean;\n\n  /** True if this cell is contained in a row with an odd-numbered index. */\n  odd?: boolean;\n}\n\n/**\n * Context provided to the row cells when `multiTemplateDataRows` is true. This context is the same\n * as CdkCellOutletRowContext except that the single `index` value is replaced by `dataIndex` and\n * `renderIndex`.\n */\nexport interface CdkCellOutletMultiRowContext<T> {\n  /** Data for the row that this cell is located within. */\n  $implicit?: T;\n\n  /** Index of the data object in the provided data array. */\n  dataIndex?: number;\n\n  /** Index location of the rendered row that this cell is located within. */\n  renderIndex?: number;\n\n  /** Length of the number of total rows. */\n  count?: number;\n\n  /** True if this cell is contained in the first row. */\n  first?: boolean;\n\n  /** True if this cell is contained in the last row. */\n  last?: boolean;\n\n  /** True if this cell is contained in a row with an even-numbered index. */\n  even?: boolean;\n\n  /** True if this cell is contained in a row with an odd-numbered index. */\n  odd?: boolean;\n}\n\n/**\n * Outlet for rendering cells inside of a row or header row.\n * @docs-private\n */\n@Directive({selector: '[cdkCellOutlet]'})\nexport class CdkCellOutlet implements OnDestroy {\n  /** The ordered list of cells to render within this outlet's view container */\n  cells: CdkCellDef[];\n\n  /** The data context to be provided to each cell */\n  context: any;\n\n  /**\n   * Static property containing the latest constructed instance of this class.\n   * Used by the CDK table when each CdkHeaderRow and CdkRow component is created using\n   * createEmbeddedView. After one of these components are created, this property will provide\n   * a handle to provide that component's cells and context. After init, the CdkCellOutlet will\n   * construct the cells with the provided context.\n   */\n  static mostRecentCellOutlet: CdkCellOutlet | null = null;\n\n  constructor(public _viewContainer: ViewContainerRef) {\n    CdkCellOutlet.mostRecentCellOutlet = this;\n  }\n\n  ngOnDestroy() {\n    // If this was the last outlet being rendered in the view, remove the reference\n    // from the static property after it has been destroyed to avoid leaking memory.\n    if (CdkCellOutlet.mostRecentCellOutlet === this) {\n      CdkCellOutlet.mostRecentCellOutlet = null;\n    }\n  }\n}\n\n/** Header template container that contains the cell outlet. Adds the right class and role. */\n@Component({\n  selector: 'cdk-header-row, tr[cdk-header-row]',\n  template: CDK_ROW_TEMPLATE,\n  host: {\n    'class': 'cdk-header-row',\n    'role': 'row',\n  },\n  // See note on CdkTable for explanation on why this uses the default change detection strategy.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class CdkHeaderRow {}\n\n/** Footer template container that contains the cell outlet. Adds the right class and role. */\n@Component({\n  selector: 'cdk-footer-row, tr[cdk-footer-row]',\n  template: CDK_ROW_TEMPLATE,\n  host: {\n    'class': 'cdk-footer-row',\n    'role': 'row',\n  },\n  // See note on CdkTable for explanation on why this uses the default change detection strategy.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class CdkFooterRow {}\n\n/** Data row template container that contains the cell outlet. Adds the right class and role. */\n@Component({\n  selector: 'cdk-row, tr[cdk-row]',\n  template: CDK_ROW_TEMPLATE,\n  host: {\n    'class': 'cdk-row',\n    'role': 'row',\n  },\n  // See note on CdkTable for explanation on why this uses the default change detection strategy.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class CdkRow {}\n\n/** Row that can be used to display a message when no data is shown in the table. */\n@Directive({\n  selector: 'ng-template[cdkNoDataRow]',\n})\nexport class CdkNoDataRow {\n  _contentClassName = 'cdk-no-data-row';\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n"]}

package/esm2020/table/sticky-position-listener.mjs

@@ -0,0 +1,11 @@
+/**
+ * @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 { InjectionToken } from '@angular/core';
+/** The injection token used to specify the StickyPositioningListener. */
+export const STICKY_POSITIONING_LISTENER = new InjectionToken('CDK_SPL');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RpY2t5LXBvc2l0aW9uLWxpc3RlbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay90YWJsZS9zdGlja3ktcG9zaXRpb24tbGlzdGVuZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUU3Qyx5RUFBeUU7QUFDekUsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQTRCLFNBQVMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7SW5qZWN0aW9uVG9rZW59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKiogVGhlIGluamVjdGlvbiB0b2tlbiB1c2VkIHRvIHNwZWNpZnkgdGhlIFN0aWNreVBvc2l0aW9uaW5nTGlzdGVuZXIuICovXG5leHBvcnQgY29uc3QgU1RJQ0tZX1BPU0lUSU9OSU5HX0xJU1RFTkVSID0gbmV3IEluamVjdGlvblRva2VuPFN0aWNreVBvc2l0aW9uaW5nTGlzdGVuZXI+KCdDREtfU1BMJyk7XG5cbmV4cG9ydCB0eXBlIFN0aWNreVNpemUgPSBudW1iZXIgfCBudWxsIHwgdW5kZWZpbmVkO1xuZXhwb3J0IHR5cGUgU3RpY2t5T2Zmc2V0ID0gbnVtYmVyIHwgbnVsbCB8IHVuZGVmaW5lZDtcblxuZXhwb3J0IGludGVyZmFjZSBTdGlja3lVcGRhdGUge1xuICBlbGVtZW50cz86IHJlYWRvbmx5IChIVE1MRWxlbWVudFtdIHwgdW5kZWZpbmVkKVtdO1xuICBvZmZzZXRzPzogU3RpY2t5T2Zmc2V0W107XG4gIHNpemVzOiBTdGlja3lTaXplW107XG59XG5cbi8qKlxuICogSWYgcHJvdmlkZWQsIENka1RhYmxlIHdpbGwgY2FsbCB0aGUgbWV0aG9kcyBiZWxvdyB3aGVuIGl0IHVwZGF0ZXMgdGhlIHNpemUvXG4gKiBwb3NpdGlvbi9ldGMgb2YgaXRzIHN0aWNreSByb3dzIGFuZCBjb2x1bW5zLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFN0aWNreVBvc2l0aW9uaW5nTGlzdGVuZXIge1xuICAvKiogQ2FsbGVkIHdoZW4gQ2RrVGFibGUgdXBkYXRlcyBpdHMgc3RpY2t5IHN0YXJ0IGNvbHVtbnMuICovXG4gIHN0aWNreUNvbHVtbnNVcGRhdGVkKHVwZGF0ZTogU3RpY2t5VXBkYXRlKTogdm9pZDtcblxuICAvKiogQ2FsbGVkIHdoZW4gQ2RrVGFibGUgdXBkYXRlcyBpdHMgc3RpY2t5IGVuZCBjb2x1bW5zLiAqL1xuICBzdGlja3lFbmRDb2x1bW5zVXBkYXRlZCh1cGRhdGU6IFN0aWNreVVwZGF0ZSk6IHZvaWQ7XG5cbiAgLyoqIENhbGxlZCB3aGVuIENka1RhYmxlIHVwZGF0ZXMgaXRzIHN0aWNreSBoZWFkZXIgcm93cy4gKi9cbiAgc3RpY2t5SGVhZGVyUm93c1VwZGF0ZWQodXBkYXRlOiBTdGlja3lVcGRhdGUpOiB2b2lkO1xuXG4gIC8qKiBDYWxsZWQgd2hlbiBDZGtUYWJsZSB1cGRhdGVzIGl0cyBzdGlja3kgZm9vdGVyIHJvd3MuICovXG4gIHN0aWNreUZvb3RlclJvd3NVcGRhdGVkKHVwZGF0ZTogU3RpY2t5VXBkYXRlKTogdm9pZDtcbn1cbiJdfQ==