| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc |
| */ |
| import * as tslib_1 from "tslib"; |
| import { Component, Input, Output, EventEmitter, forwardRef, ChangeDetectionStrategy, ChangeDetectorRef, ViewChild, ContentChildren, QueryList, Inject, Optional, ViewChildren, ElementRef } from '@angular/core'; |
| import { DOCUMENT } from '@angular/common'; |
| import { DomSanitizer } from '@angular/platform-browser'; |
| import { NG_VALUE_ACCESSOR } from '@angular/forms'; |
| import { coerceBooleanProperty } from '@angular/cdk/coercion'; |
| import { ENTER, SPACE, UP_ARROW, DOWN_ARROW } from '@angular/cdk/keycodes'; |
| import { Subject } from 'rxjs'; |
| import { debounceTime } from 'rxjs/operators'; |
| import { TdDataTableRowComponent } from './data-table-row/data-table-row.component'; |
| import { TdDataTableTemplateDirective } from './directives/data-table-template.directive'; |
| import { mixinControlValueAccessor } from '@covalent/core/common'; |
| /** @enum {string} */ |
| var TdDataTableSortingOrder = { |
| Ascending: 'ASC', |
| Descending: 'DESC', |
| }; |
| export { TdDataTableSortingOrder }; |
| /** |
| * @record |
| */ |
| export function ITdDataTableColumnWidth() { } |
| if (false) { |
| /** @type {?|undefined} */ |
| ITdDataTableColumnWidth.prototype.min; |
| /** @type {?|undefined} */ |
| ITdDataTableColumnWidth.prototype.max; |
| } |
| /** |
| * @record |
| */ |
| export function ITdDataTableColumn() { } |
| if (false) { |
| /** @type {?} */ |
| ITdDataTableColumn.prototype.name; |
| /** @type {?} */ |
| ITdDataTableColumn.prototype.label; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.tooltip; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.numeric; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.format; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.nested; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.sortable; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.hidden; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.filter; |
| /** @type {?|undefined} */ |
| ITdDataTableColumn.prototype.width; |
| } |
| /** |
| * @record |
| */ |
| export function ITdDataTableSelectEvent() { } |
| if (false) { |
| /** @type {?} */ |
| ITdDataTableSelectEvent.prototype.row; |
| /** @type {?} */ |
| ITdDataTableSelectEvent.prototype.selected; |
| /** @type {?} */ |
| ITdDataTableSelectEvent.prototype.index; |
| } |
| /** |
| * @record |
| */ |
| export function ITdDataTableSelectAllEvent() { } |
| if (false) { |
| /** @type {?} */ |
| ITdDataTableSelectAllEvent.prototype.rows; |
| /** @type {?} */ |
| ITdDataTableSelectAllEvent.prototype.selected; |
| } |
| /** |
| * @record |
| */ |
| export function ITdDataTableRowClickEvent() { } |
| if (false) { |
| /** @type {?} */ |
| ITdDataTableRowClickEvent.prototype.row; |
| /** @type {?} */ |
| ITdDataTableRowClickEvent.prototype.index; |
| } |
| /** |
| * @record |
| */ |
| export function IInternalColumnWidth() { } |
| if (false) { |
| /** @type {?} */ |
| IInternalColumnWidth.prototype.value; |
| /** @type {?} */ |
| IInternalColumnWidth.prototype.limit; |
| /** @type {?} */ |
| IInternalColumnWidth.prototype.index; |
| /** @type {?|undefined} */ |
| IInternalColumnWidth.prototype.min; |
| /** @type {?|undefined} */ |
| IInternalColumnWidth.prototype.max; |
| } |
| /** |
| * Constant to set the rows offset before and after the viewport |
| * @type {?} |
| */ |
| var TD_VIRTUAL_OFFSET = 2; |
| /** |
| * Constant to set default row height if none is provided |
| * @type {?} |
| */ |
| var TD_VIRTUAL_DEFAULT_ROW_HEIGHT = 48; |
| var TdDataTableBase = /** @class */ (function () { |
| function TdDataTableBase(_changeDetectorRef) { |
| this._changeDetectorRef = _changeDetectorRef; |
| } |
| return TdDataTableBase; |
| }()); |
| export { TdDataTableBase }; |
| if (false) { |
| /** @type {?} */ |
| TdDataTableBase.prototype._changeDetectorRef; |
| } |
| /* tslint:disable-next-line */ |
| /** @type {?} */ |
| export var _TdDataTableMixinBase = mixinControlValueAccessor(TdDataTableBase, []); |
| var TdDataTableComponent = /** @class */ (function (_super) { |
| tslib_1.__extends(TdDataTableComponent, _super); |
| function TdDataTableComponent(_document, _elementRef, _domSanitizer, _changeDetectorRef) { |
| var _this = _super.call(this, _changeDetectorRef) || this; |
| _this._document = _document; |
| _this._elementRef = _elementRef; |
| _this._domSanitizer = _domSanitizer; |
| _this._hostWidth = 0; |
| /** |
| * manually resizable columns |
| */ |
| _this._resizableColumns = false; |
| _this._columnClientX = 0; |
| _this._onColumnResize = new Subject(); |
| _this._widths = []; |
| _this._onResize = new Subject(); |
| _this._scrollHorizontalOffset = 0; |
| _this._onHorizontalScroll = new Subject(); |
| _this._onVerticalScroll = new Subject(); |
| // Array of cached row heights to allow dynamic row heights |
| _this._rowHeightCache = []; |
| // Total pseudo height of all the elements |
| _this._totalHeight = 0; |
| // Total host height for the viewport |
| _this._hostHeight = 0; |
| // Scrolled vertical pixels |
| _this._scrollVerticalOffset = 0; |
| // Variables that set from and to which rows will be rendered |
| _this._fromRow = 0; |
| _this._toRow = 0; |
| _this._selectable = false; |
| _this._clickable = false; |
| _this._multiple = true; |
| _this._allSelected = false; |
| _this._indeterminate = false; |
| /** |
| * sorting |
| */ |
| _this._sortable = false; |
| _this._sortOrder = TdDataTableSortingOrder.Ascending; |
| /** |
| * shift select |
| */ |
| _this._shiftPreviouslyPressed = false; |
| _this._lastSelectedIndex = -1; |
| _this._firstSelectedIndex = -1; |
| _this._firstCheckboxValue = false; |
| /** |
| * template fetching support |
| */ |
| _this._templateMap = new Map(); |
| /** |
| * sortChange?: function |
| * Event emitted when the column headers are clicked. [sortable] needs to be enabled. |
| * Emits an [ITdDataTableSortChangeEvent] implemented object. |
| */ |
| _this.onSortChange = new EventEmitter(); |
| /** |
| * rowSelect?: function |
| * Event emitted when a row is selected/deselected. [selectable] needs to be enabled. |
| * Emits an [ITdDataTableSelectEvent] implemented object. |
| */ |
| _this.onRowSelect = new EventEmitter(); |
| /** |
| * rowClick?: function |
| * Event emitted when a row is clicked. |
| * Emits an [ITdDataTableRowClickEvent] implemented object. |
| */ |
| _this.onRowClick = new EventEmitter(); |
| /** |
| * selectAll?: function |
| * Event emitted when all rows are selected/deselected by the all checkbox. [selectable] needs to be enabled. |
| * Emits an [ITdDataTableSelectAllEvent] implemented object. |
| */ |
| _this.onSelectAll = new EventEmitter(); |
| /** |
| * compareWith?: function(row, model): boolean |
| * Allows custom comparison between row and model to see if row is selected or not |
| * Default comparation is by reference |
| */ |
| _this.compareWith = function (row, model) { |
| return row === model; |
| }; |
| return _this; |
| } |
| Object.defineProperty(TdDataTableComponent.prototype, "resizingColumn", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._resizingColumn; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "hostWidth", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| // if the checkboxes are rendered, we need to remove their width |
| // from the total width to calculate properly |
| if (this.selectable) { |
| return this._hostWidth - 42; |
| } |
| return this._hostWidth; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "offsetTransform", { |
| /** |
| * Returns the offset style with a proper calculation on how much it should move |
| * over the y axis of the total height |
| */ |
| get: /** |
| * Returns the offset style with a proper calculation on how much it should move |
| * over the y axis of the total height |
| * @return {?} |
| */ |
| function () { |
| return this._offsetTransform; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "totalHeight", { |
| /** |
| * Returns the assumed total height of the rows |
| */ |
| get: /** |
| * Returns the assumed total height of the rows |
| * @return {?} |
| */ |
| function () { |
| return this._totalHeight; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "fromRow", { |
| /** |
| * Returns the initial row to render in the viewport |
| */ |
| get: /** |
| * Returns the initial row to render in the viewport |
| * @return {?} |
| */ |
| function () { |
| return this._fromRow; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "toRow", { |
| /** |
| * Returns the last row to render in the viewport |
| */ |
| get: /** |
| * Returns the last row to render in the viewport |
| * @return {?} |
| */ |
| function () { |
| return this._toRow; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "columnsLeftScroll", { |
| /** |
| * Returns scroll position to reposition column headers |
| */ |
| get: /** |
| * Returns scroll position to reposition column headers |
| * @return {?} |
| */ |
| function () { |
| return this._scrollHorizontalOffset * -1; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "allSelected", { |
| /** |
| * Returns true if all values are selected. |
| */ |
| get: /** |
| * Returns true if all values are selected. |
| * @return {?} |
| */ |
| function () { |
| return this._allSelected; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "indeterminate", { |
| /** |
| * Returns true if all values are not deselected |
| * and at least one is. |
| */ |
| get: /** |
| * Returns true if all values are not deselected |
| * and at least one is. |
| * @return {?} |
| */ |
| function () { |
| return this._indeterminate; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "data", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._data; |
| }, |
| /** |
| * data?: {[key: string]: any}[] |
| * Sets the data to be rendered as rows. |
| */ |
| set: /** |
| * data?: {[key: string]: any}[] |
| * Sets the data to be rendered as rows. |
| * @param {?} data |
| * @return {?} |
| */ |
| function (data) { |
| var _this = this; |
| this._data = data; |
| this._rowHeightCache = []; |
| Promise.resolve().then(function () { |
| _this.refresh(); |
| // scroll back to the top if the data has changed |
| _this._scrollableDiv.nativeElement.scrollTop = 0; |
| }); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "virtualData", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._virtualData; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "columns", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| if (this._columns) { |
| return this._columns; |
| } |
| if (this.hasData) { |
| this._columns = []; |
| // if columns is undefined, use key in [data] rows as name and label for column headers. |
| /** @type {?} */ |
| var row = this._data[0]; |
| Object.keys(row).forEach(function (k) { |
| if (!_this._columns.find(function (c) { return c.name === k; })) { |
| _this._columns.push({ name: k, label: k }); |
| } |
| }); |
| return this._columns; |
| } |
| else { |
| return []; |
| } |
| }, |
| /** |
| * columns?: ITdDataTableColumn[] |
| * Sets additional column configuration. [ITdDataTableColumn.name] has to exist in [data] as key. |
| * Defaults to [data] keys. |
| */ |
| set: /** |
| * columns?: ITdDataTableColumn[] |
| * Sets additional column configuration. [ITdDataTableColumn.name] has to exist in [data] as key. |
| * Defaults to [data] keys. |
| * @param {?} cols |
| * @return {?} |
| */ |
| function (cols) { |
| this._columns = cols; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "resizableColumns", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._resizableColumns; |
| }, |
| /** |
| * resizableColumns?: boolean |
| * Enables manual column resize. |
| * Defaults to 'false' |
| */ |
| set: /** |
| * resizableColumns?: boolean |
| * Enables manual column resize. |
| * Defaults to 'false' |
| * @param {?} resizableColumns |
| * @return {?} |
| */ |
| function (resizableColumns) { |
| this._resizableColumns = coerceBooleanProperty(resizableColumns); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "selectable", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._selectable; |
| }, |
| /** |
| * selectable?: boolean |
| * Enables row selection events, hover and selected row states. |
| * Defaults to 'false' |
| */ |
| set: /** |
| * selectable?: boolean |
| * Enables row selection events, hover and selected row states. |
| * Defaults to 'false' |
| * @param {?} selectable |
| * @return {?} |
| */ |
| function (selectable) { |
| this._selectable = coerceBooleanProperty(selectable); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "clickable", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._clickable; |
| }, |
| /** |
| * clickable?: boolean |
| * Enables row click events, hover. |
| * Defaults to 'false' |
| */ |
| set: /** |
| * clickable?: boolean |
| * Enables row click events, hover. |
| * Defaults to 'false' |
| * @param {?} clickable |
| * @return {?} |
| */ |
| function (clickable) { |
| this._clickable = coerceBooleanProperty(clickable); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "multiple", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._multiple; |
| }, |
| /** |
| * multiple?: boolean |
| * Enables multiple row selection. [selectable] needs to be enabled. |
| * Defaults to 'false' |
| */ |
| set: /** |
| * multiple?: boolean |
| * Enables multiple row selection. [selectable] needs to be enabled. |
| * Defaults to 'false' |
| * @param {?} multiple |
| * @return {?} |
| */ |
| function (multiple) { |
| this._multiple = coerceBooleanProperty(multiple); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "sortable", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._sortable; |
| }, |
| /** |
| * sortable?: boolean |
| * Enables sorting events, sort icons and active column states. |
| * Defaults to 'false' |
| */ |
| set: /** |
| * sortable?: boolean |
| * Enables sorting events, sort icons and active column states. |
| * Defaults to 'false' |
| * @param {?} sortable |
| * @return {?} |
| */ |
| function (sortable) { |
| this._sortable = coerceBooleanProperty(sortable); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "sortBy", { |
| /** |
| * sortBy?: string |
| * Sets the active sort column. [sortable] needs to be enabled. |
| */ |
| set: /** |
| * sortBy?: string |
| * Sets the active sort column. [sortable] needs to be enabled. |
| * @param {?} columnName |
| * @return {?} |
| */ |
| function (columnName) { |
| if (!columnName) { |
| return; |
| } |
| /** @type {?} */ |
| var column = this.columns.find(function (c) { return c.name === columnName; }); |
| if (!column) { |
| throw new Error('[sortBy] must be a valid column name'); |
| } |
| this._sortBy = column; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "sortByColumn", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._sortBy; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "sortOrder", { |
| /** |
| * sortOrder?: ['ASC' | 'DESC'] or TdDataTableSortingOrder |
| * Sets the sort order of the [sortBy] column. [sortable] needs to be enabled. |
| * Defaults to 'ASC' or TdDataTableSortingOrder.Ascending |
| */ |
| set: /** |
| * sortOrder?: ['ASC' | 'DESC'] or TdDataTableSortingOrder |
| * Sets the sort order of the [sortBy] column. [sortable] needs to be enabled. |
| * Defaults to 'ASC' or TdDataTableSortingOrder.Ascending |
| * @param {?} order |
| * @return {?} |
| */ |
| function (order) { |
| /** @type {?} */ |
| var sortOrder = order ? order.toUpperCase() : 'ASC'; |
| if (sortOrder !== 'DESC' && sortOrder !== 'ASC') { |
| throw new Error('[sortOrder] must be empty, ASC or DESC'); |
| } |
| this._sortOrder = sortOrder === 'ASC' ? |
| TdDataTableSortingOrder.Ascending : TdDataTableSortingOrder.Descending; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "sortOrderEnum", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._sortOrder; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(TdDataTableComponent.prototype, "hasData", { |
| get: /** |
| * @return {?} |
| */ |
| function () { |
| return this._data && this._data.length > 0; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * Initialize observable for resize and scroll events |
| */ |
| /** |
| * Initialize observable for resize and scroll events |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.ngOnInit = /** |
| * Initialize observable for resize and scroll events |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| // initialize observable for resize calculations |
| this._resizeSubs = this._onResize.asObservable().subscribe(function () { |
| if (_this._rows) { |
| _this._rows.toArray().forEach(function (row, index) { |
| _this._rowHeightCache[_this.fromRow + index] = row.height + 1; |
| }); |
| } |
| _this._calculateWidths(); |
| _this._calculateVirtualRows(); |
| }); |
| // initialize observable for column resize calculations |
| this._columnResizeSubs = this._onColumnResize.asObservable().pipe(debounceTime(0)).subscribe(function (clientX) { |
| _this._columnClientX = clientX; |
| _this._calculateWidths(); |
| _this._changeDetectorRef.markForCheck(); |
| }); |
| // initialize observable for scroll column header reposition |
| this._horizontalScrollSubs = this._onHorizontalScroll.asObservable() |
| .subscribe(function (horizontalScroll) { |
| _this._scrollHorizontalOffset = horizontalScroll; |
| _this._changeDetectorRef.markForCheck(); |
| }); |
| // initialize observable for virtual scroll rendering |
| this._verticalScrollSubs = this._onVerticalScroll.asObservable() |
| .subscribe(function (verticalScroll) { |
| _this._scrollVerticalOffset = verticalScroll; |
| _this._calculateVirtualRows(); |
| _this._changeDetectorRef.markForCheck(); |
| }); |
| this._valueChangesSubs = this.valueChanges.subscribe(function (value) { |
| _this.refresh(); |
| }); |
| }; |
| /** |
| * Loads templates and sets them in a map for faster access. |
| */ |
| /** |
| * Loads templates and sets them in a map for faster access. |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.ngAfterContentInit = /** |
| * Loads templates and sets them in a map for faster access. |
| * @return {?} |
| */ |
| function () { |
| for (var i = 0; i < this._templates.toArray().length; i++) { |
| this._templateMap.set(this._templates.toArray()[i].tdDataTableTemplate, this._templates.toArray()[i].templateRef); |
| } |
| }; |
| /** |
| * Checks hosts native elements widths to see if it has changed (resize check) |
| */ |
| /** |
| * Checks hosts native elements widths to see if it has changed (resize check) |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.ngAfterContentChecked = /** |
| * Checks hosts native elements widths to see if it has changed (resize check) |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| // check if the scroll has been reset when element is hidden |
| if (this._scrollVerticalOffset - this._scrollableDiv.nativeElement.scrollTop > 5) { |
| // scroll back to the top if element has been reset |
| this._onVerticalScroll.next(0); |
| } |
| if (this._elementRef.nativeElement) { |
| /** @type {?} */ |
| var newHostWidth_1 = this._elementRef.nativeElement.getBoundingClientRect().width; |
| // if the width has changed then we throw a resize event. |
| if (this._hostWidth !== newHostWidth_1) { |
| setTimeout(function () { |
| _this._hostWidth = newHostWidth_1; |
| _this._onResize.next(); |
| }, 0); |
| } |
| } |
| if (this._scrollableDiv.nativeElement) { |
| /** @type {?} */ |
| var newHostHeight = this._scrollableDiv.nativeElement.getBoundingClientRect().height; |
| // if the height of the viewport has changed, then we mark for check |
| if (this._hostHeight !== newHostHeight) { |
| this._hostHeight = newHostHeight; |
| this._calculateVirtualRows(); |
| this._changeDetectorRef.markForCheck(); |
| } |
| } |
| }; |
| /** |
| * Registers to an observable that checks if all rows have been rendered |
| * so we can start calculating the widths |
| */ |
| /** |
| * Registers to an observable that checks if all rows have been rendered |
| * so we can start calculating the widths |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.ngAfterViewInit = /** |
| * Registers to an observable that checks if all rows have been rendered |
| * so we can start calculating the widths |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| this._rowsChangedSubs = this._rows.changes.pipe(debounceTime(0)).subscribe(function () { |
| _this._onResize.next(); |
| }); |
| this._calculateVirtualRows(); |
| }; |
| /** |
| * Unsubscribes observables when data table is destroyed |
| */ |
| /** |
| * Unsubscribes observables when data table is destroyed |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.ngOnDestroy = /** |
| * Unsubscribes observables when data table is destroyed |
| * @return {?} |
| */ |
| function () { |
| if (this._resizeSubs) { |
| this._resizeSubs.unsubscribe(); |
| } |
| if (this._columnResizeSubs) { |
| this._columnResizeSubs.unsubscribe(); |
| } |
| if (this._horizontalScrollSubs) { |
| this._horizontalScrollSubs.unsubscribe(); |
| } |
| if (this._verticalScrollSubs) { |
| this._verticalScrollSubs.unsubscribe(); |
| } |
| if (this._rowsChangedSubs) { |
| this._rowsChangedSubs.unsubscribe(); |
| } |
| if (this._valueChangesSubs) { |
| this._valueChangesSubs.unsubscribe(); |
| } |
| }; |
| /** |
| * Method that gets executed every time there is a scroll event |
| * Calls the scroll observable |
| */ |
| /** |
| * Method that gets executed every time there is a scroll event |
| * Calls the scroll observable |
| * @param {?} event |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.handleScroll = /** |
| * Method that gets executed every time there is a scroll event |
| * Calls the scroll observable |
| * @param {?} event |
| * @return {?} |
| */ |
| function (event) { |
| /** @type {?} */ |
| var element = ((/** @type {?} */ (event.target))); |
| if (element) { |
| /** @type {?} */ |
| var horizontalScroll = element.scrollLeft; |
| if (this._scrollHorizontalOffset !== horizontalScroll) { |
| this._onHorizontalScroll.next(horizontalScroll); |
| } |
| /** @type {?} */ |
| var verticalScroll = element.scrollTop; |
| if (this._scrollVerticalOffset !== verticalScroll) { |
| this._onVerticalScroll.next(verticalScroll); |
| } |
| } |
| }; |
| /** |
| * Returns the width needed for the columns via index |
| */ |
| /** |
| * Returns the width needed for the columns via index |
| * @param {?} index |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.getColumnWidth = /** |
| * Returns the width needed for the columns via index |
| * @param {?} index |
| * @return {?} |
| */ |
| function (index) { |
| if (this._widths[index]) { |
| return this._widths[index].value; |
| } |
| return undefined; |
| }; |
| /** |
| * @param {?} column |
| * @param {?} value |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.getCellValue = /** |
| * @param {?} column |
| * @param {?} value |
| * @return {?} |
| */ |
| function (column, value) { |
| if (column.nested === undefined || column.nested) { |
| return this._getNestedValue(column.name, value); |
| } |
| return value[column.name]; |
| }; |
| /** |
| * Getter method for template references |
| */ |
| /** |
| * Getter method for template references |
| * @param {?} name |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.getTemplateRef = /** |
| * Getter method for template references |
| * @param {?} name |
| * @return {?} |
| */ |
| function (name) { |
| return this._templateMap.get(name); |
| }; |
| /** |
| * Clears model (ngModel) of component by removing all values in array. |
| */ |
| /** |
| * Clears model (ngModel) of component by removing all values in array. |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.clearModel = /** |
| * Clears model (ngModel) of component by removing all values in array. |
| * @return {?} |
| */ |
| function () { |
| this.value.splice(0, this.value.length); |
| }; |
| /** |
| * Refreshes data table and rerenders [data] and [columns] |
| */ |
| /** |
| * Refreshes data table and rerenders [data] and [columns] |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.refresh = /** |
| * Refreshes data table and rerenders [data] and [columns] |
| * @return {?} |
| */ |
| function () { |
| this._calculateVirtualRows(); |
| this._calculateWidths(); |
| this._calculateCheckboxState(); |
| this._changeDetectorRef.markForCheck(); |
| }; |
| /** |
| * Selects or clears all rows depending on 'checked' value. |
| */ |
| /** |
| * Selects or clears all rows depending on 'checked' value. |
| * @param {?} checked |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.selectAll = /** |
| * Selects or clears all rows depending on 'checked' value. |
| * @param {?} checked |
| * @return {?} |
| */ |
| function (checked) { |
| var _this = this; |
| /** @type {?} */ |
| var toggledRows = []; |
| if (checked) { |
| this._data.forEach(function (row) { |
| // skiping already selected rows |
| if (!_this.isRowSelected(row)) { |
| _this.value.push(row); |
| // checking which ones are being toggled |
| toggledRows.push(row); |
| } |
| }); |
| this._allSelected = true; |
| this._indeterminate = true; |
| } |
| else { |
| this._data.forEach(function (row) { |
| // checking which ones are being toggled |
| if (_this.isRowSelected(row)) { |
| toggledRows.push(row); |
| /** @type {?} */ |
| var modelRow = _this.value.filter(function (val) { |
| return _this.compareWith(row, val); |
| })[0]; |
| /** @type {?} */ |
| var index = _this.value.indexOf(modelRow); |
| if (index > -1) { |
| _this.value.splice(index, 1); |
| } |
| } |
| }); |
| this._allSelected = false; |
| this._indeterminate = false; |
| } |
| this.onSelectAll.emit({ rows: toggledRows, selected: checked }); |
| this.onChange(this.value); |
| }; |
| /** |
| * Checks if row is selected |
| */ |
| /** |
| * Checks if row is selected |
| * @param {?} row |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.isRowSelected = /** |
| * Checks if row is selected |
| * @param {?} row |
| * @return {?} |
| */ |
| function (row) { |
| var _this = this; |
| // compare items by [compareWith] function |
| return this.value ? this.value.filter(function (val) { |
| return _this.compareWith(row, val); |
| }).length > 0 : false; |
| }; |
| /** |
| * Selects or clears a row depending on 'checked' value if the row 'isSelectable' |
| * handles cntrl clicks and shift clicks for multi-select |
| */ |
| /** |
| * Selects or clears a row depending on 'checked' value if the row 'isSelectable' |
| * handles cntrl clicks and shift clicks for multi-select |
| * @param {?} row |
| * @param {?} event |
| * @param {?} currentSelected |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.select = /** |
| * Selects or clears a row depending on 'checked' value if the row 'isSelectable' |
| * handles cntrl clicks and shift clicks for multi-select |
| * @param {?} row |
| * @param {?} event |
| * @param {?} currentSelected |
| * @return {?} |
| */ |
| function (row, event, currentSelected) { |
| if (this.selectable) { |
| this.blockEvent(event); |
| // Check to see if Shift key is selected and need to select everything in between |
| /** @type {?} */ |
| var mouseEvent = (/** @type {?} */ (event)); |
| if (this.multiple && mouseEvent && mouseEvent.shiftKey && this._lastSelectedIndex > -1) { |
| /** @type {?} */ |
| var firstIndex = currentSelected; |
| /** @type {?} */ |
| var lastIndex = this._lastSelectedIndex; |
| if (currentSelected > this._lastSelectedIndex) { |
| firstIndex = this._lastSelectedIndex; |
| lastIndex = currentSelected; |
| } |
| // if clicking a checkbox behind the initial check, then toggle all selections expect the initial checkbox |
| // else the checkboxes clicked are all after the initial one |
| if ((this._firstSelectedIndex >= currentSelected && this._lastSelectedIndex > this._firstSelectedIndex) || |
| (this._firstSelectedIndex <= currentSelected && this._lastSelectedIndex < this._firstSelectedIndex)) { |
| for (var i = firstIndex; i <= lastIndex; i++) { |
| if (this._firstSelectedIndex !== i) { |
| this._doSelection(this._data[i], i); |
| } |
| } |
| } |
| else if ((this._firstSelectedIndex > currentSelected) || (this._firstSelectedIndex < currentSelected)) { |
| // change indexes depending on where the next checkbox is selected (before or after) |
| if (this._firstSelectedIndex > currentSelected) { |
| lastIndex--; |
| } |
| else if (this._firstSelectedIndex < currentSelected) { |
| firstIndex++; |
| } |
| for (var i = firstIndex; i <= lastIndex; i++) { |
| /** @type {?} */ |
| var rowSelected = this.isRowSelected(this._data[i]); |
| // if row is selected and first checkbox was selected |
| // or if row was unselected and first checkbox was unselected |
| // we ignore the toggle |
| if ((this._firstCheckboxValue && !rowSelected) || |
| (!this._firstCheckboxValue && rowSelected)) { |
| this._doSelection(this._data[i], i); |
| } |
| else if (this._shiftPreviouslyPressed) { |
| // else if the checkbox selected was in the middle of the last selection and the first selection |
| // then we undo the selections |
| if ((currentSelected >= this._firstSelectedIndex && currentSelected <= this._lastSelectedIndex) || |
| (currentSelected <= this._firstSelectedIndex && currentSelected >= this._lastSelectedIndex)) { |
| this._doSelection(this._data[i], i); |
| } |
| } |
| } |
| } |
| this._shiftPreviouslyPressed = true; |
| // if shift wasnt pressed, then we take the element checked as the first row |
| // incase the next click uses shift |
| } |
| else if (mouseEvent && !mouseEvent.shiftKey) { |
| this._firstCheckboxValue = this._doSelection(row, currentSelected); |
| this._shiftPreviouslyPressed = false; |
| this._firstSelectedIndex = currentSelected; |
| } |
| this._lastSelectedIndex = currentSelected; |
| } |
| }; |
| /** |
| * Overrides the onselectstart method of the document so other text on the page |
| * doesn't get selected when doing shift selections. |
| */ |
| /** |
| * Overrides the onselectstart method of the document so other text on the page |
| * doesn't get selected when doing shift selections. |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.disableTextSelection = /** |
| * Overrides the onselectstart method of the document so other text on the page |
| * doesn't get selected when doing shift selections. |
| * @return {?} |
| */ |
| function () { |
| if (this._document) { |
| this._document.onselectstart = function () { |
| return false; |
| }; |
| } |
| }; |
| /** |
| * Resets the original onselectstart method. |
| */ |
| /** |
| * Resets the original onselectstart method. |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.enableTextSelection = /** |
| * Resets the original onselectstart method. |
| * @return {?} |
| */ |
| function () { |
| if (this._document) { |
| this._document.onselectstart = undefined; |
| } |
| }; |
| /** |
| * emits the onRowClickEvent when a row is clicked |
| * if clickable is true and selectable is false then select the row |
| */ |
| /** |
| * emits the onRowClickEvent when a row is clicked |
| * if clickable is true and selectable is false then select the row |
| * @param {?} row |
| * @param {?} index |
| * @param {?} event |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.handleRowClick = /** |
| * emits the onRowClickEvent when a row is clicked |
| * if clickable is true and selectable is false then select the row |
| * @param {?} row |
| * @param {?} index |
| * @param {?} event |
| * @return {?} |
| */ |
| function (row, index, event) { |
| if (this.clickable) { |
| // ignoring linting rules here because attribute it actually null or not there |
| // can't check for undefined |
| /** @type {?} */ |
| var srcElement = event.srcElement || event.currentTarget; |
| /** @type {?} */ |
| var element = (/** @type {?} */ (event.target)); |
| /* tslint:disable-next-line */ |
| if (srcElement.getAttribute('stopRowClick') === null && element.tagName.toLowerCase() !== 'mat-pseudo-checkbox') { |
| this.onRowClick.emit({ |
| row: row, |
| index: index, |
| }); |
| } |
| } |
| }; |
| /** |
| * Method handle for sort click event in column headers. |
| */ |
| /** |
| * Method handle for sort click event in column headers. |
| * @param {?} column |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.handleSort = /** |
| * Method handle for sort click event in column headers. |
| * @param {?} column |
| * @return {?} |
| */ |
| function (column) { |
| if (this._sortBy === column) { |
| this._sortOrder = this._sortOrder === TdDataTableSortingOrder.Ascending ? |
| TdDataTableSortingOrder.Descending : TdDataTableSortingOrder.Ascending; |
| } |
| else { |
| this._sortBy = column; |
| this._sortOrder = TdDataTableSortingOrder.Ascending; |
| } |
| this.onSortChange.next({ name: this._sortBy.name, order: this._sortOrder }); |
| }; |
| /** |
| * Handle all keyup events when focusing a data table row |
| */ |
| /** |
| * Handle all keyup events when focusing a data table row |
| * @param {?} event |
| * @param {?} row |
| * @param {?} index |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._rowKeyup = /** |
| * Handle all keyup events when focusing a data table row |
| * @param {?} event |
| * @param {?} row |
| * @param {?} index |
| * @return {?} |
| */ |
| function (event, row, index) { |
| switch (event.keyCode) { |
| case ENTER: |
| case SPACE: |
| /** if user presses enter or space, the row should be selected */ |
| if (this.selectable) { |
| this._doSelection(this._data[this.fromRow + index], this.fromRow + index); |
| } |
| break; |
| case UP_ARROW: |
| /** |
| * if users presses the up arrow, we focus the prev row |
| * unless its the first row |
| */ |
| if (index > 0) { |
| this._rows.toArray()[index - 1].focus(); |
| } |
| this.blockEvent(event); |
| if (this.selectable && this.multiple && event.shiftKey && this.fromRow + index >= 0) { |
| this._doSelection(this._data[this.fromRow + index], this.fromRow + index); |
| } |
| break; |
| case DOWN_ARROW: |
| /** |
| * if users presses the down arrow, we focus the next row |
| * unless its the last row |
| */ |
| if (index < (this._rows.toArray().length - 1)) { |
| this._rows.toArray()[index + 1].focus(); |
| } |
| this.blockEvent(event); |
| if (this.selectable && this.multiple && event.shiftKey && this.fromRow + index < this._data.length) { |
| this._doSelection(this._data[this.fromRow + index], this.fromRow + index); |
| } |
| break; |
| default: |
| // default |
| } |
| }; |
| /** |
| * Sets column index of the dragged column and initial clientX of column |
| */ |
| /** |
| * Sets column index of the dragged column and initial clientX of column |
| * @param {?} index |
| * @param {?} event |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._handleStartColumnDrag = /** |
| * Sets column index of the dragged column and initial clientX of column |
| * @param {?} index |
| * @param {?} event |
| * @return {?} |
| */ |
| function (index, event) { |
| this._columnClientX = event.clientX; |
| this._resizingColumn = index; |
| }; |
| /** |
| * Calculates new width depending on new clientX of dragger column |
| */ |
| /** |
| * Calculates new width depending on new clientX of dragger column |
| * @param {?} event |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._handleColumnDrag = /** |
| * Calculates new width depending on new clientX of dragger column |
| * @param {?} event |
| * @return {?} |
| */ |
| function (event) { |
| // check if there was been a separator clicked for resize |
| if (this._resizingColumn !== undefined && event.clientX > 0) { |
| /** @type {?} */ |
| var xPosition = event.clientX; |
| // checks if the separator is being moved to try and resize the column, else dont do anything |
| if (xPosition > 0 && this._columnClientX > 0 && (xPosition - this._columnClientX) !== 0) { |
| // calculate the new width depending if making the column bigger or smaller |
| /** @type {?} */ |
| var proposedManualWidth = this._widths[this._resizingColumn].value + (xPosition - this._columnClientX); |
| // if the proposed new width is less than the projected min width of the column, use projected min width |
| if (proposedManualWidth < this._colElements.toArray()[this._resizingColumn].projectedWidth) { |
| proposedManualWidth = this._colElements.toArray()[this._resizingColumn].projectedWidth; |
| } |
| this.columns[this._resizingColumn].width = proposedManualWidth; |
| // update new x position for the resized column |
| this._onColumnResize.next(xPosition); |
| } |
| } |
| }; |
| /** |
| * Ends dragged flags |
| */ |
| /** |
| * Ends dragged flags |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._handleEndColumnDrag = /** |
| * Ends dragged flags |
| * @return {?} |
| */ |
| function () { |
| this._columnClientX = undefined; |
| this._resizingColumn = undefined; |
| }; |
| /** |
| * Method to prevent the default events |
| */ |
| /** |
| * Method to prevent the default events |
| * @param {?} event |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype.blockEvent = /** |
| * Method to prevent the default events |
| * @param {?} event |
| * @return {?} |
| */ |
| function (event) { |
| event.preventDefault(); |
| }; |
| /** |
| * @param {?} name |
| * @param {?} value |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._getNestedValue = /** |
| * @param {?} name |
| * @param {?} value |
| * @return {?} |
| */ |
| function (name, value) { |
| if (!(value instanceof Object) || !name) { |
| return value; |
| } |
| if (name.indexOf('.') > -1) { |
| /** @type {?} */ |
| var splitName = name.split(/\.(.+)/, 2); |
| return this._getNestedValue(splitName[1], value[splitName[0]]); |
| } |
| else { |
| return value[name]; |
| } |
| }; |
| /** |
| * Does the actual Row Selection |
| */ |
| /** |
| * Does the actual Row Selection |
| * @param {?} row |
| * @param {?} rowIndex |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._doSelection = /** |
| * Does the actual Row Selection |
| * @param {?} row |
| * @param {?} rowIndex |
| * @return {?} |
| */ |
| function (row, rowIndex) { |
| var _this = this; |
| /** @type {?} */ |
| var wasSelected = this.isRowSelected(row); |
| if (!wasSelected) { |
| if (!this._multiple) { |
| this.clearModel(); |
| } |
| this.value.push(row); |
| } |
| else { |
| // compare items by [compareWith] function |
| row = this.value.filter(function (val) { |
| return _this.compareWith(row, val); |
| })[0]; |
| /** @type {?} */ |
| var index = this.value.indexOf(row); |
| if (index > -1) { |
| this.value.splice(index, 1); |
| } |
| } |
| this._calculateCheckboxState(); |
| this.onRowSelect.emit({ row: row, index: rowIndex, selected: !wasSelected }); |
| this.onChange(this.value); |
| return !wasSelected; |
| }; |
| /** |
| * Calculate all the state of all checkboxes |
| */ |
| /** |
| * Calculate all the state of all checkboxes |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._calculateCheckboxState = /** |
| * Calculate all the state of all checkboxes |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| var e_1, _a; |
| if (this._data) { |
| this._allSelected = typeof this._data.find(function (d) { return !_this.isRowSelected(d); }) === 'undefined'; |
| this._indeterminate = false; |
| try { |
| for (var _b = tslib_1.__values(this._data), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var row = _c.value; |
| if (!this.isRowSelected(row)) { |
| continue; |
| } |
| this._indeterminate = true; |
| break; |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| } |
| }; |
| /** |
| * Calculates the widths for columns and cells depending on content |
| */ |
| /** |
| * Calculates the widths for columns and cells depending on content |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._calculateWidths = /** |
| * Calculates the widths for columns and cells depending on content |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| if (this._colElements && this._colElements.length) { |
| this._widths = []; |
| this._colElements.forEach(function (col, index) { |
| _this._adjustColumnWidth(index, _this._calculateWidth()); |
| }); |
| this._adjustColumnWidhts(); |
| this._changeDetectorRef.markForCheck(); |
| } |
| }; |
| /** |
| * Adjusts columns after calculation to see if they need to be recalculated. |
| */ |
| /** |
| * Adjusts columns after calculation to see if they need to be recalculated. |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._adjustColumnWidhts = /** |
| * Adjusts columns after calculation to see if they need to be recalculated. |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| /** @type {?} */ |
| var fixedTotalWidth = 0; |
| // get the number of total columns that have flexible widths (not fixed or hidden) |
| /** @type {?} */ |
| var flexibleWidths = this._widths.filter(function (width, index) { |
| if (_this.columns[index].hidden) { |
| return false; |
| } |
| if (width.limit || width.max || width.min) { |
| fixedTotalWidth += width.value; |
| } |
| return !width.limit && !width.max && !width.min; |
| }).length; |
| // calculate how much pixes are left that could be spread across |
| // the flexible columns |
| /** @type {?} */ |
| var recalculateHostWidth = 0; |
| if (fixedTotalWidth < this.hostWidth) { |
| recalculateHostWidth = this.hostWidth - fixedTotalWidth; |
| } |
| // if we have flexible columns and pixels to spare on them |
| // we try and spread the pixels across them |
| if (flexibleWidths && recalculateHostWidth) { |
| /** @type {?} */ |
| var newValue_1 = Math.floor(recalculateHostWidth / flexibleWidths); |
| /** @type {?} */ |
| var adjustedNumber_1 = 0; |
| // adjust the column widths with the spread pixels |
| this._widths.forEach(function (colWidth) { |
| if (_this._widths[colWidth.index].max && _this._widths[colWidth.index].value > newValue_1 || |
| _this._widths[colWidth.index].min && _this._widths[colWidth.index].value < newValue_1 || |
| !_this._widths[colWidth.index].limit) { |
| _this._adjustColumnWidth(colWidth.index, newValue_1); |
| adjustedNumber_1++; |
| } |
| }); |
| // if there are still columns that need to be recalculated, we start over |
| /** @type {?} */ |
| var newFlexibleWidths = this._widths.filter(function (width) { |
| return !width.limit && !width.max; |
| }).length; |
| if (newFlexibleWidths !== adjustedNumber_1 && newFlexibleWidths !== flexibleWidths) { |
| this._adjustColumnWidhts(); |
| } |
| } |
| }; |
| /** |
| * Adjusts a single column to see if it can be recalculated |
| */ |
| /** |
| * Adjusts a single column to see if it can be recalculated |
| * @param {?} index |
| * @param {?} value |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._adjustColumnWidth = /** |
| * Adjusts a single column to see if it can be recalculated |
| * @param {?} index |
| * @param {?} value |
| * @return {?} |
| */ |
| function (index, value) { |
| this._widths[index] = { |
| value: value, |
| index: index, |
| limit: false, |
| min: false, |
| max: false, |
| }; |
| // flag to see if we need to skip the min width projection |
| // depending if a width or min width has been provided |
| /** @type {?} */ |
| var skipMinWidthProjection = false; |
| if (this.columns[index]) { |
| // if the provided width has min/max, then we check to see if we need to set it |
| if (typeof this.columns[index].width === 'object') { |
| /** @type {?} */ |
| var widthOpts = (/** @type {?} */ (this.columns[index].width)); |
| // if the column width is less than the configured min, we override it |
| skipMinWidthProjection = (widthOpts && !!widthOpts.min); |
| if (widthOpts && widthOpts.min >= this._widths[index].value) { |
| this._widths[index].value = widthOpts.min; |
| this._widths[index].min = true; |
| // if the column width is more than the configured max, we override it |
| } |
| else if (widthOpts && widthOpts.max <= this._widths[index].value) { |
| this._widths[index].value = widthOpts.max; |
| this._widths[index].max = true; |
| } |
| // if it has a fixed width, then we just set it |
| } |
| else if (typeof this.columns[index].width === 'number') { |
| this._widths[index].value = (/** @type {?} */ (this.columns[index].width)); |
| skipMinWidthProjection = this._widths[index].limit = true; |
| } |
| } |
| // if there wasn't any width or min width provided, we set a min to what the column width min should be |
| if (!skipMinWidthProjection && |
| this._widths[index].value < this._colElements.toArray()[index].projectedWidth) { |
| this._widths[index].value = this._colElements.toArray()[index].projectedWidth; |
| this._widths[index].min = true; |
| this._widths[index].limit = false; |
| } |
| }; |
| /** |
| * Generic method to calculate column width |
| */ |
| /** |
| * Generic method to calculate column width |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._calculateWidth = /** |
| * Generic method to calculate column width |
| * @return {?} |
| */ |
| function () { |
| /** @type {?} */ |
| var renderedColumns = this.columns.filter(function (col) { return !col.hidden; }); |
| return Math.floor(this.hostWidth / renderedColumns.length); |
| }; |
| /** |
| * Method to calculate the rows to be rendered in the viewport |
| */ |
| /** |
| * Method to calculate the rows to be rendered in the viewport |
| * @return {?} |
| */ |
| TdDataTableComponent.prototype._calculateVirtualRows = /** |
| * Method to calculate the rows to be rendered in the viewport |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| /** @type {?} */ |
| var scrolledRows = 0; |
| if (this._data) { |
| this._totalHeight = 0; |
| /** @type {?} */ |
| var rowHeightSum_1 = 0; |
| // loop through all rows to see if we have their height cached |
| // and sum them all to calculate the total height |
| this._data.forEach(function (d, i) { |
| // iterate through all rows at first and assume all |
| // rows are the same height as the first one |
| if (!_this._rowHeightCache[i]) { |
| _this._rowHeightCache[i] = _this._rowHeightCache[0] || TD_VIRTUAL_DEFAULT_ROW_HEIGHT; |
| } |
| rowHeightSum_1 += _this._rowHeightCache[i]; |
| // check how many rows have been scrolled |
| if (_this._scrollVerticalOffset - rowHeightSum_1 > 0) { |
| scrolledRows++; |
| } |
| }); |
| this._totalHeight = rowHeightSum_1; |
| // set the initial row to be rendered taking into account the row offset |
| /** @type {?} */ |
| var fromRow = scrolledRows - TD_VIRTUAL_OFFSET; |
| this._fromRow = fromRow > 0 ? fromRow : 0; |
| /** @type {?} */ |
| var hostHeight = this._hostHeight; |
| /** @type {?} */ |
| var index = 0; |
| // calculate how many rows can fit in the viewport |
| while (hostHeight > 0) { |
| hostHeight -= this._rowHeightCache[this.fromRow + index]; |
| index++; |
| } |
| // set the last row to be rendered taking into account the row offset |
| /** @type {?} */ |
| var range = (index - 1) + (TD_VIRTUAL_OFFSET * 2); |
| /** @type {?} */ |
| var toRow = range + this.fromRow; |
| // if last row is greater than the total length, then we use the total length |
| if (isFinite(toRow) && toRow > this._data.length) { |
| toRow = this._data.length; |
| } |
| else if (!isFinite(toRow)) { |
| toRow = TD_VIRTUAL_OFFSET; |
| } |
| this._toRow = toRow; |
| } |
| else { |
| this._totalHeight = 0; |
| this._fromRow = 0; |
| this._toRow = 0; |
| } |
| /** @type {?} */ |
| var offset = 0; |
| // calculate the proper offset depending on how many rows have been scrolled |
| if (scrolledRows > TD_VIRTUAL_OFFSET) { |
| for (var index = 0; index < this.fromRow; index++) { |
| offset += this._rowHeightCache[index]; |
| } |
| } |
| this._offsetTransform = this._domSanitizer.bypassSecurityTrustStyle('translateY(' + (offset - this.totalHeight) + 'px)'); |
| if (this._data) { |
| this._virtualData = this.data.slice(this.fromRow, this.toRow); |
| } |
| // mark for check at the end of the queue so we are sure |
| // that the changes will be marked |
| Promise.resolve().then(function () { |
| _this._changeDetectorRef.markForCheck(); |
| }); |
| }; |
| TdDataTableComponent.decorators = [ |
| { type: Component, args: [{ |
| providers: [{ |
| provide: NG_VALUE_ACCESSOR, |
| useExisting: forwardRef(function () { return TdDataTableComponent; }), |
| multi: true, |
| }], |
| selector: 'td-data-table', |
| template: "<table td-data-table\n [style.left.px]=\"columnsLeftScroll\"\n [class.mat-selectable]=\"selectable\">\n <thead class=\"td-data-table-head\"\n (dragover)=\"_handleColumnDrag($event)\">\n <tr td-data-table-column-row>\n <th td-data-table-column class=\"mat-checkbox-column\" *ngIf=\"selectable\">\n <mat-checkbox\n #checkBoxAll\n *ngIf=\"multiple\"\n [disabled]=\"!hasData\"\n [indeterminate]=\"indeterminate && !allSelected && hasData\"\n [checked]=\"allSelected && hasData\"\n (click)=\"blockEvent($event); selectAll(!checkBoxAll.checked)\"\n (keyup.enter)=\"selectAll(!checkBoxAll.checked)\"\n (keyup.space)=\"selectAll(!checkBoxAll.checked)\"\n (keydown.space)=\"blockEvent($event)\">\n </mat-checkbox>\n </th>\n <th td-data-table-column\n #columnElement\n *ngFor=\"let column of columns; let i = index; let last = last\"\n [style.min-width.px]=\"getColumnWidth(i)\"\n [style.max-width.px]=\"getColumnWidth(i)\"\n [name]=\"column.name\"\n [numeric]=\"column.numeric\"\n [active]=\"(column.sortable || sortable) && column === sortByColumn\"\n [sortable]=\"column.sortable || (sortable && column.sortable !== false)\"\n [sortOrder]=\"sortOrderEnum\"\n [hidden]=\"column.hidden\"\n (sortChange)=\"handleSort(column)\">\n <span [matTooltip]=\"column.tooltip\">{{column.label}}</span>\n <span td-column-resizer\n *ngIf=\"resizableColumns\"\n draggable=\"true\"\n class=\"td-data-table-column-resizer\"\n [class.td-resizing]=\"i === resizingColumn\"\n (mousedown)=\"_handleStartColumnDrag(i, $event)\"\n (dragstart)=\"$event?.dataTransfer?.setData('text', '')\"\n (drag)=\"_handleColumnDrag($event)\"\n (dragend)=\"_handleEndColumnDrag()\"\n (mouseup)=\"_handleEndColumnDrag()\">\n <span class=\"td-data-table-column-separator\"></span>\n </span>\n </th>\n </tr>\n </thead>\n</table>\n<div #scrollableDiv class=\"td-data-table-scrollable\"\n (scroll)=\"handleScroll($event)\">\n <div [style.height.px]=\"totalHeight\"></div>\n <table td-data-table\n [style.transform]=\"offsetTransform\"\n [style.position]=\"'absolute'\"\n [class.mat-selectable]=\"selectable\"\n [class.mat-clickable]=\"clickable\">\n <tbody class=\"td-data-table-body\">\n <tr td-data-table-row\n #dtRow\n [tabIndex]=\"selectable ? 0 : -1\"\n [selected]=\"(clickable || selectable) && isRowSelected(row)\"\n *ngFor=\"let row of virtualData; let rowIndex = index\"\n (click)=\"handleRowClick(row, fromRow + rowIndex, $event)\"\n (keyup)=\"selectable && _rowKeyup($event, row, rowIndex)\"\n (keydown.space)=\"blockEvent($event)\"\n (keydown.shift.space)=\"blockEvent($event)\"\n (keydown.shift)=\"disableTextSelection()\"\n (keyup.shift)=\"enableTextSelection()\">\n <td td-data-table-cell class=\"mat-checkbox-cell\" *ngIf=\"selectable\">\n <mat-pseudo-checkbox\n [state]=\"dtRow.selected ? 'checked' : 'unchecked'\"\n (mousedown)=\"disableTextSelection()\"\n (mouseup)=\"enableTextSelection()\"\n stopRowClick\n (click)=\"select(row, $event, fromRow + rowIndex)\">\n </mat-pseudo-checkbox>\n </td>\n <td td-data-table-cell\n [numeric]=\"column.numeric\"\n [hidden]=\"column.hidden\"\n *ngFor=\"let column of columns; let i = index\"\n [style.min-width.px]=\"getColumnWidth(i)\"\n [style.max-width.px]=\"getColumnWidth(i)\">\n <span *ngIf=\"!getTemplateRef(column.name)\">{{column.format ? column.format(getCellValue(column, row)) : getCellValue(column, row)}}</span>\n <ng-template\n *ngIf=\"getTemplateRef(column.name)\"\n [ngTemplateOutlet]=\"getTemplateRef(column.name)\"\n [ngTemplateOutletContext]=\"{ value: getCellValue(column, row), row: row, column: column.name, index: rowIndex }\">\n </ng-template>\n </td>\n </tr>\n </tbody>\n </table>\n</div>\n<ng-content></ng-content>\n", |
| inputs: ['value'], |
| changeDetection: ChangeDetectionStrategy.OnPush, |
| styles: [":host{display:block;overflow:hidden}:host .td-data-table-scrollable{position:relative;overflow:auto;height:calc(100% - 56px)}.td-data-table-column-resizer{right:0;width:6px;cursor:col-resize}.td-data-table-column-resizer,.td-data-table-column-resizer .td-data-table-column-separator{position:absolute;height:100%;top:0}.td-data-table-column-resizer .td-data-table-column-separator{left:2px}.td-data-table-column-resizer.td-resizing{cursor:-webkit-grabbing}table.td-data-table{width:auto!important}table.td-data-table.mat-selectable tbody>tr.td-data-table-row{-webkit-transition:background-color .2s;transition:background-color .2s}table.td-data-table.mat-selectable .td-data-table-column:first-child>.td-data-table-column-content-wrapper,table.td-data-table.mat-selectable td.td-data-table-cell:first-child>.td-data-table-column-content-wrapper,table.td-data-table.mat-selectable th.td-data-table-column:first-child>.td-data-table-column-content-wrapper{width:18px;min-width:18px;padding:0 24px}table.td-data-table.mat-selectable .td-data-table-column:nth-child(2)>.td-data-table-column-content-wrapper,table.td-data-table.mat-selectable td.td-data-table-cell:nth-child(2)>.td-data-table-column-content-wrapper,table.td-data-table.mat-selectable th.td-data-table-column:nth-child(2)>.td-data-table-column-content-wrapper{padding-left:0}[dir=rtl] table.td-data-table.mat-selectable .td-data-table-column:nth-child(2)>.td-data-table-column-content-wrapper,[dir=rtl] table.td-data-table.mat-selectable td.td-data-table-cell:nth-child(2)>.td-data-table-column-content-wrapper,[dir=rtl] table.td-data-table.mat-selectable th.td-data-table-column:nth-child(2)>.td-data-table-column-content-wrapper{padding-right:0;padding-left:28px}table.td-data-table td.mat-checkbox-cell,table.td-data-table th.mat-checkbox-column{min-width:42px;width:42px;font-size:0!important}table.td-data-table td.mat-checkbox-cell mat-pseudo-checkbox,table.td-data-table th.mat-checkbox-column mat-pseudo-checkbox{width:18px;height:18px}::ng-deep table.td-data-table td.mat-checkbox-cell mat-pseudo-checkbox.mat-pseudo-checkbox-checked::after,::ng-deep table.td-data-table th.mat-checkbox-column mat-pseudo-checkbox.mat-pseudo-checkbox-checked::after{width:11px!important;height:4px!important}table.td-data-table td.mat-checkbox-cell mat-checkbox ::ng-deep .mat-checkbox-inner-container,table.td-data-table th.mat-checkbox-column mat-checkbox ::ng-deep .mat-checkbox-inner-container{width:18px;height:18px;margin:0}"] |
| }] } |
| ]; |
| /** @nocollapse */ |
| TdDataTableComponent.ctorParameters = function () { return [ |
| { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }, |
| { type: ElementRef }, |
| { type: DomSanitizer }, |
| { type: ChangeDetectorRef } |
| ]; }; |
| TdDataTableComponent.propDecorators = { |
| _templates: [{ type: ContentChildren, args: [TdDataTableTemplateDirective,] }], |
| _scrollableDiv: [{ type: ViewChild, args: ['scrollableDiv',] }], |
| _colElements: [{ type: ViewChildren, args: ['columnElement',] }], |
| _rows: [{ type: ViewChildren, args: [TdDataTableRowComponent,] }], |
| data: [{ type: Input, args: ['data',] }], |
| columns: [{ type: Input, args: ['columns',] }], |
| resizableColumns: [{ type: Input, args: ['resizableColumns',] }], |
| selectable: [{ type: Input, args: ['selectable',] }], |
| clickable: [{ type: Input, args: ['clickable',] }], |
| multiple: [{ type: Input, args: ['multiple',] }], |
| sortable: [{ type: Input, args: ['sortable',] }], |
| sortBy: [{ type: Input, args: ['sortBy',] }], |
| sortOrder: [{ type: Input, args: ['sortOrder',] }], |
| onSortChange: [{ type: Output, args: ['sortChange',] }], |
| onRowSelect: [{ type: Output, args: ['rowSelect',] }], |
| onRowClick: [{ type: Output, args: ['rowClick',] }], |
| onSelectAll: [{ type: Output, args: ['selectAll',] }], |
| compareWith: [{ type: Input, args: ['compareWith',] }] |
| }; |
| return TdDataTableComponent; |
| }(_TdDataTableMixinBase)); |
| export { TdDataTableComponent }; |
| if (false) { |
| /** |
| * responsive width calculations |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._resizeSubs; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._rowsChangedSubs; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._hostWidth; |
| /** |
| * manually resizable columns |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._resizableColumns; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._columnClientX; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._columnResizeSubs; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._resizingColumn; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._onColumnResize; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._widths; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._onResize; |
| /** |
| * column header reposition and viewpoort |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._verticalScrollSubs; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._horizontalScrollSubs; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._scrollHorizontalOffset; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._onHorizontalScroll; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._onVerticalScroll; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._rowHeightCache; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._totalHeight; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._hostHeight; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._scrollVerticalOffset; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._offsetTransform; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._fromRow; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._toRow; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._valueChangesSubs; |
| /** |
| * internal attributes |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._data; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._virtualData; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._columns; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._selectable; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._clickable; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._multiple; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._allSelected; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._indeterminate; |
| /** |
| * sorting |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._sortable; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._sortBy; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._sortOrder; |
| /** |
| * shift select |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._shiftPreviouslyPressed; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._lastSelectedIndex; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._firstSelectedIndex; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._firstCheckboxValue; |
| /** |
| * template fetching support |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype._templateMap; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._templates; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._scrollableDiv; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._colElements; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._rows; |
| /** |
| * sortChange?: function |
| * Event emitted when the column headers are clicked. [sortable] needs to be enabled. |
| * Emits an [ITdDataTableSortChangeEvent] implemented object. |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype.onSortChange; |
| /** |
| * rowSelect?: function |
| * Event emitted when a row is selected/deselected. [selectable] needs to be enabled. |
| * Emits an [ITdDataTableSelectEvent] implemented object. |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype.onRowSelect; |
| /** |
| * rowClick?: function |
| * Event emitted when a row is clicked. |
| * Emits an [ITdDataTableRowClickEvent] implemented object. |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype.onRowClick; |
| /** |
| * selectAll?: function |
| * Event emitted when all rows are selected/deselected by the all checkbox. [selectable] needs to be enabled. |
| * Emits an [ITdDataTableSelectAllEvent] implemented object. |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype.onSelectAll; |
| /** |
| * compareWith?: function(row, model): boolean |
| * Allows custom comparison between row and model to see if row is selected or not |
| * Default comparation is by reference |
| * @type {?} |
| */ |
| TdDataTableComponent.prototype.compareWith; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._document; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._elementRef; |
| /** @type {?} */ |
| TdDataTableComponent.prototype._domSanitizer; |
| } |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table.component.js","sourceRoot":"ng://@covalent/core/data-table/","sources":["data-table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, forwardRef, ChangeDetectionStrategy,\n         ChangeDetectorRef, ViewChild, OnDestroy, AfterViewInit,\n         ContentChildren, TemplateRef, AfterContentInit, QueryList, Inject,\n         Optional, ViewChildren, ElementRef, OnInit, AfterContentChecked } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { DomSanitizer, SafeStyle } from '@angular/platform-browser';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\n\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ENTER, SPACE, UP_ARROW, DOWN_ARROW } from '@angular/cdk/keycodes';\n\nimport { Observable, Subscription, Subject } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { TdDataTableRowComponent } from './data-table-row/data-table-row.component';\nimport { ITdDataTableSortChangeEvent, TdDataTableColumnComponent } from './data-table-column/data-table-column.component';\nimport { TdDataTableTemplateDirective } from './directives/data-table-template.directive';\n\nimport { IControlValueAccessor, mixinControlValueAccessor } from '@covalent/core/common';\n\nexport enum TdDataTableSortingOrder {\n  Ascending = 'ASC',\n  Descending = 'DESC',\n}\n\nexport interface ITdDataTableColumnWidth {\n  min?: number;\n  max?: number;\n}\n\nexport interface ITdDataTableColumn {\n  name: string;\n  label: string;\n  tooltip?: string;\n  numeric?: boolean;\n  format?: (value: any) => any;\n  nested?: boolean;\n  sortable?: boolean;\n  hidden?: boolean;\n  filter?: boolean;\n  width?: ITdDataTableColumnWidth | number;\n}\n\nexport interface ITdDataTableSelectEvent {\n  row: any;\n  selected: boolean;\n  index: number;\n}\n\nexport interface ITdDataTableSelectAllEvent {\n  rows: any[];\n  selected: boolean;\n}\n\nexport interface ITdDataTableRowClickEvent {\n  row: any;\n  index: number;\n}\n\nexport interface IInternalColumnWidth {\n  value: number;\n  limit: boolean;\n  index: number;\n  min?: boolean;\n  max?: boolean;\n}\n\n/**\n * Constant to set the rows offset before and after the viewport\n */\nconst TD_VIRTUAL_OFFSET: number = 2;\n\n/**\n * Constant to set default row height if none is provided\n */\nconst TD_VIRTUAL_DEFAULT_ROW_HEIGHT: number = 48;\n\nexport class TdDataTableBase {\n  constructor(public _changeDetectorRef: ChangeDetectorRef) {}\n}\n\n/* tslint:disable-next-line */\nexport const _TdDataTableMixinBase = mixinControlValueAccessor(TdDataTableBase, []);\n\n@Component({\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => TdDataTableComponent),\n    multi: true,\n  }],\n  selector: 'td-data-table',\n  styleUrls: ['./data-table.component.scss' ],\n  templateUrl: './data-table.component.html',\n  inputs: ['value'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TdDataTableComponent extends _TdDataTableMixinBase implements IControlValueAccessor, OnInit,\n                                          AfterContentInit, AfterContentChecked, AfterViewInit, OnDestroy {\n\n  /** responsive width calculations */\n  private _resizeSubs: Subscription;\n  private _rowsChangedSubs: Subscription;\n  private _hostWidth: number = 0;\n\n  /** manually resizable columns */\n  private _resizableColumns: boolean = false;\n  private _columnClientX: number = 0;\n  private _columnResizeSubs: Subscription;\n  private _resizingColumn: number;\n  private _onColumnResize: Subject<number> = new Subject<number>();\n\n  get resizingColumn(): number {\n    return this._resizingColumn;\n  }\n\n  get hostWidth(): number {\n    // if the checkboxes are rendered, we need to remove their width\n    // from the total width to calculate properly\n    if (this.selectable) {\n      return this._hostWidth - 42;\n    }\n    return this._hostWidth;\n  }\n\n  private _widths: IInternalColumnWidth[] = [];\n  private _onResize: Subject<void> = new Subject<void>();\n\n  /** column header reposition and viewpoort */\n  private _verticalScrollSubs: Subscription;\n  private _horizontalScrollSubs: Subscription;\n  private _scrollHorizontalOffset: number = 0;\n\n  private _onHorizontalScroll: Subject<number> = new Subject<number>();\n  private _onVerticalScroll: Subject<number> = new Subject<number>();\n\n  // Array of cached row heights to allow dynamic row heights\n  private _rowHeightCache: number[] = [];\n  // Total pseudo height of all the elements\n  private _totalHeight: number = 0;\n  // Total host height for the viewport\n  private _hostHeight: number = 0;\n  // Scrolled vertical pixels\n  private _scrollVerticalOffset: number = 0;\n  // Style to move the content a certain offset depending on scrolled offset\n  private _offsetTransform: SafeStyle;\n\n  // Variables that set from and to which rows will be rendered\n  private _fromRow: number = 0;\n  private _toRow: number = 0;\n\n  /**\n   * Returns the offset style with a proper calculation on how much it should move\n   * over the y axis of the total height\n   */\n  get offsetTransform(): SafeStyle {\n    return this._offsetTransform;\n  }\n\n  /**\n   * Returns the assumed total height of the rows\n   */\n  get totalHeight(): number {\n    return this._totalHeight;\n  }\n\n  /**\n   * Returns the initial row to render in the viewport\n   */\n  get fromRow(): number {\n    return this._fromRow;\n  }\n\n  /**\n   * Returns the last row to render in the viewport\n   */\n  get toRow(): number {\n    return this._toRow;\n  }\n\n  private _valueChangesSubs: Subscription;\n  /** internal attributes */\n  private _data: any[];\n  // data virtually iterated by component\n  private _virtualData: any[];\n  private _columns: ITdDataTableColumn[];\n  private _selectable: boolean = false;\n  private _clickable: boolean = false;\n  private _multiple: boolean = true;\n  private _allSelected: boolean = false;\n  private _indeterminate: boolean = false;\n\n  /** sorting */\n  private _sortable: boolean = false;\n  private _sortBy: ITdDataTableColumn;\n  private _sortOrder: TdDataTableSortingOrder = TdDataTableSortingOrder.Ascending;\n\n  /** shift select */\n  private _shiftPreviouslyPressed: boolean = false;\n  private _lastSelectedIndex: number = -1;\n  private _firstSelectedIndex: number = -1;\n  private _firstCheckboxValue: boolean = false;\n\n  /** template fetching support */\n  private _templateMap: Map<string, TemplateRef<any>> = new Map<string, TemplateRef<any>>();\n  @ContentChildren(TdDataTableTemplateDirective) _templates: QueryList<TdDataTableTemplateDirective>;\n\n  @ViewChild('scrollableDiv') _scrollableDiv: ElementRef;\n\n  @ViewChildren('columnElement') _colElements: QueryList<TdDataTableColumnComponent>;\n\n  @ViewChildren(TdDataTableRowComponent) _rows: QueryList<TdDataTableRowComponent>;\n\n  /**\n   * Returns scroll position to reposition column headers\n   */\n  get columnsLeftScroll(): number {\n    return this._scrollHorizontalOffset * -1;\n  }\n\n  /**\n   * Returns true if all values are selected.\n   */\n  get allSelected(): boolean {\n    return this._allSelected;\n  }\n\n  /**\n   * Returns true if all values are not deselected\n   * and at least one is.\n   */\n  get indeterminate(): boolean {\n    return this._indeterminate;\n  }\n\n  /**\n   * data?: {[key: string]: any}[]\n   * Sets the data to be rendered as rows.\n   */\n  @Input('data')\n  set data(data: any[]) {\n    this._data = data;\n    this._rowHeightCache = [];\n    Promise.resolve().then(() => {\n      this.refresh();\n      // scroll back to the top if the data has changed\n      this._scrollableDiv.nativeElement.scrollTop = 0;\n    });\n  }\n  get data(): any[] {\n    return this._data;\n  }\n\n  get virtualData(): any[] {\n    return this._virtualData;\n  }\n\n  /**\n   * columns?: ITdDataTableColumn[]\n   * Sets additional column configuration. [ITdDataTableColumn.name] has to exist in [data] as key.\n   * Defaults to [data] keys.\n   */\n  @Input('columns')\n  set columns(cols: ITdDataTableColumn[]) {\n    this._columns = cols;\n  }\n  get columns(): ITdDataTableColumn[] {\n    if (this._columns) {\n      return this._columns;\n    }\n\n    if (this.hasData) {\n      this._columns = [];\n      // if columns is undefined, use key in [data] rows as name and label for column headers.\n      let row: any = this._data[0];\n      Object.keys(row).forEach((k: string) => {\n        if (!this._columns.find((c: any) => c.name === k)) {\n          this._columns.push({ name: k, label: k });\n        }\n      });\n      return this._columns;\n    } else {\n      return [];\n    }\n  }\n\n  /**\n   * resizableColumns?: boolean\n   * Enables manual column resize.\n   * Defaults to 'false'\n   */\n  @Input('resizableColumns')\n  set resizableColumns(resizableColumns: boolean) {\n    this._resizableColumns = coerceBooleanProperty(resizableColumns);\n  }\n  get resizableColumns(): boolean {\n    return this._resizableColumns;\n  }\n\n  /**\n   * selectable?: boolean\n   * Enables row selection events, hover and selected row states.\n   * Defaults to 'false'\n   */\n  @Input('selectable')\n  set selectable(selectable: boolean) {\n    this._selectable = coerceBooleanProperty(selectable);\n  }\n  get selectable(): boolean {\n    return this._selectable;\n  }\n\n  /**\n   * clickable?: boolean\n   * Enables row click events, hover.\n   * Defaults to 'false'\n   */\n  @Input('clickable')\n  set clickable(clickable: boolean) {\n    this._clickable = coerceBooleanProperty(clickable);\n  }\n  get clickable(): boolean {\n    return this._clickable;\n  }\n\n  /**\n   * multiple?: boolean\n   * Enables multiple row selection. [selectable] needs to be enabled.\n   * Defaults to 'false'\n   */\n  @Input('multiple')\n  set multiple(multiple: boolean) {\n    this._multiple = coerceBooleanProperty(multiple);\n  }\n  get multiple(): boolean {\n    return this._multiple;\n  }\n\n  /**\n   * sortable?: boolean\n   * Enables sorting events, sort icons and active column states.\n   * Defaults to 'false'\n   */\n  @Input('sortable')\n  set sortable(sortable: boolean) {\n    this._sortable = coerceBooleanProperty(sortable);\n  }\n  get sortable(): boolean {\n    return this._sortable;\n  }\n\n  /**\n   * sortBy?: string\n   * Sets the active sort column. [sortable] needs to be enabled.\n   */\n  @Input('sortBy')\n  set sortBy(columnName: string) {\n    if (!columnName) {\n      return;\n    }\n    const column: ITdDataTableColumn = this.columns.find((c: any) => c.name === columnName);\n    if (!column) {\n      throw new Error('[sortBy] must be a valid column name');\n    }\n\n    this._sortBy = column;\n  }\n  get sortByColumn(): ITdDataTableColumn {\n    return this._sortBy;\n  }\n\n  /**\n   * sortOrder?: ['ASC' | 'DESC'] or TdDataTableSortingOrder\n   * Sets the sort order of the [sortBy] column. [sortable] needs to be enabled.\n   * Defaults to 'ASC' or TdDataTableSortingOrder.Ascending\n   */\n  @Input('sortOrder')\n  set sortOrder(order: 'ASC' | 'DESC') {\n    let sortOrder: string = order ? order.toUpperCase() : 'ASC';\n    if (sortOrder !== 'DESC' && sortOrder !== 'ASC') {\n      throw new Error('[sortOrder] must be empty, ASC or DESC');\n    }\n\n    this._sortOrder = sortOrder === 'ASC' ?\n      TdDataTableSortingOrder.Ascending : TdDataTableSortingOrder.Descending;\n  }\n  get sortOrderEnum(): TdDataTableSortingOrder {\n    return this._sortOrder;\n  }\n\n  get hasData(): boolean {\n    return this._data && this._data.length > 0;\n  }\n\n  /**\n   * sortChange?: function\n   * Event emitted when the column headers are clicked. [sortable] needs to be enabled.\n   * Emits an [ITdDataTableSortChangeEvent] implemented object.\n   */\n  @Output('sortChange') onSortChange: EventEmitter<ITdDataTableSortChangeEvent> =\n                                      new EventEmitter<ITdDataTableSortChangeEvent>();\n\n  /**\n   * rowSelect?: function\n   * Event emitted when a row is selected/deselected. [selectable] needs to be enabled.\n   * Emits an [ITdDataTableSelectEvent] implemented object.\n   */\n  @Output('rowSelect') onRowSelect: EventEmitter<ITdDataTableSelectEvent> = new EventEmitter<ITdDataTableSelectEvent>();\n\n  /**\n   * rowClick?: function\n   * Event emitted when a row is clicked.\n   * Emits an [ITdDataTableRowClickEvent] implemented object.\n   */\n  @Output('rowClick') onRowClick: EventEmitter<ITdDataTableRowClickEvent> = new EventEmitter<ITdDataTableRowClickEvent>();\n\n  /**\n   * selectAll?: function\n   * Event emitted when all rows are selected/deselected by the all checkbox. [selectable] needs to be enabled.\n   * Emits an [ITdDataTableSelectAllEvent] implemented object.\n   */\n  @Output('selectAll') onSelectAll: EventEmitter<ITdDataTableSelectAllEvent> =\n                                    new EventEmitter<ITdDataTableSelectAllEvent>();\n\n  constructor(@Optional() @Inject(DOCUMENT) private _document: any,\n              private _elementRef: ElementRef,\n              private _domSanitizer: DomSanitizer,\n              _changeDetectorRef: ChangeDetectorRef) {\n    super(_changeDetectorRef);\n  }\n\n  /**\n   * compareWith?: function(row, model): boolean\n   * Allows custom comparison between row and model to see if row is selected or not\n   * Default comparation is by reference\n   */\n  @Input('compareWith') compareWith: (row: any, model: any) => boolean = (row: any, model: any) => {\n    return row === model;\n  }\n\n  /**\n   * Initialize observable for resize and scroll events\n   */\n  ngOnInit(): void {\n    // initialize observable for resize calculations\n    this._resizeSubs = this._onResize.asObservable().subscribe(() => {\n      if (this._rows) {\n        this._rows.toArray().forEach((row: TdDataTableRowComponent, index: number) => {\n          this._rowHeightCache[this.fromRow + index] = row.height + 1;\n        });\n      }\n      this._calculateWidths();\n      this._calculateVirtualRows();\n    });\n\n    // initialize observable for column resize calculations\n    this._columnResizeSubs = this._onColumnResize.asObservable().pipe(\n      debounceTime(0),\n    ).subscribe((clientX: number) => {\n      this._columnClientX = clientX;\n      this._calculateWidths();\n      this._changeDetectorRef.markForCheck();\n    });\n    // initialize observable for scroll column header reposition\n    this._horizontalScrollSubs = this._onHorizontalScroll.asObservable()\n      .subscribe((horizontalScroll: number) => {\n      this._scrollHorizontalOffset = horizontalScroll;\n      this._changeDetectorRef.markForCheck();\n    });\n    // initialize observable for virtual scroll rendering\n    this._verticalScrollSubs = this._onVerticalScroll.asObservable()\n      .subscribe((verticalScroll: number) => {\n      this._scrollVerticalOffset = verticalScroll;\n      this._calculateVirtualRows();\n      this._changeDetectorRef.markForCheck();\n    });\n    this._valueChangesSubs = this.valueChanges.subscribe((value: any) => {\n      this.refresh();\n    });\n  }\n\n  /**\n   * Loads templates and sets them in a map for faster access.\n   */\n  ngAfterContentInit(): void {\n    for (let i: number = 0; i < this._templates.toArray().length; i++) {\n      this._templateMap.set(\n        this._templates.toArray()[i].tdDataTableTemplate,\n        this._templates.toArray()[i].templateRef,\n      );\n    }\n  }\n\n  /**\n   * Checks hosts native elements widths to see if it has changed (resize check)\n   */\n  ngAfterContentChecked(): void {\n    // check if the scroll has been reset when element is hidden\n    if (this._scrollVerticalOffset - this._scrollableDiv.nativeElement.scrollTop > 5) {\n      // scroll back to the top if element has been reset\n      this._onVerticalScroll.next(0);\n    }\n    if (this._elementRef.nativeElement) {\n      let newHostWidth: number = this._elementRef.nativeElement.getBoundingClientRect().width;\n      // if the width has changed then we throw a resize event.\n      if (this._hostWidth !== newHostWidth) {\n        setTimeout(() => {\n          this._hostWidth = newHostWidth;\n          this._onResize.next();\n        }, 0);\n      }\n    }\n    if (this._scrollableDiv.nativeElement) {\n      let newHostHeight: number = this._scrollableDiv.nativeElement.getBoundingClientRect().height;\n      // if the height of the viewport has changed, then we mark for check\n      if (this._hostHeight !== newHostHeight) {\n        this._hostHeight = newHostHeight;\n        this._calculateVirtualRows();\n        this._changeDetectorRef.markForCheck();\n      }\n    }\n  }\n\n  /**\n   * Registers to an observable that checks if all rows have been rendered\n   * so we can start calculating the widths\n   */\n  ngAfterViewInit(): void {\n    this._rowsChangedSubs = this._rows.changes.pipe(\n      debounceTime(0),\n    ).subscribe(() => {\n      this._onResize.next();\n    });\n    this._calculateVirtualRows();\n  }\n\n  /**\n   * Unsubscribes observables when data table is destroyed\n   */\n  ngOnDestroy(): void {\n    if (this._resizeSubs) {\n      this._resizeSubs.unsubscribe();\n    }\n    if (this._columnResizeSubs) {\n      this._columnResizeSubs.unsubscribe();\n    }\n    if (this._horizontalScrollSubs) {\n      this._horizontalScrollSubs.unsubscribe();\n    }\n    if (this._verticalScrollSubs) {\n      this._verticalScrollSubs.unsubscribe();\n    }\n    if (this._rowsChangedSubs) {\n      this._rowsChangedSubs.unsubscribe();\n    }\n    if (this._valueChangesSubs) {\n      this._valueChangesSubs.unsubscribe();\n    }\n  }\n\n  /**\n   * Method that gets executed every time there is a scroll event\n   * Calls the scroll observable\n   */\n  handleScroll(event: Event): void {\n    let element: HTMLElement = (<HTMLElement>event.target);\n    if (element) {\n      let horizontalScroll: number = element.scrollLeft;\n      if (this._scrollHorizontalOffset !== horizontalScroll) {\n        this._onHorizontalScroll.next(horizontalScroll);\n      }\n      let verticalScroll: number = element.scrollTop;\n      if (this._scrollVerticalOffset !== verticalScroll) {\n        this._onVerticalScroll.next(verticalScroll);\n      }\n    }\n  }\n\n  /**\n   * Returns the width needed for the columns via index\n   */\n  getColumnWidth(index: number): number {\n    if (this._widths[index]) {\n      return this._widths[index].value;\n    }\n    return undefined;\n  }\n\n  getCellValue(column: ITdDataTableColumn, value: any): string {\n    if (column.nested === undefined || column.nested) {\n      return this._getNestedValue(column.name, value);\n    }\n    return value[column.name];\n  }\n\n  /**\n   * Getter method for template references\n   */\n   getTemplateRef(name: string): TemplateRef<any> {\n     return this._templateMap.get(name);\n   }\n\n  /**\n   * Clears model (ngModel) of component by removing all values in array.\n   */\n  clearModel(): void {\n    this.value.splice(0, this.value.length);\n  }\n\n  /**\n   * Refreshes data table and rerenders [data] and [columns]\n   */\n  refresh(): void {\n    this._calculateVirtualRows();\n    this._calculateWidths();\n    this._calculateCheckboxState();\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Selects or clears all rows depending on 'checked' value.\n   */\n  selectAll(checked: boolean): void {\n    let toggledRows: any[] = [];\n    if (checked) {\n      this._data.forEach((row: any) => {\n        // skiping already selected rows\n        if (!this.isRowSelected(row)) {\n          this.value.push(row);\n          // checking which ones are being toggled\n          toggledRows.push(row);\n        }\n      });\n      this._allSelected = true;\n      this._indeterminate = true;\n    } else {\n      this._data.forEach((row: any) => {\n        // checking which ones are being toggled\n        if (this.isRowSelected(row)) {\n          toggledRows.push(row);\n          let modelRow: any = this.value.filter((val: any) => {\n            return this.compareWith(row, val);\n          })[0];\n          let index: number = this.value.indexOf(modelRow);\n          if (index > -1) {\n            this.value.splice(index, 1);\n          }\n        }\n      });\n      this._allSelected = false;\n      this._indeterminate = false;\n    }\n    this.onSelectAll.emit({rows: toggledRows, selected: checked});\n    this.onChange(this.value);\n  }\n\n  /**\n   * Checks if row is selected\n   */\n  isRowSelected(row: any): boolean {\n    // compare items by [compareWith] function\n    return this.value ? this.value.filter((val: any) => {\n      return this.compareWith(row, val);\n    }).length > 0 : false;\n  }\n\n  /**\n   * Selects or clears a row depending on 'checked' value if the row 'isSelectable'\n   * handles cntrl clicks and shift clicks for multi-select\n   */\n  select(row: any, event: Event, currentSelected: number): void {\n    if (this.selectable) {\n      this.blockEvent(event);\n      // Check to see if Shift key is selected and need to select everything in between\n      let mouseEvent: MouseEvent = event as MouseEvent;\n      if (this.multiple && mouseEvent && mouseEvent.shiftKey && this._lastSelectedIndex > -1) {\n        let firstIndex: number = currentSelected;\n        let lastIndex: number = this._lastSelectedIndex;\n        if (currentSelected > this._lastSelectedIndex) {\n          firstIndex = this._lastSelectedIndex;\n          lastIndex = currentSelected;\n        }\n        // if clicking a checkbox behind the initial check, then toggle all selections expect the initial checkbox\n        // else the checkboxes clicked are all after the initial one\n        if ((this._firstSelectedIndex >= currentSelected && this._lastSelectedIndex > this._firstSelectedIndex) ||\n           (this._firstSelectedIndex <= currentSelected && this._lastSelectedIndex < this._firstSelectedIndex)) {\n          for (let i: number = firstIndex; i <= lastIndex; i++) {\n            if (this._firstSelectedIndex !== i) {\n              this._doSelection(this._data[i], i);\n            }\n          }\n        } else if ((this._firstSelectedIndex > currentSelected) || (this._firstSelectedIndex < currentSelected)) {\n          // change indexes depending on where the next checkbox is selected (before or after)\n          if (this._firstSelectedIndex > currentSelected) {\n            lastIndex--;\n          } else if (this._firstSelectedIndex < currentSelected) {\n            firstIndex++;\n          }\n          for (let i: number = firstIndex; i <= lastIndex; i++) {\n            let rowSelected: boolean = this.isRowSelected(this._data[i]);\n            // if row is selected and first checkbox was selected\n            // or if row was unselected and first checkbox was unselected\n            // we ignore the toggle\n            if ((this._firstCheckboxValue && !rowSelected) ||\n                (!this._firstCheckboxValue && rowSelected)) {\n              this._doSelection(this._data[i], i);\n            } else if (this._shiftPreviouslyPressed) {\n              // else if the checkbox selected was in the middle of the last selection and the first selection\n              // then we undo the selections\n              if ((currentSelected >= this._firstSelectedIndex && currentSelected <= this._lastSelectedIndex) ||\n                  (currentSelected <= this._firstSelectedIndex && currentSelected >= this._lastSelectedIndex)) {\n                this._doSelection(this._data[i], i);\n              }\n            }\n          }\n        }\n        this._shiftPreviouslyPressed = true;\n      // if shift wasnt pressed, then we take the element checked as the first row\n      // incase the next click uses shift\n      } else if (mouseEvent && !mouseEvent.shiftKey) {\n        this._firstCheckboxValue = this._doSelection(row, currentSelected);\n        this._shiftPreviouslyPressed = false;\n        this._firstSelectedIndex = currentSelected;\n      }\n      this._lastSelectedIndex = currentSelected;\n    }\n  }\n\n  /**\n   * Overrides the onselectstart method of the document so other text on the page\n   * doesn't get selected when doing shift selections.\n   */\n  disableTextSelection(): void {\n    if (this._document) {\n      this._document.onselectstart = function(): boolean {\n        return false;\n      };\n    }\n  }\n\n  /**\n   * Resets the original onselectstart method.\n   */\n  enableTextSelection(): void {\n    if (this._document) {\n      this._document.onselectstart = undefined;\n    }\n  }\n\n  /**\n   * emits the onRowClickEvent when a row is clicked\n   * if clickable is true and selectable is false then select the row\n   */\n  handleRowClick(row: any, index: number, event: Event): void {\n    if (this.clickable) {\n      // ignoring linting rules here because attribute it actually null or not there\n      // can't check for undefined\n      const srcElement: any = event.srcElement || event.currentTarget;\n      let element: HTMLElement = event.target as HTMLElement;\n      /* tslint:disable-next-line */\n      if (srcElement.getAttribute('stopRowClick') === null && element.tagName.toLowerCase() !== 'mat-pseudo-checkbox') {\n        this.onRowClick.emit({\n          row: row,\n          index: index,\n        });\n      }\n    }\n  }\n\n  /**\n   * Method handle for sort click event in column headers.\n   */\n  handleSort(column: ITdDataTableColumn): void {\n    if (this._sortBy === column) {\n      this._sortOrder = this._sortOrder === TdDataTableSortingOrder.Ascending ?\n        TdDataTableSortingOrder.Descending : TdDataTableSortingOrder.Ascending;\n    } else {\n      this._sortBy = column;\n      this._sortOrder = TdDataTableSortingOrder.Ascending;\n    }\n    this.onSortChange.next({ name: this._sortBy.name, order: this._sortOrder });\n  }\n\n  /**\n   * Handle all keyup events when focusing a data table row\n   */\n  _rowKeyup(event: KeyboardEvent, row: any, index: number): void {\n    switch (event.keyCode) {\n      case ENTER:\n      case SPACE:\n        /** if user presses enter or space, the row should be selected */\n        if (this.selectable) {\n          this._doSelection(this._data[this.fromRow + index], this.fromRow + index);\n        }\n        break;\n      case UP_ARROW:\n        /**\n         * if users presses the up arrow, we focus the prev row\n         * unless its the first row\n         */\n        if (index > 0) {\n          this._rows.toArray()[index - 1].focus();\n        }\n        this.blockEvent(event);\n        if (this.selectable && this.multiple && event.shiftKey && this.fromRow + index >= 0) {\n          this._doSelection(this._data[this.fromRow + index], this.fromRow + index);\n        }\n        break;\n      case DOWN_ARROW:\n        /**\n         * if users presses the down arrow, we focus the next row\n         * unless its the last row\n         */\n        if (index < (this._rows.toArray().length - 1)) {\n          this._rows.toArray()[index + 1].focus();\n        }\n        this.blockEvent(event);\n        if (this.selectable && this.multiple && event.shiftKey && this.fromRow + index < this._data.length) {\n          this._doSelection(this._data[this.fromRow + index], this.fromRow + index);\n        }\n        break;\n      default:\n        // default\n    }\n  }\n\n  /**\n   * Sets column index of the dragged column and initial clientX of column\n   */\n  _handleStartColumnDrag(index: number, event: MouseEvent): void {\n    this._columnClientX = event.clientX;\n    this._resizingColumn = index;\n  }\n\n  /**\n   * Calculates new width depending on new clientX of dragger column\n   */\n  _handleColumnDrag(event: MouseEvent | DragEvent): void {\n    // check if there was been a separator clicked for resize\n    if (this._resizingColumn !== undefined && event.clientX > 0) {\n      let xPosition: number = event.clientX;\n      // checks if the separator is being moved to try and resize the column, else dont do anything\n      if (xPosition > 0 && this._columnClientX > 0 && (xPosition - this._columnClientX) !== 0) {\n        // calculate the new width depending if making the column bigger or smaller\n        let proposedManualWidth: number = this._widths[this._resizingColumn].value + (xPosition - this._columnClientX);\n        // if the proposed new width is less than the projected min width of the column, use projected min width\n        if (proposedManualWidth < this._colElements.toArray()[this._resizingColumn].projectedWidth) {\n          proposedManualWidth = this._colElements.toArray()[this._resizingColumn].projectedWidth;\n        }\n        this.columns[this._resizingColumn].width = proposedManualWidth;\n        // update new x position for the resized column\n        this._onColumnResize.next(xPosition);\n      }\n    }\n  }\n\n  /**\n   * Ends dragged flags\n   */\n  _handleEndColumnDrag(): void {\n    this._columnClientX = undefined;\n    this._resizingColumn = undefined;\n  }\n\n  /**\n   * Method to prevent the default events\n   */\n  blockEvent(event: Event): void {\n    event.preventDefault();\n  }\n\n  private _getNestedValue(name: string, value: any): string {\n    if (!(value instanceof Object) || !name) {\n      return value;\n    }\n    if (name.indexOf('.') > -1) {\n      let splitName: string[] = name.split(/\\.(.+)/, 2);\n      return this._getNestedValue(splitName[1], value[splitName[0]]);\n    } else {\n      return value[name];\n    }\n  }\n\n  /**\n   * Does the actual Row Selection\n   */\n  private _doSelection(row: any, rowIndex: number): boolean {\n    let wasSelected: boolean = this.isRowSelected(row);\n    if (!wasSelected) {\n      if (!this._multiple) {\n        this.clearModel();\n      }\n      this.value.push(row);\n    } else {\n      // compare items by [compareWith] function\n      row = this.value.filter((val: any) => {\n        return this.compareWith(row, val);\n      })[0];\n      let index: number = this.value.indexOf(row);\n      if (index > -1) {\n        this.value.splice(index, 1);\n      }\n    }\n    this._calculateCheckboxState();\n    this.onRowSelect.emit({row: row, index: rowIndex, selected: !wasSelected});\n    this.onChange(this.value);\n    return !wasSelected;\n  }\n\n  /**\n   * Calculate all the state of all checkboxes\n   */\n  private _calculateCheckboxState(): void {\n    if (this._data) {\n      this._allSelected = typeof this._data.find((d: any) => !this.isRowSelected(d)) === 'undefined';\n      this._indeterminate = false;\n      for (let row of this._data) {\n        if (!this.isRowSelected(row)) {\n          continue;\n        }\n        this._indeterminate = true;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Calculates the widths for columns and cells depending on content\n   */\n  private _calculateWidths(): void {\n    if (this._colElements && this._colElements.length) {\n      this._widths = [];\n      this._colElements.forEach((col: TdDataTableColumnComponent, index: number) => {\n        this._adjustColumnWidth(index, this._calculateWidth());\n      });\n      this._adjustColumnWidhts();\n      this._changeDetectorRef.markForCheck();\n    }\n  }\n\n  /**\n   * Adjusts columns after calculation to see if they need to be recalculated.\n   */\n  private _adjustColumnWidhts(): void {\n    let fixedTotalWidth: number = 0;\n    // get the number of total columns that have flexible widths (not fixed or hidden)\n    let flexibleWidths: number = this._widths.filter((width: IInternalColumnWidth, index: number) => {\n      if (this.columns[index].hidden) {\n        return false;\n      }\n      if (width.limit || width.max || width.min) {\n        fixedTotalWidth += width.value;\n      }\n      return !width.limit && !width.max && !width.min;\n    }).length;\n    // calculate how much pixes are left that could be spread across\n    // the flexible columns\n    let recalculateHostWidth: number = 0;\n    if (fixedTotalWidth < this.hostWidth) {\n      recalculateHostWidth = this.hostWidth - fixedTotalWidth;\n    }\n    // if we have flexible columns and pixels to spare on them\n    // we try and spread the pixels across them\n    if (flexibleWidths && recalculateHostWidth) {\n      let newValue: number = Math.floor(recalculateHostWidth / flexibleWidths);\n      let adjustedNumber: number = 0;\n      // adjust the column widths with the spread pixels\n      this._widths.forEach((colWidth: IInternalColumnWidth) => {\n        if (this._widths[colWidth.index].max && this._widths[colWidth.index].value > newValue ||\n            this._widths[colWidth.index].min && this._widths[colWidth.index].value < newValue ||\n            !this._widths[colWidth.index].limit) {\n          this._adjustColumnWidth(colWidth.index, newValue);\n          adjustedNumber++;\n        }\n      });\n      // if there are still columns that need to be recalculated, we start over\n      let newFlexibleWidths: number = this._widths.filter((width: IInternalColumnWidth) => {\n        return !width.limit && !width.max;\n      }).length;\n      if (newFlexibleWidths !== adjustedNumber && newFlexibleWidths !== flexibleWidths) {\n        this._adjustColumnWidhts();\n      }\n    }\n  }\n\n  /**\n   * Adjusts a single column to see if it can be recalculated\n   */\n  private _adjustColumnWidth(index: number, value: number): void {\n    this._widths[index] = {\n      value: value,\n      index: index,\n      limit: false,\n      min: false,\n      max: false,\n    };\n    // flag to see if we need to skip the min width projection\n    // depending if a width or min width has been provided\n    let skipMinWidthProjection: boolean = false;\n    if (this.columns[index]) {\n      // if the provided width has min/max, then we check to see if we need to set it\n      if (typeof this.columns[index].width === 'object') {\n        let widthOpts: ITdDataTableColumnWidth = <ITdDataTableColumnWidth>this.columns[index].width;\n        // if the column width is less than the configured min, we override it\n        skipMinWidthProjection = (widthOpts && !!widthOpts.min);\n        if (widthOpts && widthOpts.min >= this._widths[index].value) {\n          this._widths[index].value = widthOpts.min;\n          this._widths[index].min = true;\n        // if the column width is more than the configured max, we override it\n        } else if (widthOpts && widthOpts.max <= this._widths[index].value) {\n          this._widths[index].value = widthOpts.max;\n          this._widths[index].max = true;\n        }\n      // if it has a fixed width, then we just set it\n      } else if (typeof this.columns[index].width === 'number') {\n        this._widths[index].value = <number>this.columns[index].width;\n        skipMinWidthProjection = this._widths[index].limit = true;\n      }\n    }\n    // if there wasn't any width or min width provided, we set a min to what the column width min should be\n    if (!skipMinWidthProjection &&\n        this._widths[index].value < this._colElements.toArray()[index].projectedWidth) {\n      this._widths[index].value = this._colElements.toArray()[index].projectedWidth;\n      this._widths[index].min = true;\n      this._widths[index].limit = false;\n    }\n  }\n\n  /**\n   * Generic method to calculate column width\n   */\n  private _calculateWidth(): number {\n    let renderedColumns: ITdDataTableColumn[] = this.columns.filter((col: ITdDataTableColumn) => !col.hidden);\n    return Math.floor(this.hostWidth / renderedColumns.length);\n  }\n\n  /**\n   * Method to calculate the rows to be rendered in the viewport\n   */\n  private _calculateVirtualRows(): void {\n    let scrolledRows: number = 0;\n    if (this._data) {\n      this._totalHeight = 0;\n      let rowHeightSum: number = 0;\n      // loop through all rows to see if we have their height cached\n      // and sum them all to calculate the total height\n      this._data.forEach((d: any, i: number) => {\n        // iterate through all rows at first and assume all\n        // rows are the same height as the first one\n        if (!this._rowHeightCache[i]) {\n          this._rowHeightCache[i] = this._rowHeightCache[0] || TD_VIRTUAL_DEFAULT_ROW_HEIGHT;\n        }\n        rowHeightSum += this._rowHeightCache[i];\n        // check how many rows have been scrolled\n        if (this._scrollVerticalOffset - rowHeightSum > 0) {\n          scrolledRows++;\n        }\n      });\n      this._totalHeight = rowHeightSum;\n      // set the initial row to be rendered taking into account the row offset\n      let fromRow: number = scrolledRows - TD_VIRTUAL_OFFSET;\n      this._fromRow = fromRow > 0 ? fromRow : 0;\n\n      let hostHeight: number = this._hostHeight;\n      let index: number = 0;\n      // calculate how many rows can fit in the viewport\n      while (hostHeight > 0) {\n        hostHeight -= this._rowHeightCache[this.fromRow + index];\n        index++;\n      }\n      // set the last row to be rendered taking into account the row offset\n      let range: number = (index - 1) + (TD_VIRTUAL_OFFSET * 2);\n      let toRow: number = range + this.fromRow;\n      // if last row is greater than the total length, then we use the total length\n      if (isFinite(toRow) && toRow > this._data.length) {\n        toRow = this._data.length;\n      } else if (!isFinite(toRow)) {\n        toRow = TD_VIRTUAL_OFFSET;\n      }\n      this._toRow = toRow;\n    } else {\n      this._totalHeight = 0;\n      this._fromRow = 0;\n      this._toRow = 0;\n    }\n\n    let offset: number = 0;\n    // calculate the proper offset depending on how many rows have been scrolled\n    if (scrolledRows > TD_VIRTUAL_OFFSET) {\n      for (let index: number = 0; index < this.fromRow; index++) {\n        offset += this._rowHeightCache[index];\n      }\n    }\n\n    this._offsetTransform = this._domSanitizer.bypassSecurityTrustStyle('translateY(' + (offset - this.totalHeight) + 'px)');\n    if (this._data) {\n      this._virtualData = this.data.slice(this.fromRow, this.toRow);\n    }\n    // mark for check at the end of the queue so we are sure\n    // that the changes will be marked\n    Promise.resolve().then(() => {\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n}\n"]} |