/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import * as tslib_1 from "tslib";
import { Component, Input, Output, ElementRef, EventEmitter, ViewChild, HostListener, ContentChildren, QueryList, HostBinding, ContentChild, KeyValueDiffers, ViewEncapsulation, ChangeDetectionStrategy, ChangeDetectorRef, SkipSelf, Optional, Inject } from '@angular/core';
import { DatatableGroupHeaderDirective } from './body/body-group-header.directive';
import { BehaviorSubject } from 'rxjs';
import { groupRowsByParents, optionalGetterForProp } from '../utils/tree';
import { setColumnDefaults, translateTemplates } from '../utils/column-helper';
import { ColumnMode } from '../types/column-mode.type';
import { SelectionType } from '../types/selection.type';
import { SortType } from '../types/sort.type';
import { ContextmenuType } from '../types/contextmenu.type';
import { DataTableColumnDirective } from './columns/column.directive';
import { DatatableRowDetailDirective } from './row-detail/row-detail.directive';
import { DatatableFooterDirective } from './footer/footer.directive';
import { DataTableBodyComponent } from './body/body.component';
import { DataTableHeaderComponent } from './header/header.component';
import { ScrollbarHelper } from '../services/scrollbar-helper.service';
import { ColumnChangesService } from '../services/column-changes.service';
import { DimensionsHelper } from '../services/dimensions-helper.service';
import { throttleable } from '../utils/throttle';
import { forceFillColumnWidths, adjustColumnWidths } from '../utils/math';
import { sortRows } from '../utils/sort';
export class DatatableComponent {
    /**
     * @param {?} scrollbarHelper
     * @param {?} dimensionsHelper
     * @param {?} cd
     * @param {?} element
     * @param {?} differs
     * @param {?} columnChangesService
     * @param {?} configuration
     */
    constructor(scrollbarHelper, dimensionsHelper, cd, element, differs, columnChangesService, configuration) {
        this.scrollbarHelper = scrollbarHelper;
        this.dimensionsHelper = dimensionsHelper;
        this.cd = cd;
        this.columnChangesService = columnChangesService;
        this.configuration = configuration;
        /**
         * List of row objects that should be
         * represented as selected in the grid.
         * Default value: `[]`
         */
        this.selected = [];
        /**
         * Enable vertical scrollbars
         */
        this.scrollbarV = false;
        /**
         * Enable horz scrollbars
         */
        this.scrollbarH = false;
        /**
         * The row height; which is necessary
         * to calculate the height for the lazy rendering.
         */
        this.rowHeight = 30;
        /**
         * Type of column width distribution formula.
         * Example: flex, force, standard
         */
        this.columnMode = ColumnMode.standard;
        /**
         * The minimum header height in pixels.
         * Pass a falsey for no header
         */
        this.headerHeight = 30;
        /**
         * The minimum footer height in pixels.
         * Pass falsey for no footer
         */
        this.footerHeight = 0;
        /**
         * If the table should use external paging
         * otherwise its assumed that all data is preloaded.
         */
        this.externalPaging = false;
        /**
         * If the table should use external sorting or
         * the built-in basic sorting.
         */
        this.externalSorting = false;
        /**
         * Show the linear loading bar.
         * Default value: `false`
         */
        this.loadingIndicator = false;
        /**
         * Enable/Disable ability to re-order columns
         * by dragging them.
         */
        this.reorderable = true;
        /**
         * Swap columns on re-order columns or
         * move them.
         */
        this.swapColumns = true;
        /**
         * The type of sorting
         */
        this.sortType = SortType.single;
        /**
         * Array of sorted columns by property and type.
         * Default value: `[]`
         */
        this.sorts = [];
        /**
         * Css class overrides
         */
        this.cssClasses = {
            sortAscending: 'datatable-icon-up',
            sortDescending: 'datatable-icon-down',
            pagerLeftArrow: 'datatable-icon-left',
            pagerRightArrow: 'datatable-icon-right',
            pagerPrevious: 'datatable-icon-prev',
            pagerNext: 'datatable-icon-skip'
        };
        /**
         * Message overrides for localization
         *
         * emptyMessage     [default] = 'No data to display'
         * totalMessage     [default] = 'total'
         * selectedMessage  [default] = 'selected'
         */
        this.messages = {
            // Message to show when array is presented
            // but contains no values
            emptyMessage: 'No data to display',
            // Footer total message
            totalMessage: 'total',
            // Footer selected message
            selectedMessage: 'selected'
        };
        /**
         * A boolean you can use to set the detault behaviour of rows and groups
         * whether they will start expanded or not. If ommited the default is NOT expanded.
         *
         */
        this.groupExpansionDefault = false;
        /**
         * Property to which you can use for determining select all
         * rows on current page or not.
         *
         * \@memberOf DatatableComponent
         */
        this.selectAllRowsOnPage = false;
        /**
         * A flag for row virtualization on / off
         */
        this.virtualization = true;
        /**
         * A flag for switching summary row on / off
         */
        this.summaryRow = false;
        /**
         * A height of summary row
         */
        this.summaryHeight = 30;
        /**
         * A property holds a summary row position: top/bottom
         */
        this.summaryPosition = 'top';
        /**
         * Body was scrolled typically in a `scrollbarV:true` scenario.
         */
        this.scroll = new EventEmitter();
        /**
         * A cell or row was focused via keyboard or mouse click.
         */
        this.activate = new EventEmitter();
        /**
         * A cell or row was selected.
         */
        this.select = new EventEmitter();
        /**
         * Column sort was invoked.
         */
        this.sort = new EventEmitter();
        /**
         * The table was paged either triggered by the pager or the body scroll.
         */
        this.page = new EventEmitter();
        /**
         * Columns were re-ordered.
         */
        this.reorder = new EventEmitter();
        /**
         * Column was resized.
         */
        this.resize = new EventEmitter();
        /**
         * The context menu was invoked on the table.
         * type indicates whether the header or the body was clicked.
         * content contains either the column or the row that was clicked.
         */
        this.tableContextmenu = new EventEmitter(false);
        /**
         * A row was expanded ot collapsed for tree
         */
        this.treeAction = new EventEmitter();
        this.rowCount = 0;
        this._offsetX = new BehaviorSubject(0);
        this._count = 0;
        this._offset = 0;
        this._subscriptions = [];
        /**
         * This will be used when displaying or selecting rows.
         * when tracking/comparing them, we'll use the value of this fn,
         *
         * (`fn(x) === fn(y)` instead of `x === y`)
         */
        this.rowIdentity = (/**
         * @param {?} x
         * @return {?}
         */
        (x) => {
            if (this._groupRowsBy) {
                // each group in groupedRows are stored as {key, value: [rows]},
                // where key is the groupRowsBy index
                return x.key;
            }
            else {
                return x;
            }
        });
        // get ref to elm for measuring
        this.element = element.nativeElement;
        this.rowDiffer = differs.find({}).create();
        // apply global settings from Module.forRoot
        if (this.configuration && this.configuration.messages) {
            this.messages = Object.assign({}, this.configuration.messages);
        }
    }
    /**
     * Rows that are displayed in the table.
     * @param {?} val
     * @return {?}
     */
    set rows(val) {
        this._rows = val;
        if (val) {
            this._internalRows = [...val];
        }
        // auto sort on new updates
        if (!this.externalSorting) {
            this.sortInternalRows();
        }
        // auto group by parent on new update
        this._internalRows = groupRowsByParents(this._internalRows, optionalGetterForProp(this.treeFromRelation), optionalGetterForProp(this.treeToRelation));
        // recalculate sizes/etc
        this.recalculate();
        if (this._rows && this._groupRowsBy) {
            // If a column has been specified in _groupRowsBy created a new array with the data grouped by that row
            this.groupedRows = this.groupArrayBy(this._rows, this._groupRowsBy);
        }
        this.cd.markForCheck();
    }
    /**
     * Gets the rows.
     * @return {?}
     */
    get rows() {
        return this._rows;
    }
    /**
     * This attribute allows the user to set the name of the column to group the data with
     * @param {?} val
     * @return {?}
     */
    set groupRowsBy(val) {
        if (val) {
            this._groupRowsBy = val;
            if (this._rows && this._groupRowsBy) {
                // cretes a new array with the data grouped
                this.groupedRows = this.groupArrayBy(this._rows, this._groupRowsBy);
            }
        }
    }
    /**
     * @return {?}
     */
    get groupRowsBy() {
        return this._groupRowsBy;
    }
    /**
     * Columns to be displayed.
     * @param {?} val
     * @return {?}
     */
    set columns(val) {
        if (val) {
            this._internalColumns = [...val];
            setColumnDefaults(this._internalColumns);
            this.recalculateColumns();
        }
        this._columns = val;
    }
    /**
     * Get the columns.
     * @return {?}
     */
    get columns() {
        return this._columns;
    }
    /**
     * The page size to be shown.
     * Default value: `undefined`
     * @param {?} val
     * @return {?}
     */
    set limit(val) {
        this._limit = val;
        // recalculate sizes/etc
        this.recalculate();
    }
    /**
     * Gets the limit.
     * @return {?}
     */
    get limit() {
        return this._limit;
    }
    /**
     * The total count of all rows.
     * Default value: `0`
     * @param {?} val
     * @return {?}
     */
    set count(val) {
        this._count = val;
        // recalculate sizes/etc
        this.recalculate();
    }
    /**
     * Gets the count.
     * @return {?}
     */
    get count() {
        return this._count;
    }
    /**
     * The current offset ( page - 1 ) shown.
     * Default value: `0`
     * @param {?} val
     * @return {?}
     */
    set offset(val) {
        this._offset = val;
    }
    /**
     * @return {?}
     */
    get offset() {
        return Math.max(Math.min(this._offset, Math.ceil(this.rowCount / this.pageSize) - 1), 0);
    }
    /**
     * CSS class applied if the header height if fixed height.
     * @return {?}
     */
    get isFixedHeader() {
        /** @type {?} */
        const headerHeight = this.headerHeight;
        return typeof headerHeight === 'string' ? (/** @type {?} */ (headerHeight)) !== 'auto' : true;
    }
    /**
     * CSS class applied to the root element if
     * the row heights are fixed heights.
     * @return {?}
     */
    get isFixedRow() {
        return this.rowHeight !== 'auto';
    }
    /**
     * CSS class applied to root element if
     * vertical scrolling is enabled.
     * @return {?}
     */
    get isVertScroll() {
        return this.scrollbarV;
    }
    /**
     * CSS class applied to root element if
     * virtualization is enabled.
     * @return {?}
     */
    get isVirtualized() {
        return this.virtualization;
    }
    /**
     * CSS class applied to the root element
     * if the horziontal scrolling is enabled.
     * @return {?}
     */
    get isHorScroll() {
        return this.scrollbarH;
    }
    /**
     * CSS class applied to root element is selectable.
     * @return {?}
     */
    get isSelectable() {
        return this.selectionType !== undefined;
    }
    /**
     * CSS class applied to root is checkbox selection.
     * @return {?}
     */
    get isCheckboxSelection() {
        return this.selectionType === SelectionType.checkbox;
    }
    /**
     * CSS class applied to root if cell selection.
     * @return {?}
     */
    get isCellSelection() {
        return this.selectionType === SelectionType.cell;
    }
    /**
     * CSS class applied to root if single select.
     * @return {?}
     */
    get isSingleSelection() {
        return this.selectionType === SelectionType.single;
    }
    /**
     * CSS class added to root element if mulit select
     * @return {?}
     */
    get isMultiSelection() {
        return this.selectionType === SelectionType.multi;
    }
    /**
     * CSS class added to root element if mulit click select
     * @return {?}
     */
    get isMultiClickSelection() {
        return this.selectionType === SelectionType.multiClick;
    }
    /**
     * Column templates gathered from `ContentChildren`
     * if described in your markup.
     * @param {?} val
     * @return {?}
     */
    set columnTemplates(val) {
        this._columnTemplates = val;
        this.translateColumns(val);
    }
    /**
     * Returns the column templates.
     * @return {?}
     */
    get columnTemplates() {
        return this._columnTemplates;
    }
    /**
     * Returns if all rows are selected.
     * @return {?}
     */
    get allRowsSelected() {
        /** @type {?} */
        let allRowsSelected = this.rows && this.selected && this.selected.length === this.rows.length;
        if (this.selectAllRowsOnPage) {
            /** @type {?} */
            const indexes = this.bodyComponent.indexes;
            /** @type {?} */
            const rowsOnPage = indexes.last - indexes.first;
            allRowsSelected = this.selected.length === rowsOnPage;
        }
        return this.selected && this.rows && this.rows.length !== 0 && allRowsSelected;
    }
    /**
     * Lifecycle hook that is called after data-bound
     * properties of a directive are initialized.
     * @return {?}
     */
    ngOnInit() {
        // need to call this immediatly to size
        // if the table is hidden the visibility
        // listener will invoke this itself upon show
        this.recalculate();
    }
    /**
     * Lifecycle hook that is called after a component's
     * view has been fully initialized.
     * @return {?}
     */
    ngAfterViewInit() {
        if (!this.externalSorting) {
            this.sortInternalRows();
        }
        // this has to be done to prevent the change detection
        // tree from freaking out because we are readjusting
        if (typeof requestAnimationFrame === 'undefined') {
            return;
        }
        requestAnimationFrame((/**
         * @return {?}
         */
        () => {
            this.recalculate();
            // emit page for virtual server-side kickoff
            if (this.externalPaging && this.scrollbarV) {
                this.page.emit({
                    count: this.count,
                    pageSize: this.pageSize,
                    limit: this.limit,
                    offset: 0
                });
            }
        }));
    }
    /**
     * Lifecycle hook that is called after a component's
     * content has been fully initialized.
     * @return {?}
     */
    ngAfterContentInit() {
        this.columnTemplates.changes.subscribe((/**
         * @param {?} v
         * @return {?}
         */
        v => this.translateColumns(v)));
        this.listenForColumnInputChanges();
    }
    /**
     * Translates the templates to the column objects
     * @param {?} val
     * @return {?}
     */
    translateColumns(val) {
        if (val) {
            /** @type {?} */
            const arr = val.toArray();
            if (arr.length) {
                this._internalColumns = translateTemplates(arr);
                setColumnDefaults(this._internalColumns);
                this.recalculateColumns();
                this.sortInternalRows();
                this.cd.markForCheck();
            }
        }
    }
    /**
     * Creates a map with the data grouped by the user choice of grouping index
     *
     * @param {?} originalArray the original array passed via parameter
     * @param {?} groupBy
     * @return {?}
     */
    groupArrayBy(originalArray, groupBy) {
        // create a map to hold groups with their corresponding results
        /** @type {?} */
        const map = new Map();
        /** @type {?} */
        let i = 0;
        originalArray.forEach((/**
         * @param {?} item
         * @return {?}
         */
        (item) => {
            /** @type {?} */
            const key = item[groupBy];
            if (!map.has(key)) {
                map.set(key, [item]);
            }
            else {
                map.get(key).push(item);
            }
            i++;
        }));
        /** @type {?} */
        const addGroup = (/**
         * @param {?} key
         * @param {?} value
         * @return {?}
         */
        (key, value) => {
            return { key, value };
        });
        // convert map back to a simple array of objects
        return Array.from(map, (/**
         * @param {?} x
         * @return {?}
         */
        x => addGroup(x[0], x[1])));
    }
    /*
       * Lifecycle hook that is called when Angular dirty checks a directive.
       */
    /**
     * @return {?}
     */
    ngDoCheck() {
        if (this.rowDiffer.diff(this.rows)) {
            if (!this.externalSorting) {
                this.sortInternalRows();
            }
            else {
                this._internalRows = [...this.rows];
            }
            // auto group by parent on new update
            this._internalRows = groupRowsByParents(this._internalRows, optionalGetterForProp(this.treeFromRelation), optionalGetterForProp(this.treeToRelation));
            this.recalculatePages();
            this.cd.markForCheck();
        }
    }
    /**
     * Recalc's the sizes of the grid.
     *
     * Updated automatically on changes to:
     *
     *  - Columns
     *  - Rows
     *  - Paging related
     *
     * Also can be manually invoked or upon window resize.
     * @return {?}
     */
    recalculate() {
        this.recalculateDims();
        this.recalculateColumns();
    }
    /**
     * Window resize handler to update sizes.
     * @return {?}
     */
    onWindowResize() {
        this.recalculate();
    }
    /**
     * Recalulcates the column widths based on column width
     * distribution mode and scrollbar offsets.
     * @param {?=} columns
     * @param {?=} forceIdx
     * @param {?=} allowBleed
     * @return {?}
     */
    recalculateColumns(columns = this._internalColumns, forceIdx = -1, allowBleed = this.scrollbarH) {
        if (!columns)
            return undefined;
        /** @type {?} */
        let width = this._innerWidth;
        if (this.scrollbarV) {
            width = width - this.scrollbarHelper.width;
        }
        if (this.columnMode === ColumnMode.force) {
            forceFillColumnWidths(columns, width, forceIdx, allowBleed);
        }
        else if (this.columnMode === ColumnMode.flex) {
            adjustColumnWidths(columns, width);
        }
        return columns;
    }
    /**
     * Recalculates the dimensions of the table size.
     * Internally calls the page size and row count calcs too.
     *
     * @return {?}
     */
    recalculateDims() {
        /** @type {?} */
        const dims = this.dimensionsHelper.getDimensions(this.element);
        this._innerWidth = Math.floor(dims.width);
        if (this.scrollbarV) {
            /** @type {?} */
            let height = dims.height;
            if (this.headerHeight)
                height = height - this.headerHeight;
            if (this.footerHeight)
                height = height - this.footerHeight;
            this.bodyHeight = height;
        }
        this.recalculatePages();
    }
    /**
     * Recalculates the pages after a update.
     * @return {?}
     */
    recalculatePages() {
        this.pageSize = this.calcPageSize();
        this.rowCount = this.calcRowCount();
    }
    /**
     * Body triggered a page event.
     * @param {?} __0
     * @return {?}
     */
    onBodyPage({ offset }) {
        // Avoid pagination caming from body events like scroll when the table
        // has no virtualization and the external paging is enable.
        // This means, let's the developer handle pagination by my him(her) self
        if (this.externalPaging && !this.virtualization) {
            return;
        }
        this.offset = offset;
        this.page.emit({
            count: this.count,
            pageSize: this.pageSize,
            limit: this.limit,
            offset: this.offset
        });
    }
    /**
     * The body triggered a scroll event.
     * @param {?} event
     * @return {?}
     */
    onBodyScroll(event) {
        this._offsetX.next(event.offsetX);
        this.scroll.emit(event);
        this.cd.detectChanges();
    }
    /**
     * The footer triggered a page event.
     * @param {?} event
     * @return {?}
     */
    onFooterPage(event) {
        this.offset = event.page - 1;
        this.bodyComponent.updateOffsetY(this.offset);
        this.page.emit({
            count: this.count,
            pageSize: this.pageSize,
            limit: this.limit,
            offset: this.offset
        });
        if (this.selectAllRowsOnPage) {
            this.selected = [];
            this.select.emit({
                selected: this.selected
            });
        }
    }
    /**
     * Recalculates the sizes of the page
     * @param {?=} val
     * @return {?}
     */
    calcPageSize(val = this.rows) {
        // Keep the page size constant even if the row has been expanded.
        // This is because an expanded row is still considered to be a child of
        // the original row.  Hence calculation would use rowHeight only.
        if (this.scrollbarV && this.virtualization) {
            /** @type {?} */
            const size = Math.ceil(this.bodyHeight / ((/** @type {?} */ (this.rowHeight))));
            return Math.max(size, 0);
        }
        // if limit is passed, we are paging
        if (this.limit !== undefined) {
            return this.limit;
        }
        // otherwise use row length
        if (val) {
            return val.length;
        }
        // other empty :(
        return 0;
    }
    /**
     * Calculates the row count.
     * @param {?=} val
     * @return {?}
     */
    calcRowCount(val = this.rows) {
        if (!this.externalPaging) {
            if (!val)
                return 0;
            if (this.groupedRows) {
                return this.groupedRows.length;
            }
            else if (this.treeFromRelation != null && this.treeToRelation != null) {
                return this._internalRows.length;
            }
            else {
                return val.length;
            }
        }
        return this.count;
    }
    /**
     * The header triggered a contextmenu event.
     * @param {?} __0
     * @return {?}
     */
    onColumnContextmenu({ event, column }) {
        this.tableContextmenu.emit({ event, type: ContextmenuType.header, content: column });
    }
    /**
     * The body triggered a contextmenu event.
     * @param {?} __0
     * @return {?}
     */
    onRowContextmenu({ event, row }) {
        this.tableContextmenu.emit({ event, type: ContextmenuType.body, content: row });
    }
    /**
     * The header triggered a column resize event.
     * @param {?} __0
     * @return {?}
     */
    onColumnResize({ column, newValue }) {
        /* Safari/iOS 10.2 workaround */
        if (column === undefined) {
            return;
        }
        /** @type {?} */
        let idx;
        /** @type {?} */
        const cols = this._internalColumns.map((/**
         * @param {?} c
         * @param {?} i
         * @return {?}
         */
        (c, i) => {
            c = Object.assign({}, c);
            if (c.$$id === column.$$id) {
                idx = i;
                c.width = newValue;
                // set this so we can force the column
                // width distribution to be to this value
                c.$$oldWidth = newValue;
            }
            return c;
        }));
        this.recalculateColumns(cols, idx);
        this._internalColumns = cols;
        this.resize.emit({
            column,
            newValue
        });
    }
    /**
     * The header triggered a column re-order event.
     * @param {?} __0
     * @return {?}
     */
    onColumnReorder({ column, newValue, prevValue }) {
        /** @type {?} */
        const cols = this._internalColumns.map((/**
         * @param {?} c
         * @return {?}
         */
        c => {
            return Object.assign({}, c);
        }));
        if (this.swapColumns) {
            /** @type {?} */
            const prevCol = cols[newValue];
            cols[newValue] = column;
            cols[prevValue] = prevCol;
        }
        else {
            if (newValue > prevValue) {
                /** @type {?} */
                const movedCol = cols[prevValue];
                for (let i = prevValue; i < newValue; i++) {
                    cols[i] = cols[i + 1];
                }
                cols[newValue] = movedCol;
            }
            else {
                /** @type {?} */
                const movedCol = cols[prevValue];
                for (let i = prevValue; i > newValue; i--) {
                    cols[i] = cols[i - 1];
                }
                cols[newValue] = movedCol;
            }
        }
        this._internalColumns = cols;
        this.reorder.emit({
            column,
            newValue,
            prevValue
        });
    }
    /**
     * The header triggered a column sort event.
     * @param {?} event
     * @return {?}
     */
    onColumnSort(event) {
        // clean selected rows
        if (this.selectAllRowsOnPage) {
            this.selected = [];
            this.select.emit({
                selected: this.selected
            });
        }
        this.sorts = event.sorts;
        // this could be optimized better since it will resort
        // the rows again on the 'push' detection...
        if (this.externalSorting === false) {
            // don't use normal setter so we don't resort
            this.sortInternalRows();
        }
        // auto group by parent on new update
        this._internalRows = groupRowsByParents(this._internalRows, optionalGetterForProp(this.treeFromRelation), optionalGetterForProp(this.treeToRelation));
        // Always go to first page when sorting to see the newly sorted data
        this.offset = 0;
        this.bodyComponent.updateOffsetY(this.offset);
        this.sort.emit(event);
    }
    /**
     * Toggle all row selection
     * @param {?} event
     * @return {?}
     */
    onHeaderSelect(event) {
        if (this.selectAllRowsOnPage) {
            // before we splice, chk if we currently have all selected
            /** @type {?} */
            const first = this.bodyComponent.indexes.first;
            /** @type {?} */
            const last = this.bodyComponent.indexes.last;
            /** @type {?} */
            const allSelected = this.selected.length === last - first;
            // remove all existing either way
            this.selected = [];
            // do the opposite here
            if (!allSelected) {
                this.selected.push(...this._internalRows.slice(first, last));
            }
        }
        else {
            // before we splice, chk if we currently have all selected
            /** @type {?} */
            const allSelected = this.selected.length === this.rows.length;
            // remove all existing either way
            this.selected = [];
            // do the opposite here
            if (!allSelected) {
                this.selected.push(...this.rows);
            }
        }
        this.select.emit({
            selected: this.selected
        });
    }
    /**
     * A row was selected from body
     * @param {?} event
     * @return {?}
     */
    onBodySelect(event) {
        this.select.emit(event);
    }
    /**
     * A row was expanded or collapsed for tree
     * @param {?} event
     * @return {?}
     */
    onTreeAction(event) {
        /** @type {?} */
        const row = event.row;
        // TODO: For duplicated items this will not work
        /** @type {?} */
        const rowIndex = this._rows.findIndex((/**
         * @param {?} r
         * @return {?}
         */
        r => r[this.treeToRelation] === event.row[this.treeToRelation]));
        this.treeAction.emit({ row, rowIndex });
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this._subscriptions.forEach((/**
         * @param {?} subscription
         * @return {?}
         */
        subscription => subscription.unsubscribe()));
    }
    /**
     * listen for changes to input bindings of all DataTableColumnDirective and
     * trigger the columnTemplates.changes observable to emit
     * @private
     * @return {?}
     */
    listenForColumnInputChanges() {
        this._subscriptions.push(this.columnChangesService.columnInputChanges$.subscribe((/**
         * @return {?}
         */
        () => {
            if (this.columnTemplates) {
                this.columnTemplates.notifyOnChanges();
            }
        })));
    }
    /**
     * @private
     * @return {?}
     */
    sortInternalRows() {
        this._internalRows = sortRows(this._internalRows, this._internalColumns, this.sorts);
    }
}
DatatableComponent.decorators = [
    { type: Component, args: [{
                selector: 'ngx-datatable',
                template: "<div visibilityObserver (visible)=\"recalculate()\">\n  <datatable-header\n    *ngIf=\"headerHeight\"\n    [sorts]=\"sorts\"\n    [sortType]=\"sortType\"\n    [scrollbarH]=\"scrollbarH\"\n    [innerWidth]=\"_innerWidth\"\n    [offsetX]=\"_offsetX | async\"\n    [dealsWithGroup]=\"groupedRows !== undefined\"\n    [columns]=\"_internalColumns\"\n    [headerHeight]=\"headerHeight\"\n    [reorderable]=\"reorderable\"\n    [targetMarkerTemplate]=\"targetMarkerTemplate\"\n    [sortAscendingIcon]=\"cssClasses.sortAscending\"\n    [sortDescendingIcon]=\"cssClasses.sortDescending\"\n    [allRowsSelected]=\"allRowsSelected\"\n    [selectionType]=\"selectionType\"\n    (sort)=\"onColumnSort($event)\"\n    (resize)=\"onColumnResize($event)\"\n    (reorder)=\"onColumnReorder($event)\"\n    (select)=\"onHeaderSelect($event)\"\n    (columnContextmenu)=\"onColumnContextmenu($event)\"\n  >\n  </datatable-header>\n  <datatable-body\n    [groupRowsBy]=\"groupRowsBy\"\n    [groupedRows]=\"groupedRows\"\n    [rows]=\"_internalRows\"\n    [groupExpansionDefault]=\"groupExpansionDefault\"\n    [scrollbarV]=\"scrollbarV\"\n    [scrollbarH]=\"scrollbarH\"\n    [virtualization]=\"virtualization\"\n    [loadingIndicator]=\"loadingIndicator\"\n    [externalPaging]=\"externalPaging\"\n    [rowHeight]=\"rowHeight\"\n    [rowCount]=\"rowCount\"\n    [offset]=\"offset\"\n    [trackByProp]=\"trackByProp\"\n    [columns]=\"_internalColumns\"\n    [pageSize]=\"pageSize\"\n    [offsetX]=\"_offsetX | async\"\n    [rowDetail]=\"rowDetail\"\n    [groupHeader]=\"groupHeader\"\n    [selected]=\"selected\"\n    [innerWidth]=\"_innerWidth\"\n    [bodyHeight]=\"bodyHeight\"\n    [selectionType]=\"selectionType\"\n    [emptyMessage]=\"messages.emptyMessage\"\n    [rowIdentity]=\"rowIdentity\"\n    [rowClass]=\"rowClass\"\n    [selectCheck]=\"selectCheck\"\n    [displayCheck]=\"displayCheck\"\n    [summaryRow]=\"summaryRow\"\n    [summaryHeight]=\"summaryHeight\"\n    [summaryPosition]=\"summaryPosition\"\n    (page)=\"onBodyPage($event)\"\n    (activate)=\"activate.emit($event)\"\n    (rowContextmenu)=\"onRowContextmenu($event)\"\n    (select)=\"onBodySelect($event)\"\n    (scroll)=\"onBodyScroll($event)\"\n    (treeAction)=\"onTreeAction($event)\"\n  >\n  </datatable-body>\n  <datatable-footer\n    *ngIf=\"footerHeight\"\n    [rowCount]=\"rowCount\"\n    [pageSize]=\"pageSize\"\n    [offset]=\"offset\"\n    [footerHeight]=\"footerHeight\"\n    [footerTemplate]=\"footer\"\n    [totalMessage]=\"messages.totalMessage\"\n    [pagerLeftArrowIcon]=\"cssClasses.pagerLeftArrow\"\n    [pagerRightArrowIcon]=\"cssClasses.pagerRightArrow\"\n    [pagerPreviousIcon]=\"cssClasses.pagerPrevious\"\n    [selectedCount]=\"selected.length\"\n    [selectedMessage]=\"!!selectionType && messages.selectedMessage\"\n    [pagerNextIcon]=\"cssClasses.pagerNext\"\n    (page)=\"onFooterPage($event)\"\n  >\n  </datatable-footer>\n</div>\n",
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                host: {
                    class: 'ngx-datatable'
                },
                styles: [".ngx-datatable{display:block;overflow:hidden;justify-content:center;position:relative;-webkit-transform:translate3d(0,0,0)}.ngx-datatable [hidden]{display:none!important}.ngx-datatable *,.ngx-datatable :after,.ngx-datatable :before{box-sizing:border-box}.ngx-datatable.scroll-vertical .datatable-body{overflow-y:auto}.ngx-datatable.scroll-vertical.virtualized .datatable-body .datatable-row-wrapper{position:absolute}.ngx-datatable.scroll-horz .datatable-body{overflow-x:auto;-webkit-overflow-scrolling:touch}.ngx-datatable.fixed-header .datatable-header .datatable-header-inner{white-space:nowrap}.ngx-datatable.fixed-header .datatable-header .datatable-header-inner .datatable-header-cell{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.ngx-datatable.fixed-row .datatable-scroll,.ngx-datatable.fixed-row .datatable-scroll .datatable-body-row{white-space:nowrap}.ngx-datatable.fixed-row .datatable-scroll .datatable-body-row .datatable-body-cell,.ngx-datatable.fixed-row .datatable-scroll .datatable-body-row .datatable-body-group-cell{overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.ngx-datatable .datatable-body-row,.ngx-datatable .datatable-header-inner,.ngx-datatable .datatable-row-center{display:flex;flex-direction:row;-o-flex-flow:row;flex-flow:row}.ngx-datatable .datatable-body-cell,.ngx-datatable .datatable-header-cell{overflow-x:hidden;vertical-align:top;display:inline-block;line-height:1.625}.ngx-datatable .datatable-body-cell:focus,.ngx-datatable .datatable-header-cell:focus{outline:0}.ngx-datatable .datatable-row-left,.ngx-datatable .datatable-row-right{z-index:9}.ngx-datatable .datatable-row-center,.ngx-datatable .datatable-row-group,.ngx-datatable .datatable-row-left,.ngx-datatable .datatable-row-right{position:relative}.ngx-datatable .datatable-header{display:block;overflow:hidden}.ngx-datatable .datatable-header .datatable-header-inner{align-items:stretch;-webkit-align-items:stretch}.ngx-datatable .datatable-header .datatable-header-cell{position:relative;display:inline-block}.ngx-datatable .datatable-header .datatable-header-cell.sortable .datatable-header-cell-wrapper{cursor:pointer}.ngx-datatable .datatable-header .datatable-header-cell.longpress .datatable-header-cell-wrapper{cursor:move}.ngx-datatable .datatable-header .datatable-header-cell .sort-btn{line-height:100%;vertical-align:middle;display:inline-block;cursor:pointer}.ngx-datatable .datatable-header .datatable-header-cell .resize-handle,.ngx-datatable .datatable-header .datatable-header-cell .resize-handle--not-resizable{display:inline-block;position:absolute;right:0;top:0;bottom:0;width:5px;padding:0 4px;visibility:hidden}.ngx-datatable .datatable-header .datatable-header-cell .resize-handle{cursor:ew-resize}.ngx-datatable .datatable-header .datatable-header-cell.resizeable:hover .resize-handle,.ngx-datatable .datatable-header .datatable-header-cell:hover .resize-handle--not-resizable{visibility:visible}.ngx-datatable .datatable-header .datatable-header-cell .targetMarker{position:absolute;top:0;bottom:0}.ngx-datatable .datatable-header .datatable-header-cell .targetMarker.dragFromLeft{right:0}.ngx-datatable .datatable-header .datatable-header-cell .targetMarker.dragFromRight{left:0}.ngx-datatable .datatable-header .datatable-header-cell .datatable-header-cell-template-wrap{height:inherit}.ngx-datatable .datatable-body{position:relative;z-index:10;display:block}.ngx-datatable .datatable-body .datatable-scroll{display:inline-block}.ngx-datatable .datatable-body .datatable-row-detail{overflow-y:hidden}.ngx-datatable .datatable-body .datatable-row-wrapper{display:flex;flex-direction:column}.ngx-datatable .datatable-body .datatable-body-row{outline:0}.ngx-datatable .datatable-body .datatable-body-row>div{display:flex}.ngx-datatable .datatable-footer{display:block;width:100%;overflow:auto}.ngx-datatable .datatable-footer .datatable-footer-inner{display:flex;align-items:center;width:100%}.ngx-datatable .datatable-footer .selected-count .page-count{flex:1 1 40%}.ngx-datatable .datatable-footer .selected-count .datatable-pager{flex:1 1 60%}.ngx-datatable .datatable-footer .page-count{flex:1 1 20%}.ngx-datatable .datatable-footer .datatable-pager{flex:1 1 80%;text-align:right}.ngx-datatable .datatable-footer .datatable-pager .pager,.ngx-datatable .datatable-footer .datatable-pager .pager li{padding:0;margin:0;display:inline-block;list-style:none}.ngx-datatable .datatable-footer .datatable-pager .pager li,.ngx-datatable .datatable-footer .datatable-pager .pager li a{outline:0}.ngx-datatable .datatable-footer .datatable-pager .pager li a{cursor:pointer;display:inline-block}.ngx-datatable .datatable-footer .datatable-pager .pager li.disabled a{cursor:not-allowed}"]
            }] }
];
/** @nocollapse */
DatatableComponent.ctorParameters = () => [
    { type: ScrollbarHelper, decorators: [{ type: SkipSelf }] },
    { type: DimensionsHelper, decorators: [{ type: SkipSelf }] },
    { type: ChangeDetectorRef },
    { type: ElementRef },
    { type: KeyValueDiffers },
    { type: ColumnChangesService },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: ['configuration',] }] }
];
DatatableComponent.propDecorators = {
    targetMarkerTemplate: [{ type: Input }],
    rows: [{ type: Input }],
    groupRowsBy: [{ type: Input }],
    groupedRows: [{ type: Input }],
    columns: [{ type: Input }],
    selected: [{ type: Input }],
    scrollbarV: [{ type: Input }],
    scrollbarH: [{ type: Input }],
    rowHeight: [{ type: Input }],
    columnMode: [{ type: Input }],
    headerHeight: [{ type: Input }],
    footerHeight: [{ type: Input }],
    externalPaging: [{ type: Input }],
    externalSorting: [{ type: Input }],
    limit: [{ type: Input }],
    count: [{ type: Input }],
    offset: [{ type: Input }],
    loadingIndicator: [{ type: Input }],
    selectionType: [{ type: Input }],
    reorderable: [{ type: Input }],
    swapColumns: [{ type: Input }],
    sortType: [{ type: Input }],
    sorts: [{ type: Input }],
    cssClasses: [{ type: Input }],
    messages: [{ type: Input }],
    rowClass: [{ type: Input }],
    selectCheck: [{ type: Input }],
    displayCheck: [{ type: Input }],
    groupExpansionDefault: [{ type: Input }],
    trackByProp: [{ type: Input }],
    selectAllRowsOnPage: [{ type: Input }],
    virtualization: [{ type: Input }],
    treeFromRelation: [{ type: Input }],
    treeToRelation: [{ type: Input }],
    summaryRow: [{ type: Input }],
    summaryHeight: [{ type: Input }],
    summaryPosition: [{ type: Input }],
    scroll: [{ type: Output }],
    activate: [{ type: Output }],
    select: [{ type: Output }],
    sort: [{ type: Output }],
    page: [{ type: Output }],
    reorder: [{ type: Output }],
    resize: [{ type: Output }],
    tableContextmenu: [{ type: Output }],
    treeAction: [{ type: Output }],
    isFixedHeader: [{ type: HostBinding, args: ['class.fixed-header',] }],
    isFixedRow: [{ type: HostBinding, args: ['class.fixed-row',] }],
    isVertScroll: [{ type: HostBinding, args: ['class.scroll-vertical',] }],
    isVirtualized: [{ type: HostBinding, args: ['class.virtualized',] }],
    isHorScroll: [{ type: HostBinding, args: ['class.scroll-horz',] }],
    isSelectable: [{ type: HostBinding, args: ['class.selectable',] }],
    isCheckboxSelection: [{ type: HostBinding, args: ['class.checkbox-selection',] }],
    isCellSelection: [{ type: HostBinding, args: ['class.cell-selection',] }],
    isSingleSelection: [{ type: HostBinding, args: ['class.single-selection',] }],
    isMultiSelection: [{ type: HostBinding, args: ['class.multi-selection',] }],
    isMultiClickSelection: [{ type: HostBinding, args: ['class.multi-click-selection',] }],
    columnTemplates: [{ type: ContentChildren, args: [DataTableColumnDirective,] }],
    rowDetail: [{ type: ContentChild, args: [DatatableRowDetailDirective, { static: false },] }],
    groupHeader: [{ type: ContentChild, args: [DatatableGroupHeaderDirective, { static: false },] }],
    footer: [{ type: ContentChild, args: [DatatableFooterDirective, { static: false },] }],
    bodyComponent: [{ type: ViewChild, args: [DataTableBodyComponent, { static: false },] }],
    headerComponent: [{ type: ViewChild, args: [DataTableHeaderComponent, { static: false },] }],
    rowIdentity: [{ type: Input }],
    onWindowResize: [{ type: HostListener, args: ['window:resize',] }]
};
tslib_1.__decorate([
    throttleable(5),
    tslib_1.__metadata("design:type", Function),
    tslib_1.__metadata("design:paramtypes", []),
    tslib_1.__metadata("design:returntype", void 0)
], DatatableComponent.prototype, "onWindowResize", null);
if (false) {
    /**
     * Template for the target marker of drag target columns.
     * @type {?}
     */
    DatatableComponent.prototype.targetMarkerTemplate;
    /**
     * This attribute allows the user to set a grouped array in the following format:
     *  [
     *    {groupid=1} [
     *      {id=1 name="test1"},
     *      {id=2 name="test2"},
     *      {id=3 name="test3"}
     *    ]},
     *    {groupid=2>[
     *      {id=4 name="test4"},
     *      {id=5 name="test5"},
     *      {id=6 name="test6"}
     *    ]}
     *  ]
     * @type {?}
     */
    DatatableComponent.prototype.groupedRows;
    /**
     * List of row objects that should be
     * represented as selected in the grid.
     * Default value: `[]`
     * @type {?}
     */
    DatatableComponent.prototype.selected;
    /**
     * Enable vertical scrollbars
     * @type {?}
     */
    DatatableComponent.prototype.scrollbarV;
    /**
     * Enable horz scrollbars
     * @type {?}
     */
    DatatableComponent.prototype.scrollbarH;
    /**
     * The row height; which is necessary
     * to calculate the height for the lazy rendering.
     * @type {?}
     */
    DatatableComponent.prototype.rowHeight;
    /**
     * Type of column width distribution formula.
     * Example: flex, force, standard
     * @type {?}
     */
    DatatableComponent.prototype.columnMode;
    /**
     * The minimum header height in pixels.
     * Pass a falsey for no header
     * @type {?}
     */
    DatatableComponent.prototype.headerHeight;
    /**
     * The minimum footer height in pixels.
     * Pass falsey for no footer
     * @type {?}
     */
    DatatableComponent.prototype.footerHeight;
    /**
     * If the table should use external paging
     * otherwise its assumed that all data is preloaded.
     * @type {?}
     */
    DatatableComponent.prototype.externalPaging;
    /**
     * If the table should use external sorting or
     * the built-in basic sorting.
     * @type {?}
     */
    DatatableComponent.prototype.externalSorting;
    /**
     * Show the linear loading bar.
     * Default value: `false`
     * @type {?}
     */
    DatatableComponent.prototype.loadingIndicator;
    /**
     * Type of row selection. Options are:
     *
     *  - `single`
     *  - `multi`
     *  - `checkbox`
     *  - `multiClick`
     *  - `cell`
     *
     * For no selection pass a `falsey`.
     * Default value: `undefined`
     * @type {?}
     */
    DatatableComponent.prototype.selectionType;
    /**
     * Enable/Disable ability to re-order columns
     * by dragging them.
     * @type {?}
     */
    DatatableComponent.prototype.reorderable;
    /**
     * Swap columns on re-order columns or
     * move them.
     * @type {?}
     */
    DatatableComponent.prototype.swapColumns;
    /**
     * The type of sorting
     * @type {?}
     */
    DatatableComponent.prototype.sortType;
    /**
     * Array of sorted columns by property and type.
     * Default value: `[]`
     * @type {?}
     */
    DatatableComponent.prototype.sorts;
    /**
     * Css class overrides
     * @type {?}
     */
    DatatableComponent.prototype.cssClasses;
    /**
     * Message overrides for localization
     *
     * emptyMessage     [default] = 'No data to display'
     * totalMessage     [default] = 'total'
     * selectedMessage  [default] = 'selected'
     * @type {?}
     */
    DatatableComponent.prototype.messages;
    /**
     * Row specific classes.
     * Similar implementation to ngClass.
     *
     *  [rowClass]="'first second'"
     *  [rowClass]="{ 'first': true, 'second': true, 'third': false }"
     * @type {?}
     */
    DatatableComponent.prototype.rowClass;
    /**
     * A boolean/function you can use to check whether you want
     * to select a particular row based on a criteria. Example:
     *
     *    (selection) => {
     *      return selection !== 'Ethel Price';
     *    }
     * @type {?}
     */
    DatatableComponent.prototype.selectCheck;
    /**
     * A function you can use to check whether you want
     * to show the checkbox for a particular row based on a criteria. Example:
     *
     *    (row, column, value) => {
     *      return row.name !== 'Ethel Price';
     *    }
     * @type {?}
     */
    DatatableComponent.prototype.displayCheck;
    /**
     * A boolean you can use to set the detault behaviour of rows and groups
     * whether they will start expanded or not. If ommited the default is NOT expanded.
     *
     * @type {?}
     */
    DatatableComponent.prototype.groupExpansionDefault;
    /**
     * Property to which you can use for custom tracking of rows.
     * Example: 'name'
     * @type {?}
     */
    DatatableComponent.prototype.trackByProp;
    /**
     * Property to which you can use for determining select all
     * rows on current page or not.
     *
     * \@memberOf DatatableComponent
     * @type {?}
     */
    DatatableComponent.prototype.selectAllRowsOnPage;
    /**
     * A flag for row virtualization on / off
     * @type {?}
     */
    DatatableComponent.prototype.virtualization;
    /**
     * Tree from relation
     * @type {?}
     */
    DatatableComponent.prototype.treeFromRelation;
    /**
     * Tree to relation
     * @type {?}
     */
    DatatableComponent.prototype.treeToRelation;
    /**
     * A flag for switching summary row on / off
     * @type {?}
     */
    DatatableComponent.prototype.summaryRow;
    /**
     * A height of summary row
     * @type {?}
     */
    DatatableComponent.prototype.summaryHeight;
    /**
     * A property holds a summary row position: top/bottom
     * @type {?}
     */
    DatatableComponent.prototype.summaryPosition;
    /**
     * Body was scrolled typically in a `scrollbarV:true` scenario.
     * @type {?}
     */
    DatatableComponent.prototype.scroll;
    /**
     * A cell or row was focused via keyboard or mouse click.
     * @type {?}
     */
    DatatableComponent.prototype.activate;
    /**
     * A cell or row was selected.
     * @type {?}
     */
    DatatableComponent.prototype.select;
    /**
     * Column sort was invoked.
     * @type {?}
     */
    DatatableComponent.prototype.sort;
    /**
     * The table was paged either triggered by the pager or the body scroll.
     * @type {?}
     */
    DatatableComponent.prototype.page;
    /**
     * Columns were re-ordered.
     * @type {?}
     */
    DatatableComponent.prototype.reorder;
    /**
     * Column was resized.
     * @type {?}
     */
    DatatableComponent.prototype.resize;
    /**
     * The context menu was invoked on the table.
     * type indicates whether the header or the body was clicked.
     * content contains either the column or the row that was clicked.
     * @type {?}
     */
    DatatableComponent.prototype.tableContextmenu;
    /**
     * A row was expanded ot collapsed for tree
     * @type {?}
     */
    DatatableComponent.prototype.treeAction;
    /**
     * Row Detail templates gathered from the ContentChild
     * @type {?}
     */
    DatatableComponent.prototype.rowDetail;
    /**
     * Group Header templates gathered from the ContentChild
     * @type {?}
     */
    DatatableComponent.prototype.groupHeader;
    /**
     * Footer template gathered from the ContentChild
     * @type {?}
     */
    DatatableComponent.prototype.footer;
    /**
     * Reference to the body component for manually
     * invoking functions on the body.
     * @type {?}
     */
    DatatableComponent.prototype.bodyComponent;
    /**
     * Reference to the header component for manually
     * invoking functions on the header.
     *
     * \@memberOf DatatableComponent
     * @type {?}
     */
    DatatableComponent.prototype.headerComponent;
    /** @type {?} */
    DatatableComponent.prototype.element;
    /** @type {?} */
    DatatableComponent.prototype._innerWidth;
    /** @type {?} */
    DatatableComponent.prototype.pageSize;
    /** @type {?} */
    DatatableComponent.prototype.bodyHeight;
    /** @type {?} */
    DatatableComponent.prototype.rowCount;
    /** @type {?} */
    DatatableComponent.prototype.rowDiffer;
    /** @type {?} */
    DatatableComponent.prototype._offsetX;
    /** @type {?} */
    DatatableComponent.prototype._limit;
    /** @type {?} */
    DatatableComponent.prototype._count;
    /** @type {?} */
    DatatableComponent.prototype._offset;
    /** @type {?} */
    DatatableComponent.prototype._rows;
    /** @type {?} */
    DatatableComponent.prototype._groupRowsBy;
    /** @type {?} */
    DatatableComponent.prototype._internalRows;
    /** @type {?} */
    DatatableComponent.prototype._internalColumns;
    /** @type {?} */
    DatatableComponent.prototype._columns;
    /** @type {?} */
    DatatableComponent.prototype._columnTemplates;
    /** @type {?} */
    DatatableComponent.prototype._subscriptions;
    /**
     * This will be used when displaying or selecting rows.
     * when tracking/comparing them, we'll use the value of this fn,
     *
     * (`fn(x) === fn(y)` instead of `x === y`)
     * @type {?}
     */
    DatatableComponent.prototype.rowIdentity;
    /**
     * @type {?}
     * @private
     */
    DatatableComponent.prototype.scrollbarHelper;
    /**
     * @type {?}
     * @private
     */
    DatatableComponent.prototype.dimensionsHelper;
    /**
     * @type {?}
     * @private
     */
    DatatableComponent.prototype.cd;
    /**
     * @type {?}
     * @private
     */
    DatatableComponent.prototype.columnChangesService;
    /**
     * @type {?}
     * @private
     */
    DatatableComponent.prototype.configuration;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable.component.js","sourceRoot":"ng://@swimlane/ngx-datatable/","sources":["lib/components/datatable.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  ElementRef,\n  EventEmitter,\n  ViewChild,\n  HostListener,\n  ContentChildren,\n  OnInit,\n  QueryList,\n  AfterViewInit,\n  HostBinding,\n  ContentChild,\n  DoCheck,\n  KeyValueDiffers,\n  KeyValueDiffer,\n  ViewEncapsulation,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  SkipSelf,\n  OnDestroy,\n  Optional,\n  Inject\n} from '@angular/core';\n\nimport { DatatableGroupHeaderDirective } from './body/body-group-header.directive';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { INgxDatatableConfig } from '../ngx-datatable.module';\nimport { groupRowsByParents, optionalGetterForProp } from '../utils/tree';\nimport { TableColumn } from '../types/table-column.type';\nimport { setColumnDefaults, translateTemplates } from '../utils/column-helper';\nimport { ColumnMode } from '../types/column-mode.type';\nimport { SelectionType } from '../types/selection.type';\nimport { SortType } from '../types/sort.type';\nimport { ContextmenuType } from '../types/contextmenu.type';\nimport { DataTableColumnDirective } from './columns/column.directive';\nimport { DatatableRowDetailDirective } from './row-detail/row-detail.directive';\nimport { DatatableFooterDirective } from './footer/footer.directive';\nimport { DataTableBodyComponent } from './body/body.component';\nimport { DataTableHeaderComponent } from './header/header.component';\nimport { ScrollbarHelper } from '../services/scrollbar-helper.service';\nimport { ColumnChangesService } from '../services/column-changes.service';\nimport { DimensionsHelper } from '../services/dimensions-helper.service';\nimport { throttleable } from '../utils/throttle';\nimport { forceFillColumnWidths, adjustColumnWidths } from '../utils/math';\nimport { sortRows } from '../utils/sort';\n\n@Component({\n  selector: 'ngx-datatable',\n  templateUrl: './datatable.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  styleUrls: ['./datatable.component.scss'],\n  host: {\n    class: 'ngx-datatable'\n  }\n})\nexport class DatatableComponent implements OnInit, DoCheck, AfterViewInit {\n  /**\n   * Template for the target marker of drag target columns.\n   */\n  @Input() targetMarkerTemplate: any;\n\n  /**\n   * Rows that are displayed in the table.\n   */\n  @Input() set rows(val: any) {\n    this._rows = val;\n\n    if (val) {\n      this._internalRows = [...val];\n    }\n\n    // auto sort on new updates\n    if (!this.externalSorting) {\n      this.sortInternalRows();\n    }\n\n    // auto group by parent on new update\n    this._internalRows = groupRowsByParents(\n      this._internalRows,\n      optionalGetterForProp(this.treeFromRelation),\n      optionalGetterForProp(this.treeToRelation)\n    );\n\n    // recalculate sizes/etc\n    this.recalculate();\n\n    if (this._rows && this._groupRowsBy) {\n      // If a column has been specified in _groupRowsBy created a new array with the data grouped by that row\n      this.groupedRows = this.groupArrayBy(this._rows, this._groupRowsBy);\n    }\n\n    this.cd.markForCheck();\n  }\n\n  /**\n   * Gets the rows.\n   */\n  get rows(): any {\n    return this._rows;\n  }\n\n  /**\n   * This attribute allows the user to set the name of the column to group the data with\n   */\n  @Input() set groupRowsBy(val: string) {\n    if (val) {\n      this._groupRowsBy = val;\n      if (this._rows && this._groupRowsBy) {\n        // cretes a new array with the data grouped\n        this.groupedRows = this.groupArrayBy(this._rows, this._groupRowsBy);\n      }\n    }\n  }\n\n  get groupRowsBy() {\n    return this._groupRowsBy;\n  }\n\n  /**\n   * This attribute allows the user to set a grouped array in the following format:\n   *  [\n   *    {groupid=1} [\n   *      {id=1 name=\"test1\"},\n   *      {id=2 name=\"test2\"},\n   *      {id=3 name=\"test3\"}\n   *    ]},\n   *    {groupid=2>[\n   *      {id=4 name=\"test4\"},\n   *      {id=5 name=\"test5\"},\n   *      {id=6 name=\"test6\"}\n   *    ]}\n   *  ]\n   */\n  @Input() groupedRows: any[];\n\n  /**\n   * Columns to be displayed.\n   */\n  @Input() set columns(val: TableColumn[]) {\n    if (val) {\n      this._internalColumns = [...val];\n      setColumnDefaults(this._internalColumns);\n      this.recalculateColumns();\n    }\n\n    this._columns = val;\n  }\n\n  /**\n   * Get the columns.\n   */\n  get columns(): TableColumn[] {\n    return this._columns;\n  }\n\n  /**\n   * List of row objects that should be\n   * represented as selected in the grid.\n   * Default value: `[]`\n   */\n  @Input() selected: any[] = [];\n\n  /**\n   * Enable vertical scrollbars\n   */\n  @Input() scrollbarV: boolean = false;\n\n  /**\n   * Enable horz scrollbars\n   */\n  @Input() scrollbarH: boolean = false;\n\n  /**\n   * The row height; which is necessary\n   * to calculate the height for the lazy rendering.\n   */\n  @Input() rowHeight: number | 'auto' | ((row?: any) => number) = 30;\n\n  /**\n   * Type of column width distribution formula.\n   * Example: flex, force, standard\n   */\n  @Input() columnMode: ColumnMode = ColumnMode.standard;\n\n  /**\n   * The minimum header height in pixels.\n   * Pass a falsey for no header\n   */\n  @Input() headerHeight: any = 30;\n\n  /**\n   * The minimum footer height in pixels.\n   * Pass falsey for no footer\n   */\n  @Input() footerHeight: number = 0;\n\n  /**\n   * If the table should use external paging\n   * otherwise its assumed that all data is preloaded.\n   */\n  @Input() externalPaging: boolean = false;\n\n  /**\n   * If the table should use external sorting or\n   * the built-in basic sorting.\n   */\n  @Input() externalSorting: boolean = false;\n\n  /**\n   * The page size to be shown.\n   * Default value: `undefined`\n   */\n  @Input() set limit(val: number | undefined) {\n    this._limit = val;\n\n    // recalculate sizes/etc\n    this.recalculate();\n  }\n\n  /**\n   * Gets the limit.\n   */\n  get limit(): number | undefined {\n    return this._limit;\n  }\n\n  /**\n   * The total count of all rows.\n   * Default value: `0`\n   */\n  @Input() set count(val: number) {\n    this._count = val;\n\n    // recalculate sizes/etc\n    this.recalculate();\n  }\n\n  /**\n   * Gets the count.\n   */\n  get count(): number {\n    return this._count;\n  }\n\n  /**\n   * The current offset ( page - 1 ) shown.\n   * Default value: `0`\n   */\n  @Input() set offset(val: number) {\n    this._offset = val;\n  }\n  get offset(): number {\n    return Math.max(Math.min(this._offset, Math.ceil(this.rowCount / this.pageSize) - 1), 0);\n  }\n\n  /**\n   * Show the linear loading bar.\n   * Default value: `false`\n   */\n  @Input() loadingIndicator: boolean = false;\n\n  /**\n   * Type of row selection. Options are:\n   *\n   *  - `single`\n   *  - `multi`\n   *  - `checkbox`\n   *  - `multiClick`\n   *  - `cell`\n   *\n   * For no selection pass a `falsey`.\n   * Default value: `undefined`\n   */\n  @Input() selectionType: SelectionType;\n\n  /**\n   * Enable/Disable ability to re-order columns\n   * by dragging them.\n   */\n  @Input() reorderable: boolean = true;\n\n  /**\n   * Swap columns on re-order columns or\n   * move them.\n   */\n  @Input() swapColumns: boolean = true;\n\n  /**\n   * The type of sorting\n   */\n  @Input() sortType: SortType = SortType.single;\n\n  /**\n   * Array of sorted columns by property and type.\n   * Default value: `[]`\n   */\n  @Input() sorts: any[] = [];\n\n  /**\n   * Css class overrides\n   */\n  @Input() cssClasses: any = {\n    sortAscending: 'datatable-icon-up',\n    sortDescending: 'datatable-icon-down',\n    pagerLeftArrow: 'datatable-icon-left',\n    pagerRightArrow: 'datatable-icon-right',\n    pagerPrevious: 'datatable-icon-prev',\n    pagerNext: 'datatable-icon-skip'\n  };\n\n  /**\n   * Message overrides for localization\n   *\n   * emptyMessage     [default] = 'No data to display'\n   * totalMessage     [default] = 'total'\n   * selectedMessage  [default] = 'selected'\n   */\n  @Input() messages: any = {\n    // Message to show when array is presented\n    // but contains no values\n    emptyMessage: 'No data to display',\n\n    // Footer total message\n    totalMessage: 'total',\n\n    // Footer selected message\n    selectedMessage: 'selected'\n  };\n\n  /**\n   * Row specific classes.\n   * Similar implementation to ngClass.\n   *\n   *  [rowClass]=\"'first second'\"\n   *  [rowClass]=\"{ 'first': true, 'second': true, 'third': false }\"\n   */\n  @Input() rowClass: any;\n\n  /**\n   * A boolean/function you can use to check whether you want\n   * to select a particular row based on a criteria. Example:\n   *\n   *    (selection) => {\n   *      return selection !== 'Ethel Price';\n   *    }\n   */\n  @Input() selectCheck: any;\n\n  /**\n   * A function you can use to check whether you want\n   * to show the checkbox for a particular row based on a criteria. Example:\n   *\n   *    (row, column, value) => {\n   *      return row.name !== 'Ethel Price';\n   *    }\n   */\n  @Input() displayCheck: (row: any, column?: any, value?: any) => boolean;\n\n  /**\n   * A boolean you can use to set the detault behaviour of rows and groups\n   * whether they will start expanded or not. If ommited the default is NOT expanded.\n   *\n   */\n  @Input() groupExpansionDefault: boolean = false;\n\n  /**\n   * Property to which you can use for custom tracking of rows.\n   * Example: 'name'\n   */\n  @Input() trackByProp: string;\n\n  /**\n   * Property to which you can use for determining select all\n   * rows on current page or not.\n   *\n   * @memberOf DatatableComponent\n   */\n  @Input() selectAllRowsOnPage = false;\n\n  /**\n   * A flag for row virtualization on / off\n   */\n  @Input() virtualization: boolean = true;\n\n  /**\n   * Tree from relation\n   */\n  @Input() treeFromRelation: string;\n\n  /**\n   * Tree to relation\n   */\n  @Input() treeToRelation: string;\n\n  /**\n   * A flag for switching summary row on / off\n   */\n  @Input() summaryRow: boolean = false;\n\n  /**\n   * A height of summary row\n   */\n  @Input() summaryHeight: number = 30;\n\n  /**\n   * A property holds a summary row position: top/bottom\n   */\n  @Input() summaryPosition: string = 'top';\n\n  /**\n   * Body was scrolled typically in a `scrollbarV:true` scenario.\n   */\n  @Output() scroll: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * A cell or row was focused via keyboard or mouse click.\n   */\n  @Output() activate: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * A cell or row was selected.\n   */\n  @Output() select: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * Column sort was invoked.\n   */\n  @Output() sort: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * The table was paged either triggered by the pager or the body scroll.\n   */\n  @Output() page: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * Columns were re-ordered.\n   */\n  @Output() reorder: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * Column was resized.\n   */\n  @Output() resize: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * The context menu was invoked on the table.\n   * type indicates whether the header or the body was clicked.\n   * content contains either the column or the row that was clicked.\n   */\n  @Output() tableContextmenu = new EventEmitter<{ event: MouseEvent; type: ContextmenuType; content: any }>(false);\n\n  /**\n   * A row was expanded ot collapsed for tree\n   */\n  @Output() treeAction: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * CSS class applied if the header height if fixed height.\n   */\n  @HostBinding('class.fixed-header')\n  get isFixedHeader(): boolean {\n    const headerHeight: number | string = this.headerHeight;\n    return typeof headerHeight === 'string' ? <string>headerHeight !== 'auto' : true;\n  }\n\n  /**\n   * CSS class applied to the root element if\n   * the row heights are fixed heights.\n   */\n  @HostBinding('class.fixed-row')\n  get isFixedRow(): boolean {\n    return this.rowHeight !== 'auto';\n  }\n\n  /**\n   * CSS class applied to root element if\n   * vertical scrolling is enabled.\n   */\n  @HostBinding('class.scroll-vertical')\n  get isVertScroll(): boolean {\n    return this.scrollbarV;\n  }\n\n  /**\n   * CSS class applied to root element if\n   * virtualization is enabled.\n   */\n  @HostBinding('class.virtualized')\n  get isVirtualized(): boolean {\n    return this.virtualization;\n  }\n\n  /**\n   * CSS class applied to the root element\n   * if the horziontal scrolling is enabled.\n   */\n  @HostBinding('class.scroll-horz')\n  get isHorScroll(): boolean {\n    return this.scrollbarH;\n  }\n\n  /**\n   * CSS class applied to root element is selectable.\n   */\n  @HostBinding('class.selectable')\n  get isSelectable(): boolean {\n    return this.selectionType !== undefined;\n  }\n\n  /**\n   * CSS class applied to root is checkbox selection.\n   */\n  @HostBinding('class.checkbox-selection')\n  get isCheckboxSelection(): boolean {\n    return this.selectionType === SelectionType.checkbox;\n  }\n\n  /**\n   * CSS class applied to root if cell selection.\n   */\n  @HostBinding('class.cell-selection')\n  get isCellSelection(): boolean {\n    return this.selectionType === SelectionType.cell;\n  }\n\n  /**\n   * CSS class applied to root if single select.\n   */\n  @HostBinding('class.single-selection')\n  get isSingleSelection(): boolean {\n    return this.selectionType === SelectionType.single;\n  }\n\n  /**\n   * CSS class added to root element if mulit select\n   */\n  @HostBinding('class.multi-selection')\n  get isMultiSelection(): boolean {\n    return this.selectionType === SelectionType.multi;\n  }\n\n  /**\n   * CSS class added to root element if mulit click select\n   */\n  @HostBinding('class.multi-click-selection')\n  get isMultiClickSelection(): boolean {\n    return this.selectionType === SelectionType.multiClick;\n  }\n\n  /**\n   * Column templates gathered from `ContentChildren`\n   * if described in your markup.\n   */\n  @ContentChildren(DataTableColumnDirective)\n  set columnTemplates(val: QueryList<DataTableColumnDirective>) {\n    this._columnTemplates = val;\n    this.translateColumns(val);\n  }\n\n  /**\n   * Returns the column templates.\n   */\n  get columnTemplates(): QueryList<DataTableColumnDirective> {\n    return this._columnTemplates;\n  }\n\n  /**\n   * Row Detail templates gathered from the ContentChild\n   */\n  @ContentChild(DatatableRowDetailDirective, { static: false })\n  rowDetail: DatatableRowDetailDirective;\n\n  /**\n   * Group Header templates gathered from the ContentChild\n   */\n  @ContentChild(DatatableGroupHeaderDirective, { static: false })\n  groupHeader: DatatableGroupHeaderDirective;\n\n  /**\n   * Footer template gathered from the ContentChild\n   */\n  @ContentChild(DatatableFooterDirective, { static: false })\n  footer: DatatableFooterDirective;\n\n  /**\n   * Reference to the body component for manually\n   * invoking functions on the body.\n   */\n  @ViewChild(DataTableBodyComponent, { static: false })\n  bodyComponent: DataTableBodyComponent;\n\n  /**\n   * Reference to the header component for manually\n   * invoking functions on the header.\n   *\n   * @memberOf DatatableComponent\n   */\n  @ViewChild(DataTableHeaderComponent, { static: false })\n  headerComponent: DataTableHeaderComponent;\n\n  /**\n   * Returns if all rows are selected.\n   */\n  get allRowsSelected(): boolean {\n    let allRowsSelected = this.rows && this.selected && this.selected.length === this.rows.length;\n\n    if (this.selectAllRowsOnPage) {\n      const indexes = this.bodyComponent.indexes;\n      const rowsOnPage = indexes.last - indexes.first;\n      allRowsSelected = this.selected.length === rowsOnPage;\n    }\n\n    return this.selected && this.rows && this.rows.length !== 0 && allRowsSelected;\n  }\n\n  element: HTMLElement;\n  _innerWidth: number;\n  pageSize: number;\n  bodyHeight: number;\n  rowCount: number = 0;\n  rowDiffer: KeyValueDiffer<{}, {}>;\n\n  _offsetX = new BehaviorSubject(0);\n  _limit: number | undefined;\n  _count: number = 0;\n  _offset: number = 0;\n  _rows: any[];\n  _groupRowsBy: string;\n  _internalRows: any[];\n  _internalColumns: TableColumn[];\n  _columns: TableColumn[];\n  _columnTemplates: QueryList<DataTableColumnDirective>;\n  _subscriptions: Subscription[] = [];\n\n  constructor(\n    @SkipSelf() private scrollbarHelper: ScrollbarHelper,\n    @SkipSelf() private dimensionsHelper: DimensionsHelper,\n    private cd: ChangeDetectorRef,\n    element: ElementRef,\n    differs: KeyValueDiffers,\n    private columnChangesService: ColumnChangesService,\n    @Optional() @Inject('configuration') private configuration: INgxDatatableConfig\n  ) {\n    // get ref to elm for measuring\n    this.element = element.nativeElement;\n    this.rowDiffer = differs.find({}).create();\n\n    // apply global settings from Module.forRoot\n    if (this.configuration && this.configuration.messages) {\n      this.messages = { ...this.configuration.messages };\n    }\n  }\n\n  /**\n   * Lifecycle hook that is called after data-bound\n   * properties of a directive are initialized.\n   */\n  ngOnInit(): void {\n    // need to call this immediatly to size\n    // if the table is hidden the visibility\n    // listener will invoke this itself upon show\n    this.recalculate();\n  }\n\n  /**\n   * Lifecycle hook that is called after a component's\n   * view has been fully initialized.\n   */\n  ngAfterViewInit(): void {\n    if (!this.externalSorting) {\n      this.sortInternalRows();\n    }\n\n    // this has to be done to prevent the change detection\n    // tree from freaking out because we are readjusting\n    if (typeof requestAnimationFrame === 'undefined') {\n      return;\n    }\n\n    requestAnimationFrame(() => {\n      this.recalculate();\n\n      // emit page for virtual server-side kickoff\n      if (this.externalPaging && this.scrollbarV) {\n        this.page.emit({\n          count: this.count,\n          pageSize: this.pageSize,\n          limit: this.limit,\n          offset: 0\n        });\n      }\n    });\n  }\n\n  /**\n   * Lifecycle hook that is called after a component's\n   * content has been fully initialized.\n   */\n  ngAfterContentInit() {\n    this.columnTemplates.changes.subscribe(v => this.translateColumns(v));\n    this.listenForColumnInputChanges();\n  }\n\n  /**\n   * This will be used when displaying or selecting rows.\n   * when tracking/comparing them, we'll use the value of this fn,\n   *\n   * (`fn(x) === fn(y)` instead of `x === y`)\n   */\n  @Input() rowIdentity: (x: any) => any = (x: any) => {\n    if (this._groupRowsBy) {\n      // each group in groupedRows are stored as {key, value: [rows]},\n      // where key is the groupRowsBy index\n      return x.key;\n    } else {\n      return x;\n    }\n  };\n\n  /**\n   * Translates the templates to the column objects\n   */\n  translateColumns(val: any) {\n    if (val) {\n      const arr = val.toArray();\n      if (arr.length) {\n        this._internalColumns = translateTemplates(arr);\n        setColumnDefaults(this._internalColumns);\n        this.recalculateColumns();\n        this.sortInternalRows();\n        this.cd.markForCheck();\n      }\n    }\n  }\n\n  /**\n   * Creates a map with the data grouped by the user choice of grouping index\n   *\n   * @param originalArray the original array passed via parameter\n   * @param groupByIndex  the index of the column to group the data by\n   */\n  groupArrayBy(originalArray: any, groupBy: any) {\n    // create a map to hold groups with their corresponding results\n    const map = new Map();\n    let i: number = 0;\n\n    originalArray.forEach((item: any) => {\n      const key = item[groupBy];\n      if (!map.has(key)) {\n        map.set(key, [item]);\n      } else {\n        map.get(key).push(item);\n      }\n      i++;\n    });\n\n    const addGroup = (key: any, value: any) => {\n      return { key, value };\n    };\n\n    // convert map back to a simple array of objects\n    return Array.from(map, x => addGroup(x[0], x[1]));\n  }\n\n  /*\n   * Lifecycle hook that is called when Angular dirty checks a directive.\n   */\n  ngDoCheck(): void {\n    if (this.rowDiffer.diff(this.rows)) {\n      if (!this.externalSorting) {\n        this.sortInternalRows();\n      } else {\n        this._internalRows = [...this.rows];\n      }\n\n      // auto group by parent on new update\n      this._internalRows = groupRowsByParents(\n        this._internalRows,\n        optionalGetterForProp(this.treeFromRelation),\n        optionalGetterForProp(this.treeToRelation)\n      );\n\n      this.recalculatePages();\n      this.cd.markForCheck();\n    }\n  }\n\n  /**\n   * Recalc's the sizes of the grid.\n   *\n   * Updated automatically on changes to:\n   *\n   *  - Columns\n   *  - Rows\n   *  - Paging related\n   *\n   * Also can be manually invoked or upon window resize.\n   */\n  recalculate(): void {\n    this.recalculateDims();\n    this.recalculateColumns();\n  }\n\n  /**\n   * Window resize handler to update sizes.\n   */\n  @HostListener('window:resize')\n  @throttleable(5)\n  onWindowResize(): void {\n    this.recalculate();\n  }\n\n  /**\n   * Recalulcates the column widths based on column width\n   * distribution mode and scrollbar offsets.\n   */\n  recalculateColumns(\n    columns: any[] = this._internalColumns,\n    forceIdx: number = -1,\n    allowBleed: boolean = this.scrollbarH\n  ): any[] | undefined {\n    if (!columns) return undefined;\n\n    let width = this._innerWidth;\n    if (this.scrollbarV) {\n      width = width - this.scrollbarHelper.width;\n    }\n\n    if (this.columnMode === ColumnMode.force) {\n      forceFillColumnWidths(columns, width, forceIdx, allowBleed);\n    } else if (this.columnMode === ColumnMode.flex) {\n      adjustColumnWidths(columns, width);\n    }\n\n    return columns;\n  }\n\n  /**\n   * Recalculates the dimensions of the table size.\n   * Internally calls the page size and row count calcs too.\n   *\n   */\n  recalculateDims(): void {\n    const dims = this.dimensionsHelper.getDimensions(this.element);\n    this._innerWidth = Math.floor(dims.width);\n\n    if (this.scrollbarV) {\n      let height = dims.height;\n      if (this.headerHeight) height = height - this.headerHeight;\n      if (this.footerHeight) height = height - this.footerHeight;\n      this.bodyHeight = height;\n    }\n\n    this.recalculatePages();\n  }\n\n  /**\n   * Recalculates the pages after a update.\n   */\n  recalculatePages(): void {\n    this.pageSize = this.calcPageSize();\n    this.rowCount = this.calcRowCount();\n  }\n\n  /**\n   * Body triggered a page event.\n   */\n  onBodyPage({ offset }: any): void {\n    // Avoid pagination caming from body events like scroll when the table\n    // has no virtualization and the external paging is enable.\n    // This means, let's the developer handle pagination by my him(her) self\n    if (this.externalPaging && !this.virtualization) {\n      return;\n    }\n\n    this.offset = offset;\n\n    this.page.emit({\n      count: this.count,\n      pageSize: this.pageSize,\n      limit: this.limit,\n      offset: this.offset\n    });\n  }\n\n  /**\n   * The body triggered a scroll event.\n   */\n  onBodyScroll(event: MouseEvent): void {\n    this._offsetX.next(event.offsetX);\n    this.scroll.emit(event);\n    this.cd.detectChanges();\n  }\n\n  /**\n   * The footer triggered a page event.\n   */\n  onFooterPage(event: any) {\n    this.offset = event.page - 1;\n    this.bodyComponent.updateOffsetY(this.offset);\n\n    this.page.emit({\n      count: this.count,\n      pageSize: this.pageSize,\n      limit: this.limit,\n      offset: this.offset\n    });\n\n    if (this.selectAllRowsOnPage) {\n      this.selected = [];\n      this.select.emit({\n        selected: this.selected\n      });\n    }\n  }\n\n  /**\n   * Recalculates the sizes of the page\n   */\n  calcPageSize(val: any[] = this.rows): number {\n    // Keep the page size constant even if the row has been expanded.\n    // This is because an expanded row is still considered to be a child of\n    // the original row.  Hence calculation would use rowHeight only.\n    if (this.scrollbarV && this.virtualization) {\n      const size = Math.ceil(this.bodyHeight / (this.rowHeight as number));\n      return Math.max(size, 0);\n    }\n\n    // if limit is passed, we are paging\n    if (this.limit !== undefined) {\n      return this.limit;\n    }\n\n    // otherwise use row length\n    if (val) {\n      return val.length;\n    }\n\n    // other empty :(\n    return 0;\n  }\n\n  /**\n   * Calculates the row count.\n   */\n  calcRowCount(val: any[] = this.rows): number {\n    if (!this.externalPaging) {\n      if (!val) return 0;\n\n      if (this.groupedRows) {\n        return this.groupedRows.length;\n      } else if (this.treeFromRelation != null && this.treeToRelation != null) {\n        return this._internalRows.length;\n      } else {\n        return val.length;\n      }\n    }\n\n    return this.count;\n  }\n\n  /**\n   * The header triggered a contextmenu event.\n   */\n  onColumnContextmenu({ event, column }: any): void {\n    this.tableContextmenu.emit({ event, type: ContextmenuType.header, content: column });\n  }\n\n  /**\n   * The body triggered a contextmenu event.\n   */\n  onRowContextmenu({ event, row }: any): void {\n    this.tableContextmenu.emit({ event, type: ContextmenuType.body, content: row });\n  }\n\n  /**\n   * The header triggered a column resize event.\n   */\n  onColumnResize({ column, newValue }: any): void {\n    /* Safari/iOS 10.2 workaround */\n    if (column === undefined) {\n      return;\n    }\n\n    let idx: number;\n    const cols = this._internalColumns.map((c, i) => {\n      c = { ...c };\n\n      if (c.$$id === column.$$id) {\n        idx = i;\n        c.width = newValue;\n\n        // set this so we can force the column\n        // width distribution to be to this value\n        c.$$oldWidth = newValue;\n      }\n\n      return c;\n    });\n\n    this.recalculateColumns(cols, idx);\n    this._internalColumns = cols;\n\n    this.resize.emit({\n      column,\n      newValue\n    });\n  }\n\n  /**\n   * The header triggered a column re-order event.\n   */\n  onColumnReorder({ column, newValue, prevValue }: any): void {\n    const cols = this._internalColumns.map(c => {\n      return { ...c };\n    });\n\n    if (this.swapColumns) {\n      const prevCol = cols[newValue];\n      cols[newValue] = column;\n      cols[prevValue] = prevCol;\n    } else {\n      if (newValue > prevValue) {\n        const movedCol = cols[prevValue];\n        for (let i = prevValue; i < newValue; i++) {\n          cols[i] = cols[i + 1];\n        }\n        cols[newValue] = movedCol;\n      } else {\n        const movedCol = cols[prevValue];\n        for (let i = prevValue; i > newValue; i--) {\n          cols[i] = cols[i - 1];\n        }\n        cols[newValue] = movedCol;\n      }\n    }\n\n    this._internalColumns = cols;\n\n    this.reorder.emit({\n      column,\n      newValue,\n      prevValue\n    });\n  }\n\n  /**\n   * The header triggered a column sort event.\n   */\n  onColumnSort(event: any): void {\n    // clean selected rows\n    if (this.selectAllRowsOnPage) {\n      this.selected = [];\n      this.select.emit({\n        selected: this.selected\n      });\n    }\n\n    this.sorts = event.sorts;\n\n    // this could be optimized better since it will resort\n    // the rows again on the 'push' detection...\n    if (this.externalSorting === false) {\n      // don't use normal setter so we don't resort\n      this.sortInternalRows();\n    }\n\n    // auto group by parent on new update\n    this._internalRows = groupRowsByParents(\n      this._internalRows,\n      optionalGetterForProp(this.treeFromRelation),\n      optionalGetterForProp(this.treeToRelation)\n    );\n\n    // Always go to first page when sorting to see the newly sorted data\n    this.offset = 0;\n    this.bodyComponent.updateOffsetY(this.offset);\n    this.sort.emit(event);\n  }\n\n  /**\n   * Toggle all row selection\n   */\n  onHeaderSelect(event: any): void {\n    if (this.selectAllRowsOnPage) {\n      // before we splice, chk if we currently have all selected\n      const first = this.bodyComponent.indexes.first;\n      const last = this.bodyComponent.indexes.last;\n      const allSelected = this.selected.length === last - first;\n\n      // remove all existing either way\n      this.selected = [];\n\n      // do the opposite here\n      if (!allSelected) {\n        this.selected.push(...this._internalRows.slice(first, last));\n      }\n    } else {\n      // before we splice, chk if we currently have all selected\n      const allSelected = this.selected.length === this.rows.length;\n      // remove all existing either way\n      this.selected = [];\n      // do the opposite here\n      if (!allSelected) {\n        this.selected.push(...this.rows);\n      }\n    }\n\n    this.select.emit({\n      selected: this.selected\n    });\n  }\n\n  /**\n   * A row was selected from body\n   */\n  onBodySelect(event: any): void {\n    this.select.emit(event);\n  }\n\n  /**\n   * A row was expanded or collapsed for tree\n   */\n  onTreeAction(event: any) {\n    const row = event.row;\n    // TODO: For duplicated items this will not work\n    const rowIndex = this._rows.findIndex(r => r[this.treeToRelation] === event.row[this.treeToRelation]);\n    this.treeAction.emit({ row, rowIndex });\n  }\n\n  ngOnDestroy() {\n    this._subscriptions.forEach(subscription => subscription.unsubscribe());\n  }\n\n  /**\n   * listen for changes to input bindings of all DataTableColumnDirective and\n   * trigger the columnTemplates.changes observable to emit\n   */\n  private listenForColumnInputChanges(): void {\n    this._subscriptions.push(\n      this.columnChangesService.columnInputChanges$.subscribe(() => {\n        if (this.columnTemplates) {\n          this.columnTemplates.notifyOnChanges();\n        }\n      })\n    );\n  }\n\n  private sortInternalRows(): void {\n    this._internalRows = sortRows(this._internalRows, this._internalColumns, this.sorts);\n  }\n}\n"]}