{"version":3,"sources":["../../src/plugins/integrated-grouping/constants.ts","../../src/plugins/grid-core/computeds.ts","../../src/plugins/sorting-state/reducers.ts","../../src/plugins/sorting-state/helpers.ts","../../src/utils/merge-sort.ts","../../src/utils/hierarchical-data.ts","../../src/plugins/integrated-sorting/computeds.ts","../../src/plugins/filtering-state/reducers.ts","../../src/plugins/filtering-state/helpers.ts","../../src/plugins/filtering-state/computeds.ts","../../src/plugins/integrated-filtering/computeds.ts","../../src/plugins/grouping-state/reducers.ts","../../src/plugins/grouping-state/constants.ts","../../src/plugins/grouping-state/helpers.ts","../../src/plugins/integrated-grouping/helpers.ts","../../src/plugins/integrated-grouping/computeds.ts","../../src/plugins/custom-grouping/computeds.ts","../../src/plugins/custom-grouping/helpers.ts","../../src/plugins/grouping-panel/helpers.ts","../../src/plugins/paging-state/reducers.ts","../../src/plugins/integrated-paging/computeds.ts","../../src/plugins/integrated-paging/helpers.ts","../../src/plugins/paging-panel/helpers.ts","../../src/utils/common-reducers.ts","../../src/plugins/selection-state/reducers.ts","../../src/plugins/integrated-selection/computeds.ts","../../src/plugins/editing-state/reducers.ts","../../src/plugins/editing-state/computeds.ts","../../src/plugins/editing-state/helpers.ts","../../src/plugins/table-column-reordering/constants.ts","../../src/plugins/table-column-reordering/reducers.ts","../../src/plugins/table/constants.ts","../../src/plugins/table-column-reordering/computeds.ts","../../src/plugins/table-column-resizing/helpers.ts","../../src/plugins/table-column-resizing/computeds.ts","../../src/plugins/table-column-resizing/reducers.ts","../../src/plugins/table-edit-column/constants.ts","../../src/plugins/table-edit-row/constants.ts","../../src/plugins/table-header-row/constants.ts","../../src/plugins/table-edit-column/helpers.ts","../../src/plugins/table-edit-column/computeds.ts","../../src/plugins/table-edit-row/helpers.ts","../../src/plugins/table-edit-row/computeds.ts","../../src/plugins/table-inline-cell-editing/computeds.ts","../../src/plugins/table-filter-row/constants.ts","../../src/plugins/table-filter-row/helpers.ts","../../src/plugins/table-filter-row/computeds.ts","../../src/plugins/table-group-row/constants.ts","../../src/utils/virtual-table.ts","../../src/plugins/table-group-row/helpers.ts","../../src/plugins/table-group-row/computeds.ts","../../src/plugins/table-header-row/helpers.ts","../../src/plugins/table-header-row/computeds.ts","../../src/plugins/table-band-header/constants.ts","../../src/plugins/table-band-header/helpers.ts","../../src/plugins/virtual-table-state/helpers.ts","../../src/plugins/virtual-table-state/utils.ts","../../src/plugins/table-band-header/computeds.ts","../../src/plugins/row-detail-state/reducers.ts","../../src/plugins/table-row-detail/constants.ts","../../src/plugins/table-row-detail/helpers.ts","../../src/plugins/table-row-detail/computeds.ts","../../src/plugins/table-selection/constants.ts","../../src/plugins/table-selection/helpers.ts","../../src/plugins/table-selection/computeds.ts","../../src/plugins/table/helpers.ts","../../src/utils/column-extension.ts","../../src/plugins/table/computeds.ts","../../src/plugins/table-column-visibility/computeds.ts","../../src/plugins/table-column-visibility/helpers.ts","../../src/plugins/column-chooser/computeds.ts","../../src/plugins/column-chooser/reducers.ts","../../src/plugins/tree-data-state/reducers.ts","../../src/plugins/custom-tree-data/constants.ts","../../src/plugins/custom-tree-data/computeds.ts","../../src/plugins/table-tree-column/helpers.ts","../../src/plugins/search-state/reducers.ts","../../src/plugins/search-state/computeds.ts","../../src/plugins/data-type-provider/computeds.ts","../../src/plugins/table-fixed-columns/constants.ts","../../src/plugins/table-fixed-columns/helpers.ts","../../src/plugins/table-fixed-columns/computeds.ts","../../src/plugins/integrated-summary/computeds.ts","../../src/plugins/table-summary-row/constants.ts","../../src/plugins/table-summary-row/helpers.ts","../../src/plugins/table-summary-row/computeds.ts","../../src/plugins/summary-state/helpers.ts","../../src/utils/column-geometries.ts","../../src/utils/table.ts","../../src/utils/group-panel.ts","../../src/plugins/virtual-table/utils.ts","../../src/plugins/virtual-table/constants.ts","../../src/plugins/virtual-table/helpers.ts","../../src/plugins/virtual-table-state/computeds.ts"],"names":["GRID_GROUP_TYPE","Symbol","GRID_GROUP_CHECK","toString","GRID_GROUP_LEVEL_KEY","GRID_GROUP_COLLAPSED_ROWS","rowIdGetter","getRowId","rows","map_1","Map","map","row","rowIndex","get","result","warnIfRowIdUndefined","defaultGetCellValue","columnName","cellValueGetter","getCellValue","columns","useFastAccessor","reduce","acc","column","name","changeColumnSorting","state","_a","direction","keepOther","sortIndex","sorting","nextSorting","Array","isArray","slice","filter","s","indexOf","columnSortingIndex","findIndex","columnSorting","newColumnSorting","splice","newIndexFallback","length","newIndex","undefined","unique","arr","__spread","from","Set","getColumnSortingDirection","getPersistentSortedColumns","columnExtensions","sortingEnabled","sortItem","push","calculateKeepOther","persistentSortedColumns","item","merge","array","auxiliary","lo","mid","hi","compare","i","j","k","sortArrayToAuxiliary","Math","floor","sortAuxiliaryToArray","mergeSort","a","b","NODE_CHECK","rowsToTree","getRowLevelKey","levels","children","forEach","levelKey","levelIndex","level","root","node","treeToRows","tree","defaultCompare","createCompare","getColumnCompare","getComparableValue","reduceRight","prevCompare","inverse","columnCompare","aRow","bRow","args","_i","arguments","sortTree","sortedTree","__assign","sortedRows","isGroupRow","sortHierarchicalRows","groupedBy","value","changeColumnFilter","filters","config","filterIndex","f","nextState","getColumnFilterConfig","filterExpression","expression","selfFilterExpr","operator","operators","or","predicates","predicate","and","toLowerCase","String","operationPredicates","contains","notContains","startsWith","endsWith","equal","notEqual","greaterThan","greaterThanOrEqual","lessThan","lessThanOrEqual","defaultFilterPredicate","operation","filterTree","filteredChildren","buildPredicate","initialFilterExpression","getColumnPredicate","getPredicate","build","getOperatorPredicate","getSimplePredicate","filteredRows","getCollapsedRows","Object","keys","collapsedRowsMeta","filteredTree","isNode","collapsedRows","filteredCollapsedRows","filterHierarchicalRows","filteredCollapsedRowsGetter","unwrappedFilteredRows","applyColumnGrouping","grouping","groupIndex","nextGrouping","groupingIndex","g","targetIndex","changeColumnGrouping","_b","expandedGroups","ungroupedColumnIndex","group","index","filteredExpandedGroups","split","toggleExpandedGroups","groupKey","groupKeyIndex","draftColumnGrouping","draftGrouping","cancelColumnGroupingDraft","adjustSortIndex","max","columnGrouping","defaultColumnCriteria","key","getGroupRows","groupsGetter","keyPrefixes","prefix","resultRows","compoundKeys","pop","keyPrefix","currentRows","currentCompoundKey","groupRows","childRows","params","__rest","compoundKey","apply","groupRowChecker","groupRowLevelKeyGetter","groupedRows","getColumnCriteria","currentGrouping","groupCriteria","groups","rawValue","sameKeyItems","groupingValue","set","values","_c","__read","getIntegratedGroups","expandedGroupRows","isExporting","groupingColumnNames","expandedGroupsSet","currentGroupExpanded","currentGroupLevel","groupLevel","has","groupCollapsedRowsGetter","customGroupedRows","getChildGroups","rootRows","getCustomGroups","customGroupingRowIdGetter","firstRow","find","groupingPanelItems","items","c","draft","some","setCurrentPage","prevPage","page","setPageSize","prevPageSize","size","paginatedRows","pageSize","rowsWithPageHeaders","headerRows","currentIndex","headerIndex","headerRow","Error","indexInPage","rowCount","pageCount","count","ceil","currentPage","totalCount","totalPages","adjustedCurrentPage","min","setTimeout","firstRowOnPage","lastRowOnPage","totalRowCount","calculateStartPage","maxButtonCount","totalPageCount","toggle","source","itemsSet","sourceState","sourceSet_1","toggleSelection","selection","rowIds","rowsWithAvailableToSelect","dataRows","availableToSelect","someSelected","selectionSet","elem","allSelected","unwrapSelectedRows","startEditRows","prevEditingRowIds","stopEditRows","rowIdSet","id","startEditCells","prevEditingCells","editingCells","stopEditCells","rowId","currentRowId","currentColumnName","addRow","addedRows","changeAddedRow","change","cancelAddedRows","indexSet","changeRow","prevRowChanges","prevChange","cancelChanges","deleteRows","deletedRowIds","cancelDeletedRows","changedRowsByIds","changes","addedRowsByIds","defaultCreateRowChange","createRowChangeGetter","createRowChange","columnExtension","getRowChange","rowChanges","TABLE_REORDERING_TYPE","changeColumnOrder","order","sourceColumnName","targetColumnName","sourceColumnIndex","targetColumnIndex","newOrder","TABLE_DATA_TYPE","TABLE_NODATA_TYPE","TABLE_FLEX_TYPE","orderedColumns","tableColumns","type","tableHeaderRowsWithReordering","tableHeaderRows","height","draftOrder","sourceColumn","getColumnWidth","columnWidths","cachedWidths","shift","minColumnWidth","maxColumnWidth","extension","width","minWidth","maxWidth","getColumnSizes","payload","nextColumnName","resizingMode","nextWidth","nextSize","isValidValue","validUnits","numb","parseInt","unit","substr","sizeIsAuto","isNaN","sizeIsValid","validUnit","convertWidth","VALID_UNITS","NOT_FOR_WIDGET_UNITS","specifyWidths","widths","onError","tableColumn","columnName_1","el","tableColumnsWithWidths","throwError","tableColumnsWithDraftWidths","draftColumnWidths","changeTableColumnWidth","nextColumnWidth","nextIndex","draftTableColumnWidth","cancelTableColumnWidthDraft","TABLE_EDIT_COMMAND_TYPE","TABLE_ADDED_TYPE","TABLE_EDIT_TYPE","TABLE_HEADING_TYPE","isHeadingEditCommandsTableCell","tableRow","isEditCommandsTableCell","tableColumnsWithEditing","isEditTableCell","isAddedTableRow","isEditTableRow","tableRowsWithEditing","tableRows","editingRowIds","rowHeight","editedTableRows","addedTableRows","reverse","rowsWithEditingCells","tableBodyRows","hasEditCell","columnsWithEditingCells","TABLE_FILTER_TYPE","DEFAULT_FILTER_OPERATIONS","isFilterTableCell","isFilterTableRow","getColumnFilterOperations","getAvailableFilterOperations","isFilterValueEmpty","getSelectedFilterOperation","filterOperations","columnFilter","columnFilterOperations","tableHeaderRowsWithFilter","TABLE_GROUP_TYPE","TABLE_STUB_TYPE","getVisibleBoundary","viewportStart","viewportSize","getItemSize","offset","itemSize","start","end","beforePosition","viewportEnd","afterPosition","isVisible","getRenderBoundary","itemsCount","visibleBoundary","overscan","getRowsVisibleBoundary","top","getRowHeight","isDataRemote","boundaries","noVisibleRowsLoaded","topIndex","round","getColumnsRenderBoundary","columnCount","getSpanBoundary","visibleBoundaries","getItemSpan","endIndex","span","collapseBoundaries","spanBoundaries","breakpoints","rowBoundaries","boundary","add","every","bound","point","bp","sort","bounds","getColumnsSize","startIndex","getColumnSize","getCollapsedColumns","collapsedColumns","getCells","cells","getCollapsedGrid","rowsVisibleBoundary","columnsVisibleBoundary","_d","getColSpan","rowSpanBoundaries","columnBoundaries","collapsedCells","spanBoundary","realColSpanEnd_1","colSpanEnd","colSpanBoundary","colSpan","getCollapsedCells","getColumnWidthGetter","tableWidth","colsHavingWidth","col","autoWidth","autoColWidth","getCollapsedGrids","bodyRows","footerRows","loadedRowsStart","getCellColSpan","viewport","getCollapsedGridBlock","headerGrid","getRenderRowBounds","bodyGrid","adjustedRenderRowBounds","footerGrid","visibleBounds","renderRowBoundaries","adjustedInterval","intervalUtil","intersect","getGroupIndexByColumn","isIndentCell","rowGroupIndex","isGroupTableCell","isGroupIndentTableCell","isGroupIndentStubTableCell","isGroupTableRow","isGroupRowOrdinaryCell","isRowSummaryCell","groupSummaryItems","showInGroupFooter","alignByColumn","columnHasGroupRowSummary","isPreviousCellContainSummary","columnIndex","calculateGroupCellIndent","indentWidth","tableColumnsWithGrouping","indentColumnWidth","showColumnWhenGrouped","groupedColumn","columnGroupingExists","columnDraftGroupingExists","tableColumnsWithDraftGrouping","tableRowsWithGrouping","groupSummaryChains","firstVisibleColumnIndex","captionStarted","groupColumns","dataColumns","flexColumns","otherColumns","firstGroupIndex","sortAndSpliceColumns","colName","isStartOfGroupCaption","isIndentColumn","isRowLevelSummary","tableGroupCellColSpanGetter","getTableCellColSpan","colName_1","dataColumnGroupedBy_1","chain","ch","isHeadingTableCell","isHeadingTableRow","findChainByColumnIndex","chains","splitHeaderColumnChains","tableColumnChains","shouldSplitChain","extendChainProps","currentChain","generateSimpleChains","getNextColumnName","tableRowsWithHeading","TABLE_BAND_TYPE","BAND_GROUP_CELL","BAND_HEADER_CELL","BAND_EMPTY_CELL","BAND_DUPLICATE_RENDER","BAND_FILL_LEVEL_CELL","isBandedTableRow","isBandedOrHeaderRow","getColumnMeta","bands","tableRowLevel","title","band","rowLevelPassed","bandTitle","bandKey","getBandComponent","columnBands","tableHeaderColumnChains","columnVisibleIntervals","bandLevelsVisibility","currentTableColumn","rowSpan","maxLevel","currentRowLevel","currentColumnMeta","currentColumnIndex","levelsCount","visibleLevelsCount","Boolean","previousTableColumn","beforeBorder","isStubColumn","isColumnVisible","visibleBound","headerChain","currentColumnChain","columnVisibleBoundary","bandStart","bandEnd","emptyVirtualRows","skip","Number","POSITIVE_INFINITY","pluckSubarray","sourceStart","left","right","recalculateBounds","middleIndex","currentPageIndex","rowToPageIndex","prevPageIndex","nextPageIndex","trimRowsToInterval","virtualRows","targetInterval","rowsInterval","getRowsInterval","intersection","empty","getAvailableRowCount","isInfiniteScroll","newRowCount","lastRowCount","getRequestMeta","referenceIndex","forceReload","actualBounds","intervalEnd","getForceReloadInterval","requestedRange","newRange","loadedInterval","abs","calculatedRange","difference","correctRequestedRange","calculateRequestedRange","needFetchMorePages","loadCount","topTriggerIndex","bottomTriggerIndex","getReferenceIndex","shouldSendRequest","requestedPageIndex","NEGATIVE_INFINITY","r","getLength","tableRowsWithBands","tableDataColumns","getMaxNestedLevel","isDataColumn","dataColumn","tableHeaderColumnChainsWithBands","maxBandRowIndex","rawBandChains","currentBand","getBandLevels","columnsBands","columnBandLevels","columnIntervals","bandLevels","rowsWithBands","visibleIntervals","getVisibleBandsByLevel","interval","isBandChainVisible","_","toggleDetailRowExpanded","prevExpanded","TABLE_DETAIL_TYPE","isDetailRowExpanded","expandedDetailRowIds","isDetailToggleTableCell","isDetailTableRow","isDetailTableCell","tableRowsWithExpandedDetail","expandedRowId","insertIndex","tableColumnsWithDetail","toggleColumnWidth","tableDetailCellColSpanGetter","TABLE_SELECT_TYPE","isSelectTableCell","isSelectAllTableCell","isRowHighlighted","highlightRow","includes","tableColumnsWithSelection","selectionColumnWidth","VALID_UNITS$1","isDataTableCell","isHeaderStubTableCell","isDataTableRow","isNoDataTableRow","isNoDataTableCell","isStubTableCell","checkTableColumnExtensions","getColumnExtension","getColumnExtensionValueGetter","extensionName","defaultValue","extensionValue","tableColumnsWithDataRows","align","wordWrapEnabled","tableRowsWithDataRows","isRemoteRowsLoading","dataIndex","tableCellColSpanGetter","visibleTableColumns","hiddenColumnNames","tableDataColumnsExist","columnChooserItems","hidden","toggleColumn","hiddenColumn","toggleRowExpanded","GRID_TREE_NODE_TYPE","customTreeRowsWithMeta","getChildRows","rowsToProcess","treeRows","currentRow","nestedRows","childRow","leaf","treeMeta","customTreeRowIdGetter","firstNestedRowIndex","customTreeRowLevelKeyGetter","rowMeta","expandedTreeRows","expandedRowIds","expandedRowIdsSet","currentExpanded","currentLevel","lastRow","collapsedItems","collapsedTreeRowsGetter","isTreeRowLeafGetter","getTreeRowLevelGetter","unwrappedCustomTreeRows","isTreeTableCell","forColumnName","changeSearchValue","prevSearchValue","searchValue","searchFilterExpression","selfFilterExpression","getAvailableFilterOperationsGetter","availableFilterOperations","columnNames","FIXED_COLUMN_LEFT_SIDE","TABLE_FIXED_TYPE","getFixedColumnKeys","fixedNames","isFixedTableRow","calculateFixedColumnProps","tableColumnDimensions","leftColumns","rightColumns","side","fixed","targetArray","fixedIndex","columnChain","showLeftDivider","showRightDivider","position","target","calculatePosition","tableColumnsWithFixed","tableHeaderRowsWithFixed","tableHeaderColumnChainsWithFixed","currentGroup","defaultSummaryCalculators","sum","getValue","Infinity","avg","defaultSummaryCalculator","summaryCalculator","rowsSummary","summaryItems","calculator","expandRows","includeGroupRow","shouldIncludeRow","totalSummaryValues","plainRows","groupSummaryValues","getLevelIndex","summaries","anyRowLevelSummaryExist","rowsToAppend","treeSummaryValues","TABLE_TOTAL_SUMMARY_TYPE","TABLE_GROUP_SUMMARY_TYPE","TABLE_TREE_SUMMARY_TYPE","defaultFormatlessSummaries","isTotalSummaryTableCell","isGroupSummaryTableCell","isTreeSummaryTableCell","isTotalSummaryTableRow","isGroupSummaryTableRow","isTreeSummaryTableRow","getColumnSummaries","summaryValues","isFooterSummary","summaryItem","isInlineGroupCaptionSummary","getGroupInlineSummaries","tableRowsWithTotalSummaries","tableRowsWithSummaries","treeSummaryItems","hasGroupFooterSummary","groupFooterSummaryExists","closeLevel","opened","prepareGroupSummaryItems","getCellGeometries","getBoundingClientRect","styleLeft","style","replace","styleRight","calculatedLeft","isFixed","tableContainer","nodeName","parentNode","calculatedRight","getTableColumnGeometries","freeSpacePortion","accum","lastRightPosition","getTableTargetColumnIndex","columnGeometries","indexes","getAnimationProgress","animation","Date","getTime","startTime","getAnimations","prevColumns","nextColumns","prevAnimations","resizing","join","prevColumnGeometries","geometry","progress","easeOutCubic","to","nextColumnGeometries","prev","next","takePrevColumnIntoAccount","filterActiveAnimations","animations","entries","evalAnimations","transform","isOnTheSameLine","y","bottom","rectToObject","getGroupCellTargetIndex","geometries","sourceIndex","x","targetGeometries","sourceWidth","getWidthDifference","leftBorder","rightBorder","getTargetColumnGeometries","collapseGapsBetweenItems","inVerticalBounds","inHorizontalBounds","shouldGoFirst","shouldGoOnLineBreak","arraysEqual","arrA","arrB","comparator","TOP_POSITION","BOTTOM_POSITION","VALID_UNITS$2","getViewport","getters","estimatedRowHeight","viewportTop","viewportLeft","containerWidth","containerHeight","headerHeight","footerHeight","tableFooterRows","getColumnBoundaries","checkColumnWidths","unit_1","getScrollTop","rowsCount","calculateScrollHeight","getTopRowId","hasViewportRows","hasBodyRows","virtualRowsWithCache","cache","cacheInterval","cacheRows","rowsStart","cacheStart","chunk","concat","mergeRows","availableRowCount"],"mappings":"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","file":"static/js/main~24fbd82e.63268bf0.chunk.js","sourcesContent":["export const GRID_GROUP_TYPE = Symbol('group');\nexport const GRID_GROUP_CHECK = Symbol(`${GRID_GROUP_TYPE.toString()}_check`);\nexport const GRID_GROUP_LEVEL_KEY = Symbol(`${GRID_GROUP_TYPE.toString()}_levelKey`);\nexport const GRID_GROUP_COLLAPSED_ROWS = Symbol(`${GRID_GROUP_TYPE.toString()}_collapsedRows`);\n","import { GRID_GROUP_CHECK } from '../integrated-grouping/constants';\nimport { GetRowIdFn, Row, RowId, GetCellValueFn, Column } from '../../types';\nimport { PureComputed } from '@devexpress/dx-core';\n\nconst warnIfRowIdUndefined: PureComputed<[GetRowIdFn]> = getRowId => (row) => {\n  const result = getRowId(row);\n  if (!row[GRID_GROUP_CHECK] && result === undefined) {\n    // tslint:disable-next-line: no-console\n    console.warn('The row id is undefined. Check the getRowId function. The row is', row);\n  }\n  return result;\n};\n\nexport const rowIdGetter: PureComputed<[GetRowIdFn, Row[]]> = (getRowId, rows) => {\n  if (!getRowId) {\n    const map = new Map(rows.map((row, rowIndex) => [row, rowIndex]) as [any, number]);\n    return (row: Row) => map.get(row) as RowId;\n  }\n  return warnIfRowIdUndefined(getRowId);\n};\n\nconst defaultGetCellValue: GetCellValueFn = (row, columnName) => row[columnName];\n\nexport const cellValueGetter: PureComputed<[GetCellValueFn, Column[]]> = (\n  getCellValue = defaultGetCellValue, columns,\n) => {\n  let useFastAccessor = true;\n  const map = columns.reduce((acc, column) => {\n    if (column.getCellValue) {\n      useFastAccessor = false;\n      acc[column.name] = column.getCellValue;\n    }\n    return acc;\n  }, {});\n\n  if (useFastAccessor) {\n    return getCellValue;\n  }\n\n  return (row, columnName) => (map[columnName]\n    ? map[columnName](row, columnName)\n    : getCellValue(row, columnName));\n};\n","import { ColumnSortingState, ChangeSortingPayload, Sorting } from '../../types';\nimport { PureReducer, slice } from '@devexpress/dx-core';\n\nexport const changeColumnSorting: PureReducer<ColumnSortingState, ChangeSortingPayload> = (\n  state, {\n  columnName, direction, keepOther, sortIndex,\n}) => {\n  const { sorting } = state;\n\n  let nextSorting: any[] = [];\n  if (keepOther === true) {\n    nextSorting = sorting as Sorting[];\n  }\n  if (Array.isArray(keepOther)) {\n    nextSorting = slice(sorting)\n      .filter(s =>\n        keepOther.indexOf(s.columnName) > -1);\n  }\n\n  const columnSortingIndex = sorting.findIndex(s => s.columnName === columnName);\n  const columnSorting = sorting[columnSortingIndex];\n  const newColumnSorting = {\n    columnName,\n    direction: direction\n      || (!columnSorting || columnSorting.direction === 'desc' ? 'asc' : 'desc'),\n  };\n\n  if (columnSortingIndex > -1) {\n    nextSorting = slice(nextSorting);\n    nextSorting.splice(columnSortingIndex, 1);\n  }\n\n  if (direction !== null) {\n    const newIndexFallback = columnSortingIndex > -1 ? columnSortingIndex : nextSorting.length;\n    const newIndex = sortIndex !== undefined ? sortIndex : newIndexFallback;\n    nextSorting = slice(nextSorting);\n    nextSorting.splice(newIndex, 0, newColumnSorting);\n  }\n\n  return {\n    sorting: nextSorting,\n  };\n};\n","import {\n  KeepOtherSorting, GetColumnSortingDirectionFn, GetPersistentSortedColumnsFn,\n  CalculateKeepOtherFn,\n} from '../../types';\n\nconst unique = (arr: any[]) => [...Array.from(new Set(arr))];\n\nexport const getColumnSortingDirection: GetColumnSortingDirectionFn = (\n  sorting, columnName,\n) => {\n  const columnSorting = sorting.filter(s => s.columnName === columnName)[0];\n  return columnSorting ? columnSorting.direction : null;\n};\n\nexport const getPersistentSortedColumns: GetPersistentSortedColumnsFn = (\n  sorting, columnExtensions = [],\n) => columnExtensions.reduce((acc, { columnName, sortingEnabled }) => {\n  if (sortingEnabled === false) {\n    if (sorting.findIndex(sortItem => sortItem.columnName === columnName) > -1) {\n      acc.push(columnName);\n    }\n  }\n  return acc;\n}, [] as string[]);\n\nexport const calculateKeepOther: CalculateKeepOtherFn = (\n  sorting, keepOther, persistentSortedColumns = [],\n) => {\n  if (!persistentSortedColumns.length) return keepOther as KeepOtherSorting;\n  if (!keepOther) return persistentSortedColumns as KeepOtherSorting;\n\n  return Array.isArray(keepOther)\n    ? unique([...keepOther, ...persistentSortedColumns])\n    : unique([...sorting.map(item => item.columnName), ...persistentSortedColumns]);\n};\n","import { slice } from '@devexpress/dx-core';\nimport { MergeFn, SortArrayToAuxiliaryFn, CompareFn } from '../types';\n\n/* eslint-disable no-plusplus, no-param-reassign, no-use-before-define, no-constant-condition */\n/* tslint:disable no-increment-decrement */\n\nconst merge: MergeFn = (array, auxiliary, lo, mid, hi, compare) => {\n  let i = lo;\n  let j = mid + 1;\n  let k = lo;\n  while (true) {\n    const cmp = compare(array[i], array[j]);\n    if (cmp <= 0) {\n      auxiliary[k++] = array[i++];\n      if (i > mid) {\n        do {\n          auxiliary[k++] = array[j++];\n        } while (j <= hi);\n        break;\n      }\n    } else {\n      auxiliary[k++] = array[j++];\n      if (j > hi) {\n        do {\n          auxiliary[k++] = array[i++];\n        } while (i <= mid);\n        break;\n      }\n    }\n  }\n};\n\nconst sortArrayToAuxiliary: SortArrayToAuxiliaryFn = (array, auxiliary, lo, hi, compare) => {\n  if (hi < lo) return;\n  if (hi === lo) {\n    auxiliary[lo] = array[lo];\n    return;\n  }\n  const mid = Math.floor(lo + ((hi - lo) / 2));\n  sortAuxiliaryToArray(array, auxiliary, lo, mid, compare);\n  sortAuxiliaryToArray(array, auxiliary, mid + 1, hi, compare);\n  merge(array, auxiliary, lo, mid, hi, compare);\n};\n\nconst sortAuxiliaryToArray: SortArrayToAuxiliaryFn = (array, auxiliary, lo, hi, compare) => {\n  if (hi <= lo) return;\n  const mid = Math.floor(lo + ((hi - lo) / 2));\n  sortArrayToAuxiliary(array, auxiliary, lo, mid, compare);\n  sortArrayToAuxiliary(array, auxiliary, mid + 1, hi, compare);\n  merge(auxiliary, array, lo, mid, hi, compare);\n};\n\nexport default (\n  array: any[] | ReadonlyArray<any>,\n  compare: CompareFn = (a, b): number => {\n    if (a < b) return -1;\n    if (a > b) return 1;\n    return 0;\n  },\n) => {\n  const result = slice(array);\n  const auxiliary = slice(array);\n  sortAuxiliaryToArray(result, auxiliary, 0, result.length - 1, compare);\n  return result;\n};\n","import { RowsToTreeFn, TreeToRowsFn, TreeNode } from '../types';\n\nexport const NODE_CHECK = Symbol('node');\n\nexport const rowsToTree: RowsToTreeFn = (rows, getRowLevelKey) => {\n  if (!rows.length) return rows;\n\n  const levels: any[] = [{ children: [] }];\n\n  rows.forEach((row) => {\n    const levelKey = getRowLevelKey(row);\n    if (levelKey) {\n      const levelIndex = levels.slice(1)\n        .findIndex(level => getRowLevelKey(level.root) === levelKey) + 1;\n      if (levelIndex > 0) {\n        levels.splice(levelIndex, levels.length - levelIndex);\n      }\n      const node = { [NODE_CHECK]: true, root: row, children: [] };\n      levels[levels.length - 1].children.push(node);\n      levels.push(node);\n    } else {\n      levels[levels.length - 1].children.push(row);\n    }\n  });\n\n  return levels[0].children;\n};\n\nexport const treeToRows: TreeToRowsFn = (tree, rows = []) => {\n  if (!tree.length) return tree;\n  return tree.reduce(\n    (acc, node) => {\n      if (node[NODE_CHECK]) {\n        acc.push(node.root);\n        treeToRows(node.children, rows);\n      } else {\n        acc.push(node);\n      }\n      return acc;\n    },\n    rows as TreeNode[],\n  );\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport mergeSort from '../../utils/merge-sort';\nimport { NODE_CHECK, rowsToTree, treeToRows } from '../../utils/hierarchical-data';\nimport {\n  Row, GetRowLevelKeyFn, CompareFn, CreateCompareFn, SortedRowsFn, TreeNode,\n} from '../../types';\n\nconst defaultCompare = (a: any, b: any) => {\n  if (a === b) return 0;\n\n  if (a === null) {\n    return b === undefined ? -1 : 1;\n  }\n  if (a === undefined) {\n    return 1;\n  }\n  if (b === null || b === undefined) {\n    return -1;\n  }\n  return a < b ? -1 : 1;\n};\n\nconst createCompare: CreateCompareFn = (\n  sorting, getColumnCompare, getComparableValue,\n) => sorting.reduceRight((prevCompare, columnSorting) => {\n  const { columnName } = columnSorting;\n  const inverse = columnSorting.direction === 'desc';\n  const columnCompare = (getColumnCompare && getColumnCompare(columnName)) || defaultCompare;\n\n  return (aRow: Row, bRow: Row) => {\n    const a = getComparableValue(aRow, columnName);\n    const b = getComparableValue(bRow, columnName);\n    const result = columnCompare(a, b);\n\n    if (result !== 0) {\n      return inverse ? -result : result;\n    }\n    return prevCompare(aRow, bRow);\n  };\n}, (...args: any[]) => 0);\n\nconst sortTree: PureComputed<[TreeNode[], CompareFn]> = (tree, compare) => {\n  const sortedTree = tree.map((node) => {\n    if (node[NODE_CHECK]) {\n      return {\n        ...node,\n        children: sortTree(node.children, compare),\n      };\n    }\n    return node;\n  });\n\n  return mergeSort(\n    sortedTree, (a, b) => compare(a[NODE_CHECK] ? a.root : a, b[NODE_CHECK] ? b.root : b),\n  );\n};\n\nconst sortHierarchicalRows: PureComputed<[Row[], CompareFn, GetRowLevelKeyFn]> = (\n  rows, compare, getRowLevelKey,\n) => {\n  const tree = rowsToTree(rows, getRowLevelKey);\n\n  const sortedTree = sortTree(tree, compare);\n\n  return treeToRows(sortedTree);\n};\n\nexport const sortedRows: SortedRowsFn = (\n  rows, sorting, getCellValue, getColumnCompare, isGroupRow, getRowLevelKey,\n) => {\n  if (!sorting.length || !rows.length) return rows;\n\n  let compare;\n  if (!getRowLevelKey) {\n    compare = createCompare(sorting, getColumnCompare, getCellValue);\n    return mergeSort(rows.slice(), compare);\n  }\n\n  compare = createCompare(sorting, getColumnCompare, (row, columnName) => {\n    if (isGroupRow && isGroupRow(row)) {\n      if (row.groupedBy === columnName) {\n        return row.value;\n      }\n      return undefined;\n    }\n    return getCellValue(row, columnName);\n  });\n  return sortHierarchicalRows(\n    rows,\n    compare,\n    getRowLevelKey,\n  );\n};\n","import { Filter, ChangeFilterPayload } from '../../types';\nimport { PureReducer, slice } from '@devexpress/dx-core';\n\nexport const changeColumnFilter: PureReducer<Filter[], ChangeFilterPayload> = (\n  filters, { columnName, config },\n) => {\n  const filterIndex = filters.findIndex(f => f.columnName === columnName);\n  const nextState = slice(filters);\n\n  if (config) {\n    const filter = { columnName, ...config };\n    if (filterIndex > -1) {\n      nextState.splice(filterIndex, 1, filter);\n    } else {\n      nextState.push(filter);\n    }\n  } else if (filterIndex > -1) {\n    nextState.splice(filterIndex, 1);\n  }\n\n  return nextState;\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { Filter } from '../../types';\n\nexport const getColumnFilterConfig: PureComputed<\n  [Filter[], string], Filter | null\n> = (filters, columnName) => (\n  filters.length && filters.filter(s => s.columnName === columnName)[0] || null\n);\n","import { FilterExpression, Filter } from '../../types';\nimport { PureComputed } from '@devexpress/dx-core';\n\nexport const filterExpression: PureComputed<\n  [Filter[], FilterExpression?], FilterExpression\n> = (filters, expression) => {\n  // tslint:disable-next-line: no-object-literal-type-assertion\n  const selfFilterExpr = { filters, operator: 'and' as 'and' } as FilterExpression;\n  if (!expression) {\n    return selfFilterExpr;\n  }\n  return {\n    operator: 'and' as 'and',\n    filters: [expression, selfFilterExpr] as FilterExpression[],\n  };\n};\n","import { NODE_CHECK, rowsToTree, treeToRows } from '../../utils/hierarchical-data';\nimport { PureComputed } from '@devexpress/dx-core';\nimport {\n  Row, Filter, FilterPredicate,\n  FilterExpression, GetCellValueFn, RowsWithCollapsedRowsMetaMap,\n  UnwrapRowsComputed, FilteredRowsFn, FilterHierarchicalRowsFn,\n  CompiledPredicate, GetColumnPredicateFn, FilteredCollapsedRowsGetterFn, TreeNode,\n} from '../../types';\n\nconst operators = {\n  or: (predicates: CompiledPredicate[]) => (row: Row) => (\n    predicates.reduce((acc, predicate) => acc || predicate(row), false)\n  ),\n  and: (predicates: CompiledPredicate[]) => (row: Row) => (\n    predicates.reduce((acc, predicate) => acc && predicate(row), true)\n  ),\n};\n\nconst toLowerCase = (value: any) => String(value).toLowerCase();\n\nconst operationPredicates: { [key: string]: FilterPredicate } = {\n  contains: (value, filter) => toLowerCase(value)\n    .indexOf(toLowerCase(filter.value)) > -1,\n\n  notContains: (value, filter) => toLowerCase(value)\n    .indexOf(toLowerCase(filter.value)) === -1,\n\n  startsWith: (value, filter) => toLowerCase(value)\n    .startsWith(toLowerCase(filter.value)),\n\n  endsWith: (value, filter) => toLowerCase(value)\n    .endsWith(toLowerCase(filter.value)),\n\n  equal: (value, filter) => String(value) === String(filter.value),\n  notEqual: (value, filter) => String(value) !== String(filter.value),\n\n  greaterThan: (value, filter) => value > filter.value!,\n  greaterThanOrEqual: (value, filter) => value >= filter.value!,\n  lessThan: (value, filter) => value < filter.value!,\n  lessThanOrEqual: (value, filter) => value <= filter.value!,\n};\n\nexport const defaultFilterPredicate: FilterPredicate = (value, filter) => {\n  const operation = filter.operation || 'contains';\n  return operationPredicates[operation](value, filter);\n};\n\nconst filterTree: PureComputed<[TreeNode[], CompiledPredicate]> = (tree, predicate) => tree.reduce(\n  (acc, node) => {\n    if (node[NODE_CHECK]) {\n      const filteredChildren = filterTree(node.children, predicate) as TreeNode[];\n      if (filteredChildren.length > 0) {\n        acc.push({\n          ...node,\n          children: filteredChildren,\n        });\n        return acc;\n      }\n      if (predicate(node.root, true)) {\n        acc.push(node.root);\n        return acc;\n      }\n      return acc;\n    }\n\n    if (predicate(node)) {\n      acc.push(node);\n      return acc;\n    }\n\n    return acc;\n  },\n  [] as TreeNode[],\n);\n\nconst filterHierarchicalRows: FilterHierarchicalRowsFn = (\n  rows, predicate, getRowLevelKey, getCollapsedRows,\n) => {\n  const tree = rowsToTree(rows, getRowLevelKey);\n  const collapsedRowsMeta: any[] = [];\n\n  const filteredTree = filterTree(tree, (row, isNode) => {\n    if (isNode) {\n      const collapsedRows = getCollapsedRows && getCollapsedRows(row);\n      if (collapsedRows && collapsedRows.length) {\n        const filteredCollapsedRows = collapsedRows.filter(predicate);\n        collapsedRowsMeta.push([row, filteredCollapsedRows]);\n        return !!filteredCollapsedRows.length || predicate(row);\n      }\n      if (predicate(row)) {\n        collapsedRowsMeta.push([row, []]);\n        return true;\n      }\n      return false;\n    }\n    return predicate(row);\n  });\n\n  return { rows: treeToRows(filteredTree), collapsedRowsMeta: new Map(collapsedRowsMeta) };\n};\n\nconst buildPredicate: PureComputed<\n  [FilterExpression, GetCellValueFn, GetColumnPredicateFn],\n  CompiledPredicate\n> = (\n  initialFilterExpression, getCellValue, getColumnPredicate,\n) => {\n  const getSimplePredicate = (filter: Filter) => {\n    const { columnName } = filter;\n    const customPredicate = getColumnPredicate && getColumnPredicate(columnName);\n    const predicate = customPredicate || defaultFilterPredicate;\n    return (row: Row) => predicate(getCellValue(row, columnName), filter, row);\n  };\n\n  const getOperatorPredicate: any = (filterExpression: FilterExpression) => {\n    const build = operators[toLowerCase(filterExpression.operator)];\n    return build && build(filterExpression.filters.map(getPredicate));\n  };\n\n  const getPredicate = (filterExpression: any) => (\n    getOperatorPredicate(filterExpression)\n    || getSimplePredicate(filterExpression)\n  );\n\n  return getPredicate(initialFilterExpression);\n};\n\nexport const filteredRows: FilteredRowsFn = (\n  rows, filterExpression, getCellValue, getColumnPredicate, getRowLevelKey, getCollapsedRows,\n) => {\n  if (!(filterExpression && Object.keys(filterExpression).length && rows.length)) {\n    // tslint:disable-next-line:no-object-literal-type-assertion\n    return { rows } as Partial<RowsWithCollapsedRowsMetaMap>;\n  }\n\n  const predicate = buildPredicate(\n    filterExpression,\n    getCellValue,\n    getColumnPredicate,\n  );\n\n  return getRowLevelKey\n    ? filterHierarchicalRows(rows, predicate, getRowLevelKey, getCollapsedRows)\n    : { rows: rows.filter(predicate) };\n};\n\nexport const filteredCollapsedRowsGetter: FilteredCollapsedRowsGetterFn = (\n  { collapsedRowsMeta },\n) => row => collapsedRowsMeta && collapsedRowsMeta.get(row);\n\nexport const unwrappedFilteredRows: UnwrapRowsComputed = ({ rows }) => rows;\n","import { PureReducer, slice } from '@devexpress/dx-core';\nimport { Getters } from '@devexpress/dx-react-core';\nimport { GROUP_KEY_SEPARATOR } from './constants';\nimport {\n  Grouping, ColumnGroupingState, ChangeGroupingPayload, ToggleGroupPayload, DraftGroupingState,\n} from '../../types';\n\nconst applyColumnGrouping: PureReducer<Grouping[], ChangeGroupingPayload> = (\n  grouping, { columnName, groupIndex },\n) => {\n  let nextGrouping = grouping;\n  const groupingIndex = nextGrouping.findIndex(g => g.columnName === columnName);\n  let targetIndex = groupIndex;\n\n  if (groupingIndex > -1) {\n    nextGrouping = slice(grouping);\n    (nextGrouping as Grouping[]).splice(groupingIndex, 1);\n  } else if (groupIndex === undefined) {\n    targetIndex = nextGrouping.length;\n  }\n\n  if (targetIndex > -1) {\n    nextGrouping = slice(nextGrouping);\n    (nextGrouping as Grouping[]).splice(targetIndex, 0, {\n      columnName,\n    });\n  }\n\n  return nextGrouping;\n};\n\nexport const changeColumnGrouping: PureReducer<ColumnGroupingState, ChangeGroupingPayload> = (\n  { grouping, expandedGroups }, { columnName, groupIndex },\n) => {\n  const nextGrouping = applyColumnGrouping(grouping!, { columnName, groupIndex });\n\n  const ungroupedColumnIndex = grouping!.findIndex(\n    (group, index) => !nextGrouping[index] || group.columnName !== nextGrouping[index].columnName,\n  );\n  if (ungroupedColumnIndex === -1) {\n    return {\n      grouping: nextGrouping,\n    };\n  }\n\n  const filteredExpandedGroups = expandedGroups!.filter(\n    group => group.split(GROUP_KEY_SEPARATOR).length <= ungroupedColumnIndex,\n  );\n  if (filteredExpandedGroups.length === expandedGroups!.length) {\n    return {\n      grouping: nextGrouping,\n    };\n  }\n\n  return {\n    grouping: nextGrouping,\n    expandedGroups: filteredExpandedGroups,\n  };\n};\n\nexport const toggleExpandedGroups: PureReducer<ColumnGroupingState, ToggleGroupPayload> = (\n  state, { groupKey },\n) => {\n  const expandedGroups = slice(state.expandedGroups);\n  const groupKeyIndex = expandedGroups.indexOf(groupKey);\n\n  if (groupKeyIndex > -1) {\n    expandedGroups.splice(groupKeyIndex, 1);\n  } else {\n    expandedGroups.push(groupKey);\n  }\n\n  return {\n    expandedGroups,\n  };\n};\n\nexport const draftColumnGrouping: PureReducer<\n  Getters, ChangeGroupingPayload, DraftGroupingState\n> = (\n  { grouping, draftGrouping },\n  { columnName, groupIndex },\n) => ({\n  draftGrouping: applyColumnGrouping(draftGrouping || grouping, { columnName, groupIndex }),\n});\n\nexport const cancelColumnGroupingDraft = () => ({\n  draftGrouping: null,\n});\n","export const GROUP_KEY_SEPARATOR = '|';\n","import { PureComputed } from '@devexpress/dx-core';\nimport { Grouping, Sorting, GroupIndex } from '../../types';\n\nexport const adjustSortIndex: PureComputed<[GroupIndex, Grouping[], Sorting[]]> = (\n  groupingIndex, grouping, sorting,\n) => Math.max(\n  grouping.slice(0, groupingIndex).reduce(\n    (acc, columnGrouping) => {\n      const columnSortingIndex = sorting.findIndex(\n        columnSorting => columnSorting.columnName === columnGrouping.columnName,\n      );\n      return (columnSortingIndex === -1 ? acc - 1 : acc);\n    },\n    groupingIndex,\n  ),\n  0,\n);\n","import { GetIntegratedGroupsFn, GetGroupRowsFn, Row } from '../../types';\nimport { GROUP_KEY_SEPARATOR } from '../grouping-state/constants';\nimport { GRID_GROUP_CHECK, GRID_GROUP_LEVEL_KEY, GRID_GROUP_TYPE } from './constants';\n\nconst defaultColumnCriteria = (value: any) => ({\n  value,\n  key: String(value),\n});\n\nexport const getGroupRows: GetGroupRowsFn = (\n  rows, grouping, groupsGetter,\n) => {\n  if (grouping.length === 0) {\n    return rows;\n  }\n\n  const keyPrefixes = [{ prefix: '', level: 0, rows }];\n  const resultRows = [] as Row[];\n  const compoundKeys = {};\n\n  while (keyPrefixes.length) {\n    const { prefix: keyPrefix, level, rows: currentRows } = keyPrefixes.pop()!;\n\n    const currentCompoundKey = keyPrefix.slice(0, keyPrefix.length - 1);\n    const groupIndex = compoundKeys[currentCompoundKey] ?? -1;\n\n    const groupRows: readonly Row[] = grouping[level] && currentRows.length\n      ? groupsGetter(currentRows, grouping[level], keyPrefix)\n          .map(({ childRows, ...params }: any, rowIndex) => {\n            const { compoundKey } = params;\n\n            compoundKeys[compoundKey] = groupIndex + rowIndex + 1;\n            keyPrefixes.push({\n              prefix: `${compoundKey}${GROUP_KEY_SEPARATOR}`,\n              level: level + 1,\n              rows: childRows || [],\n            });\n\n            return params;\n          })\n      : currentRows;\n\n    if (groupIndex > -1) {\n      resultRows.splice(groupIndex + 1, 0, ...groupRows);\n    } else {\n      groupRows.forEach(row => resultRows.push(row));\n    }\n  }\n\n  return resultRows;\n};\n\nexport const getIntegratedGroups: GetIntegratedGroupsFn = (\n  rows,\n  grouping,\n  keyPrefix,\n  getCellValue,\n  getColumnCriteria,\n) => {\n  const { columnName } = grouping;\n  const groupCriteria = (getColumnCriteria && getColumnCriteria(columnName))\n        || defaultColumnCriteria;\n\n  const groups = new Map();\n  rows.forEach((row) => {\n    const rawValue = getCellValue(row, columnName);\n    const { key, value } = groupCriteria(rawValue, row);\n    const sameKeyItems = groups.get(key);\n\n    if (!sameKeyItems) {\n      const groupingValue = value === rawValue ? value : value || key;\n      groups.set(key, [groupingValue, key, [row]]);\n    } else {\n      sameKeyItems[2].push(row);\n    }\n  });\n\n  const groupedBy = columnName;\n  return [...groups.values()]\n    .map(([value, key, childRows]) => ({\n      groupedBy,\n      compoundKey: `${keyPrefix}${key}`,\n      key,\n      value,\n      [GRID_GROUP_CHECK]: true,\n      [GRID_GROUP_LEVEL_KEY]: `${GRID_GROUP_TYPE.toString()}_${groupedBy}`,\n      childRows,\n    }));\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  GRID_GROUP_CHECK,\n  GRID_GROUP_LEVEL_KEY,\n  GRID_GROUP_COLLAPSED_ROWS,\n} from './constants';\nimport {\n  Grouping,\n  GroupKey,\n  Row,\n  GetCollapsedRowsFn,\n  IsSpecificRowFn,\n  GroupedRowsFn,\n  GroupsGetterFn,\n} from '../../types';\nimport { getGroupRows, getIntegratedGroups } from './helpers';\n\nexport const groupRowChecker: IsSpecificRowFn = row => row[GRID_GROUP_CHECK];\n\nexport const groupRowLevelKeyGetter = (row: Row) => (row ? row[GRID_GROUP_LEVEL_KEY] : undefined);\n\nexport const groupedRows: GroupedRowsFn = (\n  rows, grouping, getCellValue, getColumnCriteria,\n) => {\n  const groupsGetter: GroupsGetterFn = (currentRows, currentGrouping, prefix) =>\n    getIntegratedGroups(\n      currentRows,\n      currentGrouping,\n      prefix,\n      getCellValue,\n      getColumnCriteria,\n    );\n  return getGroupRows(rows, grouping, groupsGetter);\n};\n\nexport const expandedGroupRows: PureComputed<[Row[], Grouping[], GroupKey[], boolean]> = (\n  rows,\n  grouping,\n  expandedGroups,\n  isExporting,\n) => {\n  if (!grouping.length) return rows;\n\n  const groupingColumnNames = grouping.map(columnGrouping => columnGrouping.columnName);\n  const expandedGroupsSet = new Set(expandedGroups);\n  let currentGroupExpanded = true;\n  let currentGroupLevel = 0;\n\n  return rows.reduce((acc, row) => {\n    if (!row[GRID_GROUP_CHECK]) {\n      if (currentGroupExpanded) {\n        acc.push(row);\n      } else {\n        acc[acc.length - 1][GRID_GROUP_COLLAPSED_ROWS].push(row);\n      }\n      return acc;\n    }\n\n    const groupLevel = groupingColumnNames.indexOf(row.groupedBy);\n    if (groupLevel > currentGroupLevel && !currentGroupExpanded) {\n      return acc;\n    }\n\n    currentGroupExpanded = expandedGroupsSet.has(row.compoundKey) || isExporting;\n    currentGroupLevel = groupLevel;\n\n    if (currentGroupExpanded) {\n      acc.push(row);\n    } else {\n      acc.push({\n        ...row,\n        [GRID_GROUP_COLLAPSED_ROWS]: [],\n      });\n    }\n\n    return acc;\n  }, []);\n};\n\nexport const groupCollapsedRowsGetter: PureComputed<[GetCollapsedRowsFn]> =\n  getCollapsedRows => row => (\n  row[GRID_GROUP_COLLAPSED_ROWS] || (getCollapsedRows && getCollapsedRows(row))\n);\n","import { PureComputed } from '@devexpress/dx-core';\nimport { GRID_GROUP_CHECK } from '../integrated-grouping/constants';\nimport { GetRowIdFn, Row, RowId, CustomGroupedRowsFn, GroupsGetterFn } from '../../types';\nimport { getCustomGroups } from './helpers';\nimport { getGroupRows } from '../integrated-grouping/helpers';\n\nexport const customGroupedRows: CustomGroupedRowsFn = (\n  rows, grouping, getChildGroups, rootRows = rows,\n) => {\n  const groupsGetter: GroupsGetterFn = (currentRows, currentGrouping, prefix) =>\n    getCustomGroups(\n      currentRows,\n      currentGrouping,\n      prefix,\n      getChildGroups,\n      rootRows,\n    );\n  return getGroupRows(rows, grouping, groupsGetter);\n};\n\nexport const customGroupingRowIdGetter: PureComputed<[GetRowIdFn, Row[]]> = (getRowId, rows) => {\n  const firstRow = rows.find(row => !row[GRID_GROUP_CHECK]);\n  if (!firstRow || getRowId(firstRow) !== undefined) {\n    return getRowId;\n  }\n\n  const map = new Map<Row, RowId>(rows\n    .filter(row => !row[GRID_GROUP_CHECK])\n    .map((row, rowIndex) => [row, rowIndex]) as [Row, RowId]);\n\n  return row => map.get(row)!;\n};\n","import { GetCustomGroupsFn } from '../../types';\nimport {\n  GRID_GROUP_CHECK,\n  GRID_GROUP_LEVEL_KEY,\n  GRID_GROUP_TYPE,\n} from '../integrated-grouping/constants';\n\nexport const getCustomGroups: GetCustomGroupsFn = (\n  rows,\n  grouping,\n  keyPrefix,\n  getChildGroups,\n  rootRows,\n) => {\n  const groupedBy = grouping.columnName;\n  return getChildGroups(rows as any[], grouping, rootRows as any[])\n    .map(({ key, value = key, childRows }) => ({\n      groupedBy,\n      compoundKey: `${keyPrefix}${key}`,\n      key,\n      value,\n      [GRID_GROUP_CHECK]: true,\n      [GRID_GROUP_LEVEL_KEY]: `${GRID_GROUP_TYPE.toString()}_${groupedBy}`,\n      childRows,\n    }));\n};\n","import { GroupingPanelItemsFn } from '../../types/';\n\nexport const groupingPanelItems: GroupingPanelItemsFn = (\n  columns, grouping, draftGrouping,\n) => {\n  const items = draftGrouping.map(({ columnName }) => ({\n    column: columns.find(c => c.name === columnName)!,\n    draft: !grouping.some(columnGrouping => columnGrouping.columnName === columnName),\n  }));\n\n  grouping.forEach(({ columnName }, index) => {\n    if (draftGrouping.some(columnGrouping => columnGrouping.columnName === columnName)) return;\n    items.splice(index, 0, {\n      column: columns.find(c => c.name === columnName)!,\n      draft: true,\n    });\n  });\n\n  return items;\n};\n","export const setCurrentPage = (prevPage: number, page: number) => page;\nexport const setPageSize = (prevPageSize: number, size: number) => size;\n","import { clamp } from './helpers';\nimport { Row, GetRowLevelKeyFn, CurrentPageFn } from '../../types';\nimport { PureComputed } from '@devexpress/dx-core';\n\n// tslint:disable-next-line:max-line-length\nconst PAGE_HEADERS_OVERFLOW_ERROR = 'Max row level exceeds the page size. Consider increasing the page size.';\n\nexport const paginatedRows: PureComputed<[Row[], number, number]> = (rows, pageSize, page) => (\n  pageSize\n    ? rows.slice(pageSize * page, pageSize * (page + 1))\n    : rows as Row[]\n);\n\nexport const rowsWithPageHeaders: PureComputed<[Row[], number, GetRowLevelKeyFn]> = (\n  rows, pageSize, getRowLevelKey,\n) => {\n  if (!pageSize || !getRowLevelKey) return rows as Row[];\n\n  let result = rows.slice();\n\n  let headerRows: any[] = [];\n  let currentIndex = 0;\n  while (result.length > currentIndex) {\n    const row = result[currentIndex];\n    const levelKey = getRowLevelKey(row);\n    if (levelKey) {\n      const headerIndex = headerRows.findIndex(headerRow => getRowLevelKey(headerRow) === levelKey);\n      // tslint:disable-next-line:prefer-conditional-expression\n      if (headerIndex === -1) {\n        headerRows = [...headerRows, row];\n      } else {\n        headerRows = [...headerRows.slice(0, headerIndex), row];\n      }\n      if (headerRows.length >= pageSize) {\n        throw new Error(PAGE_HEADERS_OVERFLOW_ERROR);\n      }\n    }\n    const indexInPage = currentIndex % pageSize;\n    if (indexInPage < headerRows.length && row !== headerRows[indexInPage]) {\n      result = [\n        ...result.slice(0, currentIndex),\n        headerRows[indexInPage],\n        ...result.slice(currentIndex),\n      ];\n    }\n    currentIndex += 1;\n  }\n\n  return result;\n};\n\nexport const rowCount = (rows: Row[]) => rows.length;\n\nexport const pageCount: PureComputed<[number, number]> = (count, pageSize) => (\n  pageSize ? Math.ceil(count / pageSize) : 1\n);\n\nexport const currentPage: CurrentPageFn = (\n  page, totalCount, pageSize, setCurrentPage,\n) => {\n  const totalPages = pageCount(totalCount, pageSize);\n  const adjustedCurrentPage = clamp(page, totalPages - 1);\n  if (page !== adjustedCurrentPage) {\n    setTimeout(() => setCurrentPage(adjustedCurrentPage));\n  }\n  return adjustedCurrentPage;\n};\n","import { PureComputed } from '@devexpress/dx-core';\n\nexport const clamp: PureComputed<[number, number]> = (value, max) => (\n  Math.max(Math.min(value, max), 0)\n);\n","import { PureComputed } from '@devexpress/dx-core';\nimport { NthRowOnPageFn } from '../../types';\n\nexport const firstRowOnPage: NthRowOnPageFn = (currentPage, pageSize, totalCount) => {\n  if (totalCount === 0) {\n    return 0;\n  }\n  return pageSize ? (currentPage * pageSize) + 1 : 1;\n};\n\nexport const lastRowOnPage: NthRowOnPageFn = (currentPage, pageSize, totalRowCount) => {\n  let result = totalRowCount;\n  if (pageSize) {\n    const index = (currentPage + 1) * pageSize;\n    result = index > totalRowCount ? totalRowCount : index;\n  }\n\n  return result;\n};\n\nexport const calculateStartPage: PureComputed<[number, number, number]> = (\n  currentPage, maxButtonCount, totalPageCount,\n) => (\n  Math.max(\n    Math.min(\n    currentPage - Math.floor(maxButtonCount / 2),\n      (totalPageCount - maxButtonCount) + 1,\n    ),\n    1,\n  )\n);\n","import { PureComputed } from '@devexpress/dx-core';\nimport { RowId } from '../types';\n\nexport const toggle: PureComputed<[RowId[], RowId[], boolean?]> = (\n  source, items, state?,\n) => {\n  const itemsSet = new Set(items);\n\n  let sourceState: any = state;\n  if (sourceState === undefined) {\n    const availableSelection = source.filter(item => itemsSet.has(item));\n    sourceState = availableSelection.length !== itemsSet.size;\n  }\n\n  if (sourceState) {\n    const sourceSet = new Set(source);\n    return [\n      ...source,\n      ...items.filter(item => !sourceSet.has(item)),\n    ];\n  }\n\n  return source.filter(item => !itemsSet.has(item));\n};\n","import { toggle } from '../../utils/common-reducers';\nimport { ToggleRowsFieldReducer } from '../../types';\n\nexport const toggleSelection: ToggleRowsFieldReducer = (\n  selection, { rowIds, state },\n) => toggle(selection, rowIds, state);\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  RowsWithSelection, UnwrapRowsComputed, RowId, RowsWithAvailableToSelectFn,\n} from '../../types';\n\ntype RowsSelectedFn = PureComputed<[RowsWithSelection, RowId[]], boolean>;\n\nexport const rowsWithAvailableToSelect: RowsWithAvailableToSelectFn = (\n  rows, getRowId, isGroupRow,\n) => {\n  let dataRows = rows;\n  if (isGroupRow) {\n    dataRows = dataRows.filter(row => !isGroupRow(row));\n  }\n  return { rows, availableToSelect: dataRows.map(row => getRowId(row)) };\n};\n\nexport const someSelected: RowsSelectedFn = ({ availableToSelect }, selection) => {\n  const selectionSet = new Set(selection);\n\n  return availableToSelect.length !== 0 && selectionSet.size !== 0\n    && availableToSelect.some(elem => selectionSet.has(elem))\n    && availableToSelect.some(elem => !selectionSet.has(elem));\n};\n\nexport const allSelected: RowsSelectedFn = ({ availableToSelect }, selection) => {\n  const selectionSet = new Set(selection);\n\n  return selectionSet.size !== 0 && availableToSelect.length !== 0\n    && !availableToSelect.some(elem => !selectionSet.has(elem));\n};\n\nexport const unwrapSelectedRows: UnwrapRowsComputed = ({ rows }) => rows;\n","import { PureReducer } from '@devexpress/dx-core';\nimport { RowId, Row, RowIdsPayload, RowPayload, RowChangePayload,\n  RowChanges, EditingCell, EditingCellsPayload,\n} from '../../types';\n\nexport const startEditRows: PureReducer<RowId[], RowIdsPayload> = (\n  prevEditingRowIds, { rowIds },\n) => [...prevEditingRowIds, ...rowIds];\n\nexport const stopEditRows: PureReducer<RowId[], RowIdsPayload> = (\n  prevEditingRowIds, { rowIds },\n) => {\n  const rowIdSet = new Set(rowIds);\n  return prevEditingRowIds.filter(id => !rowIdSet.has(id));\n};\n\nexport const startEditCells: PureReducer<EditingCell[], EditingCellsPayload> = (\n  prevEditingCells, { editingCells },\n) => [...prevEditingCells, ...editingCells];\n\nexport const stopEditCells: PureReducer<EditingCell[], EditingCellsPayload> = (\n  prevEditingCells, { editingCells },\n) => {\n  return prevEditingCells.filter(({ rowId, columnName }) => (\n    !editingCells.some(({ rowId: currentRowId, columnName: currentColumnName }) => (\n      currentRowId === rowId && currentColumnName === columnName\n    ))\n  ));\n};\n\nexport const addRow: PureReducer<Row[], RowPayload> = (\n  addedRows, { row } = { row: {} },\n) => [...addedRows, row];\n\nexport const changeAddedRow: PureReducer<Row[], RowChangePayload> = (\n  addedRows, { rowId, change },\n) => {\n  const result = addedRows.slice();\n  result[rowId] = { ...result[rowId], ...change };\n  return result;\n};\n\nexport const cancelAddedRows: PureReducer<Row[], RowIdsPayload> = (addedRows, { rowIds }) => {\n  const result: Row[] = [];\n  const indexSet = new Set(rowIds);\n  addedRows.forEach((row, index) => {\n    if (!indexSet.has(index)) {\n      result.push(row);\n    }\n  });\n  return result;\n};\n\nexport const changeRow: PureReducer<RowChanges, RowChangePayload> = (\n  prevRowChanges, { rowId, change },\n) => {\n  const prevChange = prevRowChanges[rowId] || {};\n  return {\n    ...prevRowChanges,\n    [rowId]: {\n      ...prevChange,\n      ...change,\n    },\n  };\n};\n\nexport const cancelChanges: PureReducer<RowChanges, RowIdsPayload> = (\n  prevRowChanges, { rowIds },\n) => {\n  const result = { ...prevRowChanges };\n  rowIds.forEach((rowId) => {\n    delete result[rowId];\n  });\n  return result;\n};\n\nexport const deleteRows: PureReducer<RowId[], RowIdsPayload> = (deletedRowIds, { rowIds }) => [\n  ...deletedRowIds, ...rowIds,\n];\n\nexport const cancelDeletedRows: PureReducer<RowId[], RowIdsPayload> = (\n  deletedRowIds, { rowIds },\n) => {\n  const rowIdSet = new Set(rowIds);\n  return deletedRowIds.filter(rowId => !rowIdSet.has(rowId));\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  EditingColumnExtension, CreateRowChangeFn, Row, RowId, RowChanges,\n} from '../../types';\n\nexport const changedRowsByIds: PureComputed<\n  [any, RowId[]], RowChanges\n> = (changes, rowIds) => {\n  const result = {};\n  rowIds.forEach((rowId) => {\n    result[rowId] = changes[rowId];\n  });\n  return result;\n};\n\nexport const addedRowsByIds: PureComputed<[Row[], RowId[]]> = (addedRows, rowIds) => {\n  const rowIdSet = new Set(rowIds);\n  const result: Row[] = [];\n  addedRows.forEach((row, index) => {\n    if (rowIdSet.has(index)) {\n      result.push(row);\n    }\n  });\n  return result;\n};\n\nconst defaultCreateRowChange: CreateRowChangeFn = (row, value, columnName) => (\n  { [columnName]: value }\n);\nexport const createRowChangeGetter: PureComputed<\n  [CreateRowChangeFn?, EditingColumnExtension[]?], CreateRowChangeFn\n> = (\n  createRowChange = defaultCreateRowChange,\n  columnExtensions = [],\n) => {\n  const map = columnExtensions.reduce((acc, columnExtension) => {\n    if (columnExtension.createRowChange) {\n      acc[columnExtension.columnName] = columnExtension.createRowChange;\n    }\n    return acc;\n  }, {});\n\n  return (row, value, columnName) => {\n    if (map[columnName]) {\n      return map[columnName](row, value, columnName);\n    }\n    return createRowChange(row, value, columnName);\n  };\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { RowId, RowChanges } from '../../types';\n\nexport const getRowChange: PureComputed<[RowChanges, RowId], any> = (\n  rowChanges, rowId,\n) => rowChanges[rowId] || {};\n","export const TABLE_REORDERING_TYPE = Symbol('reordering');\n","import { PureReducer, slice } from '@devexpress/dx-core';\nimport { ColumnOrder, ChangeColumnOrderPayload } from '../../types';\n\nexport const changeColumnOrder: PureReducer<ColumnOrder, ChangeColumnOrderPayload> = (\n  order, { sourceColumnName, targetColumnName },\n) => {\n  const sourceColumnIndex = order.indexOf(sourceColumnName);\n  const targetColumnIndex = order.indexOf(targetColumnName);\n  const newOrder = slice(order);\n\n  newOrder.splice(sourceColumnIndex, 1);\n  newOrder.splice(targetColumnIndex, 0, sourceColumnName);\n  return newOrder;\n};\n","export const TABLE_DATA_TYPE = Symbol('data');\nexport const TABLE_NODATA_TYPE = Symbol('nodata');\nexport const TABLE_FLEX_TYPE = Symbol('flex');\n","import { PureComputed, slice } from '@devexpress/dx-core';\nimport mergeSort from '../../utils/merge-sort';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TABLE_REORDERING_TYPE } from './constants';\nimport { OrderedColumnsComputed, DraftOrderComputed, TableRow } from '../../types';\n\nexport const orderedColumns: OrderedColumnsComputed = (\n  tableColumns = [], order,\n) => mergeSort(tableColumns, (a, b) => {\n  if (a.type !== TABLE_DATA_TYPE || b.type !== TABLE_DATA_TYPE) return 0;\n\n  const aPos = order.indexOf(a.column.name);\n  const bPos = order.indexOf(b.column.name);\n  return aPos - bPos;\n});\n\nexport const tableHeaderRowsWithReordering: PureComputed<[TableRow[]]> = tableHeaderRows => [\n  ...tableHeaderRows,\n  {\n    key: TABLE_REORDERING_TYPE.toString(),\n    type: TABLE_REORDERING_TYPE,\n    height: 0,\n  },\n];\n\nexport const draftOrder: DraftOrderComputed = (order, sourceColumnIndex, targetColumnIndex) => {\n  if (sourceColumnIndex === -1\n    || targetColumnIndex === -1\n    || sourceColumnIndex === targetColumnIndex) {\n    return order;\n  }\n\n  const result = slice(order);\n  const sourceColumn = order[sourceColumnIndex];\n  result.splice(sourceColumnIndex, 1);\n  result.splice(targetColumnIndex, 0, sourceColumn);\n\n  return result;\n};\n","import { ColumnSizesFn, ValidValueFn, ConvertWidthFn, ColumnWidthFn } from '../../types';\n\nconst getColumnWidth: ColumnWidthFn = (\n  columnWidths, name, {\n    columnName, cachedWidths, shift, minColumnWidth, maxColumnWidth, columnExtensions = [],\n}) => {\n  const change = name === columnName ? shift : -shift;\n  const column  = columnWidths.find(elem => elem.columnName === name)!;\n  const extension = columnExtensions.find(elem => elem.columnName === name);\n  const width = typeof column.width === 'number'\n    ? column.width\n    : cachedWidths[name];\n  const minWidth = extension && extension.minWidth! >= 0\n    ? extension.minWidth\n    : minColumnWidth;\n  const maxWidth = extension && extension.maxWidth! >= 0\n    ? extension.maxWidth\n    : maxColumnWidth;\n  const size = Math.max(\n    minWidth!,\n    Math.min(width + change, maxWidth!),\n  );\n\n  return ({ width, size });\n};\n\nexport const getColumnSizes: ColumnSizesFn = (\n  columnWidths, payload) => {\n  const { columnName, nextColumnName, resizingMode, shift } = payload;\n  const { width, size } = getColumnWidth(columnWidths, columnName, payload);\n\n  if (resizingMode === 'nextColumn') {\n    const { width: nextWidth, size: nextSize } = getColumnWidth(\n      columnWidths, nextColumnName, payload,\n    );\n\n    if (size + nextSize !== width + nextWidth) {\n      const moreThanLimit = size + nextSize > width + nextWidth;\n      const columnExpand = shift > 0;\n      if (moreThanLimit !== columnExpand) {\n        return { size, nextSize: width + nextWidth - size };\n      }\n      return { size: width + nextWidth - nextSize, nextSize };\n    }\n    return { size, nextSize };\n  }\n\n  return { size };\n};\n\nexport const isValidValue: ValidValueFn = (value, validUnits) => {\n  const numb = parseInt(value, 10);\n  const unit = numb ? value.substr(numb.toString().length) : value;\n  const sizeIsAuto = isNaN(numb) && unit === 'auto';\n  const sizeIsValid = numb >= 0 && validUnits.some(validUnit => validUnit === unit);\n  return sizeIsAuto || sizeIsValid;\n};\n\nexport const convertWidth: ConvertWidthFn = (value) => {\n  if (typeof value === 'string') {\n    const numb = parseInt(value, 10);\n    if (value.substr(numb.toString().length).length > 0) {\n      return value;\n    }\n    return numb;\n  }\n  return value;\n};\n","import { TABLE_DATA_TYPE } from '../table/constants';\nimport { TableColumn, SpecifyWidthsFn, TableColumnsWithWidthFn, ErrorFn } from '../../types';\nimport { isValidValue, convertWidth } from './helpers';\n\nconst VALID_UNITS = ['px', '%', 'em', 'rem', 'vm', 'vh', 'vmin', 'vmax', ''];\nconst NOT_FOR_WIDGET_UNITS = ['%'];\n/* tslint:disable max-line-length */\nconst COLUMN_RESIZING_ERROR = 'The columnWidths property of the TableColumnResizing plugin is given an invalid value.';\n\nconst specifyWidths: SpecifyWidthsFn = (tableColumns, widths, resizingMode, onError) => {\n  if (resizingMode !== 'widget' && resizingMode !== 'nextColumn') {\n    onError();\n  }\n  if (!widths.length) return tableColumns;\n  return tableColumns\n    .reduce((acc, tableColumn) => {\n      if (tableColumn.type === TABLE_DATA_TYPE) {\n        const columnName = tableColumn.column!.name;\n        const column = widths.find(el => el.columnName === columnName);\n        const width = column && column.width;\n        if (typeof width !== 'number') {\n          if (width === undefined) {\n            onError();\n          } else if (!isValidValue(width, VALID_UNITS)) {\n            onError();\n          } else if (resizingMode === 'widget' && isValidValue(width, NOT_FOR_WIDGET_UNITS)) {\n            onError();\n          }\n        } else if (width < 0) {\n          onError();\n        }\n        if (width === undefined) {\n          acc.push(tableColumn);\n        } else {\n          acc.push({ ...tableColumn, width: convertWidth(width) });\n        }\n      } else {\n        acc.push(tableColumn);\n      }\n      return acc;\n    }, [] as TableColumn[]);\n};\n\nexport const tableColumnsWithWidths: TableColumnsWithWidthFn = (\n  tableColumns, columnWidths, resizingMode,\n) => specifyWidths(tableColumns, columnWidths, resizingMode, throwError);\n\nexport const tableColumnsWithDraftWidths: TableColumnsWithWidthFn = (\n  tableColumns, draftColumnWidths, resizingMode,\n) => specifyWidths(tableColumns, draftColumnWidths, resizingMode, () => {});\n\nconst throwError: ErrorFn = () => {\n  throw new Error(COLUMN_RESIZING_ERROR);\n};\n","import { slice } from '@devexpress/dx-core';\nimport { ColumnWidthReducer } from '../../types';\nimport { getColumnSizes } from './helpers';\n\nexport const changeTableColumnWidth: ColumnWidthReducer = (state, payload) => {\n  const { columnWidths } = state;\n  const { columnName, nextColumnName, resizingMode } = payload;\n  const nextColumnWidth = slice(columnWidths);\n  const index = nextColumnWidth.findIndex(elem => elem.columnName === columnName);\n  const nextIndex = nextColumnWidth.findIndex(elem => elem.columnName === nextColumnName);\n  const { size, nextSize } = getColumnSizes(columnWidths, payload);\n\n  nextColumnWidth.splice(index, 1, { columnName, width: size });\n  if (resizingMode === 'nextColumn') {\n    nextColumnWidth.splice(nextIndex, 1, { columnName: nextColumnName, width: nextSize });\n  }\n  return {\n    columnWidths: nextColumnWidth,\n  };\n};\n\nexport const draftTableColumnWidth: ColumnWidthReducer = (state, payload) => {\n  const { columnWidths } = state;\n  const { columnName, nextColumnName, resizingMode } = payload;\n  const { size, nextSize } = getColumnSizes(columnWidths, payload);\n\n  if (resizingMode === 'nextColumn') {\n    return { draftColumnWidths: [\n      { columnName, width: size }, { columnName: nextColumnName, width: nextSize! },\n    ] };\n  }\n  return { draftColumnWidths: [{ columnName, width: size }] };\n};\n\nexport const cancelTableColumnWidthDraft = () => ({\n  draftColumnWidths: [],\n});\n","export const TABLE_EDIT_COMMAND_TYPE = Symbol('editCommand');\n","export const TABLE_ADDED_TYPE = Symbol('added');\nexport const TABLE_EDIT_TYPE = Symbol('edit');\n","export const TABLE_HEADING_TYPE = Symbol('heading');\n","import { TABLE_ADDED_TYPE, TABLE_EDIT_TYPE } from '../table-edit-row/constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TABLE_HEADING_TYPE } from '../table-header-row/constants';\nimport { TABLE_EDIT_COMMAND_TYPE } from './constants';\nimport { IsSpecificCellFn } from '../../types';\n\nexport const isHeadingEditCommandsTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_HEADING_TYPE && tableColumn.type === TABLE_EDIT_COMMAND_TYPE;\nexport const isEditCommandsTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => (tableRow.type === TABLE_DATA_TYPE || tableRow.type === TABLE_ADDED_TYPE\n  || tableRow.type === TABLE_EDIT_TYPE) && tableColumn.type === TABLE_EDIT_COMMAND_TYPE;\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_EDIT_COMMAND_TYPE } from './constants';\nimport { TableColumn } from '../../types';\nimport { convertWidth } from '../table-column-resizing/helpers';\n\nexport const tableColumnsWithEditing: PureComputed<[TableColumn[], number | string]> = (\n  tableColumns, width,\n) => [\n  { width: convertWidth(width),\n    key: TABLE_EDIT_COMMAND_TYPE.toString(), type: TABLE_EDIT_COMMAND_TYPE },\n  ...tableColumns];\n","import { TABLE_ADDED_TYPE, TABLE_EDIT_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { IsSpecificRowFn, IsSpecificCellFn } from '../../types';\n\nexport const isEditTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => (tableRow.type === TABLE_ADDED_TYPE || tableRow.type === TABLE_EDIT_TYPE)\n  && tableColumn.type === TABLE_DATA_TYPE;\nexport const isAddedTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_ADDED_TYPE;\nexport const isEditTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_EDIT_TYPE;\n","import { slice } from '@devexpress/dx-core';\nimport { TABLE_ADDED_TYPE, TABLE_EDIT_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TableRowsWithEditingFn } from '../../types';\n\nexport const tableRowsWithEditing: TableRowsWithEditingFn = (\n  tableRows, editingRowIds, addedRows, rowHeight,\n) => {\n  const rowIds = new Set(editingRowIds);\n  const editedTableRows = tableRows\n    .map(tableRow => (\n      tableRow.type === TABLE_DATA_TYPE && rowIds.has(tableRow.rowId!)\n        ? {\n          ...tableRow,\n          type: TABLE_EDIT_TYPE,\n          height: rowHeight,\n        }\n        : tableRow\n    ));\n\n  const addedTableRows = addedRows\n    .map((row, rowIndex) => ({\n      row,\n      key: `${TABLE_ADDED_TYPE.toString()}_${rowIndex}`,\n      type: TABLE_ADDED_TYPE,\n      rowId: rowIndex,\n      height: rowHeight,\n    }));\n\n  return [\n    ...slice(addedTableRows).reverse(),\n    ...editedTableRows,\n  ];\n};\n","import { TableRowsWithEditingCellsFn, TableColumnsWithEditingCellsFn } from '../../types';\nimport { TABLE_DATA_TYPE } from '../table/constants';\n\nexport const rowsWithEditingCells: TableRowsWithEditingCellsFn = (\n  tableBodyRows, editingCells,\n) => tableBodyRows.map((row) => {\n  const { rowId, type } = row;\n  if (\n    rowId !== undefined &&\n    type === TABLE_DATA_TYPE &&\n    editingCells.some(elem => elem.rowId === rowId)\n  ) {\n    return {\n      ...row,\n      hasEditCell: true,\n    };\n  }\n  return row;\n});\n\nexport const columnsWithEditingCells: TableColumnsWithEditingCellsFn = (\n  tableColumns, editingCells,\n) => tableColumns.map((tableColumn) => {\n  const columnName = tableColumn.column ? tableColumn.column.name : undefined;\n  if (columnName !== undefined && editingCells.some(elem => elem.columnName === columnName)) {\n    return {\n      ...tableColumn,\n      hasEditCell: true,\n    };\n  }\n  return tableColumn;\n});\n","export const TABLE_FILTER_TYPE = Symbol('filter');\nexport const DEFAULT_FILTER_OPERATIONS = [\n  'contains',\n  'notContains',\n  'startsWith',\n  'endsWith',\n  'equal',\n  'notEqual',\n];\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_FILTER_TYPE, DEFAULT_FILTER_OPERATIONS } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport {\n  IsSpecificCellFn, IsSpecificRowFn, FilterOperation, GetAvailableFilterOperationsFn,\n  GetSelectedFilterOperationFn,\n} from '../../types';\n\nexport const isFilterTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_FILTER_TYPE && tableColumn.type === TABLE_DATA_TYPE;\n\nexport const isFilterTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_FILTER_TYPE;\n\nexport const getColumnFilterOperations: PureComputed<\n  [GetAvailableFilterOperationsFn, string],\n  FilterOperation[]\n> = (\n  getAvailableFilterOperations, columnName,\n) => (getAvailableFilterOperations && getAvailableFilterOperations(columnName))\n  || DEFAULT_FILTER_OPERATIONS;\n\nexport const isFilterValueEmpty = (value: any) => value === undefined || !String(value).length;\n\nexport const getSelectedFilterOperation: GetSelectedFilterOperationFn = (\n  filterOperations, columnName, columnFilter, columnFilterOperations,\n) => {\n  if (columnFilter && columnFilter.operation) {\n    return columnFilter.operation;\n  }\n  if (filterOperations[columnName]) {\n    return filterOperations[columnName];\n  }\n  return columnFilterOperations[0];\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_FILTER_TYPE } from './constants';\nimport { TableRow } from '../../types';\n\nexport const tableHeaderRowsWithFilter: PureComputed<[TableRow[], number]> = (\n  headerRows, rowHeight,\n) => [\n  ...headerRows,\n  { key: TABLE_FILTER_TYPE.toString(), type: TABLE_FILTER_TYPE, height: rowHeight }];\n","export const TABLE_GROUP_TYPE = Symbol('group');\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  GetVisibleBoundaryWithFixedFn, VisibleBoundary, GetVisibleBoundaryFn, GetSpanBoundaryFn,\n  CollapseBoundariesFn, GetColumnsSizeFn, GetCollapsedColumnsFn, CollapsedColumn,\n  GetCollapsedAndStubRowsFn, GetCollapsedCellsFn, GetCollapsedGridFn, GetColumnWidthFn,\n  TableColumn,\n  CollapsedCell,\n  GetColumnWidthGetterFn,\n  GetCollapsedGridsFn,\n  CollapsedGrid,\n  GetSpecificRenderBoundaryFn,\n  GetRenderBoundaryFn,\n  GetRowsVisibleBoundaryFn,\n} from '../types';\nimport { TABLE_FLEX_TYPE, intervalUtil } from '..';\n\nexport const TABLE_STUB_TYPE = Symbol('stub');\n\nexport const getVisibleBoundaryWithFixed: GetVisibleBoundaryWithFixedFn = (\n  visibleBoundary, items,\n) => items.reduce((acc, item, index) => {\n  if (item.fixed && (index < visibleBoundary[0] || index > visibleBoundary[1])) {\n    acc.push([index, index]);\n  }\n  return acc;\n}, [visibleBoundary] as [VisibleBoundary]);\n\nexport const getVisibleBoundary: GetVisibleBoundaryFn = (\n  items, viewportStart, viewportSize, getItemSize, offset = 0, itemSize = 0,\n) => {\n  let start: number | null = null;\n  let end: number | null = null;\n  let index = 0;\n  let beforePosition = offset * itemSize;\n\n  const viewportEnd = viewportStart + viewportSize;\n  while (end === null && index < items.length) {\n    const item = items[index];\n    const afterPosition = beforePosition + getItemSize(item)!;\n    const isVisible = (beforePosition >= viewportStart && beforePosition < viewportEnd)\n      || (afterPosition > viewportStart && afterPosition <= viewportEnd)\n      || (beforePosition < viewportStart && afterPosition > viewportEnd);\n    if (isVisible && start === null) {\n      start = index;\n    }\n    if (!isVisible && start !== null) {\n      end = index - 1;\n      break;\n    }\n    index += 1;\n    beforePosition = afterPosition;\n  }\n  if (start !== null && end === null) {\n    end = index - 1;\n  }\n\n  start = start === null ? 0 : start;\n  end = end === null ? 0 : end;\n\n  return [start + offset, end + offset];\n};\n\nexport const getRenderBoundary: GetRenderBoundaryFn = (itemsCount, visibleBoundary, overscan) => {\n  let [start, end] = visibleBoundary;\n  start = Math.max(0, start - overscan);\n  end = Math.min(itemsCount - 1, end + overscan);\n\n  return [start, end];\n};\n\nexport const getColumnBoundaries: PureComputed<\n  [TableColumn[], number, number, GetColumnWidthFn], VisibleBoundary[]\n> = (columns, left, width, getColumnWidth) => (\n  getVisibleBoundaryWithFixed(\n    getColumnsRenderBoundary(\n      columns.length,\n      getVisibleBoundary(columns, left, width, getColumnWidth, 0),\n    ),\n    columns,\n  )\n);\nexport const getRowsVisibleBoundary: GetRowsVisibleBoundaryFn = (\n  rows, top, height, getRowHeight, offset, rowHeight, isDataRemote,\n) => {\n  const beforePosition = offset * rowHeight;\n  const noVisibleRowsLoaded = rowHeight > 0 &&\n    beforePosition + rows.length * rowHeight < top ||\n    top < beforePosition;\n\n  let boundaries;\n  if (isDataRemote && noVisibleRowsLoaded) {\n    const topIndex = Math.round(top / rowHeight);\n    boundaries = [topIndex, topIndex];\n  } else {\n    boundaries = getVisibleBoundary(rows, top, height, getRowHeight, offset, rowHeight);\n  }\n\n  return boundaries;\n};\n\nexport const getColumnsRenderBoundary: GetSpecificRenderBoundaryFn = (\n  columnCount, visibleBoundary,\n) => getRenderBoundary(columnCount, visibleBoundary, 1);\n\nexport const getRowsRenderBoundary: GetSpecificRenderBoundaryFn = (\n  rowsCount, visibleBoundary,\n) => getRenderBoundary(rowsCount, visibleBoundary, 3);\n\nexport const getSpanBoundary: GetSpanBoundaryFn = (\n  items, visibleBoundaries, getItemSpan,\n) => visibleBoundaries\n  .map((visibleBoundary) => {\n    const endIndex = Math.min(visibleBoundary[1], items.length - 1);\n    let end = endIndex;\n    let start = visibleBoundary[0] <= end ? visibleBoundary[0] : 0;\n\n    for (let index = 0; index <= endIndex; index += 1) {\n      const span = getItemSpan(items[index]);\n      if (index < visibleBoundary[0] && index + span > visibleBoundary[0]) {\n        start = index;\n      }\n      if (index + (span - 1) > visibleBoundary[1]) {\n        end = index + (span - 1);\n      }\n    }\n    return [start, end] as VisibleBoundary;\n  });\n\nexport const collapseBoundaries: CollapseBoundariesFn = (\n  itemsCount, visibleBoundaries, spanBoundaries,\n) => {\n  const breakpoints = new Set([0, itemsCount]);\n  spanBoundaries.forEach(rowBoundaries => rowBoundaries\n    .forEach((boundary) => {\n      breakpoints.add(boundary[0]);\n      // next interval starts after span end point\n      breakpoints.add(Math.min(boundary[1] + 1, itemsCount));\n    }));\n\n  visibleBoundaries\n    .filter(boundary => boundary.every(bound => 0 <= bound && bound < itemsCount))\n    .forEach((boundary) => {\n      for (let point = boundary[0]; point <= boundary[1]; point += 1) {\n        breakpoints.add(point);\n      }\n      if (boundary[1] + 1 < itemsCount) {\n        // close last visible point\n        breakpoints.add(boundary[1] + 1);\n      }\n    });\n\n  const bp = [...breakpoints].sort((a, b) => a - b);\n  const bounds: any[] = [];\n  for (let i = 0; i < bp.length - 1; i += 1) {\n    bounds.push([\n      bp[i],\n      bp[i + 1] - 1,\n    ]);\n  }\n\n  return bounds;\n};\n\nconst getColumnsSize: GetColumnsSizeFn = (columns, startIndex, endIndex, getColumnSize) => {\n  let size = 0;\n  for (let i = startIndex; i <= endIndex; i += 1) {\n    size += getColumnSize(columns[i], 0) || 0;\n  }\n  return size;\n};\n\nexport const getCollapsedColumns: GetCollapsedColumnsFn = (\n  columns, visibleBoundaries, boundaries, getColumnWidth,\n) => {\n  const collapsedColumns: CollapsedColumn[] = [];\n  boundaries.forEach((boundary) => {\n    const isVisible = visibleBoundaries.reduce((acc, visibleBoundary) => (\n      acc || (visibleBoundary[0] <= boundary[0] && boundary[1] <= visibleBoundary[1])\n    ), false);\n\n    if (isVisible) {\n      const column = columns[boundary[0]];\n      collapsedColumns.push({\n        ...column,\n        width: getColumnWidth(column) as number,\n      });\n    } else {\n      collapsedColumns.push({\n        key: `${TABLE_STUB_TYPE.toString()}_${boundary[0]}_${boundary[1]}`,\n        type: TABLE_STUB_TYPE,\n        width: getColumnsSize(columns, boundary[0], boundary[1], getColumnWidth),\n      });\n    }\n  });\n  return collapsedColumns;\n};\n\nexport const getCollapsedRows: GetCollapsedAndStubRowsFn = (\n  rows, visibleBoundary, boundaries, getRowHeight, getCells, offset,\n) => {\n  const collapsedRows: any[] = [];\n  boundaries.forEach((boundary) => {\n    const isVisible = visibleBoundary[0] <= boundary[0] && boundary[1] <= visibleBoundary[1];\n    if (isVisible) {\n      const row = rows[boundary[0] - offset];\n      collapsedRows.push({\n        row,\n        cells: getCells(row),\n      });\n    } else {\n      const row = {} as any;\n      collapsedRows.push({\n        row: {\n          key: `${TABLE_STUB_TYPE.toString()}_${boundary[0]}_${boundary[1]}`,\n          type: TABLE_STUB_TYPE,\n          height: getColumnsSize(rows, boundary[0], boundary[1], getRowHeight),\n        },\n        cells: getCells(row),\n      });\n    }\n  });\n  return collapsedRows;\n};\n\nexport const getCollapsedCells: GetCollapsedCellsFn = (\n  columns, spanBoundaries, boundaries, getColSpan,\n) => {\n  const collapsedCells: CollapsedCell[] = [];\n  let index = 0;\n  while (index < boundaries.length) {\n    const boundary = boundaries[index];\n    const isSpan = spanBoundaries.reduce((acc, spanBoundary) => (\n      acc || (spanBoundary[0] <= boundary[0] && boundary[1] <= spanBoundary[1])), false);\n    if (isSpan) {\n      const column = columns[boundary[0]];\n      const realColSpan = getColSpan(column);\n      const realColSpanEnd = (realColSpan + boundary[0]) - 1;\n      const colSpanEnd = boundaries.findIndex(\n        colSpanBoundary => colSpanBoundary[0]\n        <= realColSpanEnd && realColSpanEnd\n        <= colSpanBoundary[1],\n      );\n      collapsedCells.push({\n        column,\n        colSpan: (colSpanEnd - index) + 1,\n      });\n      index += 1;\n    } else {\n      collapsedCells.push({\n        column: {\n          key: `${TABLE_STUB_TYPE.toString()}_${boundary[0]}_${boundary[1]}`,\n          type: TABLE_STUB_TYPE,\n        },\n        colSpan: 1,\n      });\n      index += 1;\n    }\n  }\n  return collapsedCells;\n};\n\nexport const getCollapsedGrid: GetCollapsedGridFn = ({\n  rows,\n  columns,\n  rowsVisibleBoundary,\n  columnsVisibleBoundary,\n  getColumnWidth = (column: any) => column.width,\n  getRowHeight = (row: any) => row.height,\n  getColSpan = () => 1,\n  totalRowCount,\n  offset,\n}) => {\n  if (!columns.length) {\n    return {\n      columns: [],\n      rows: [],\n    };\n  }\n\n  const boundaries = rowsVisibleBoundary || [0, rows.length - 1 || 1];\n\n  const rowSpanBoundaries = rows\n    .slice(boundaries[0], boundaries[1])\n    .map(row => getSpanBoundary(\n      columns,\n      columnsVisibleBoundary,\n      column => getColSpan(row, column),\n    ));\n  const columnBoundaries = collapseBoundaries(\n    columns.length,\n    columnsVisibleBoundary,\n    rowSpanBoundaries,\n  );\n\n  const rowBoundaries = collapseBoundaries(totalRowCount!, [boundaries], []);\n\n  return {\n    columns: getCollapsedColumns(\n      columns,\n      columnsVisibleBoundary,\n      columnBoundaries,\n      getColumnWidth,\n    ),\n    rows: getCollapsedRows(\n      rows,\n      boundaries,\n      rowBoundaries,\n      getRowHeight,\n      row => getCollapsedCells(\n        columns,\n        getSpanBoundary(\n          columns,\n          columnsVisibleBoundary,\n          column => getColSpan(row, column),\n        ),\n        columnBoundaries,\n        column => getColSpan(row, column),\n      ),\n      offset,\n    ),\n  };\n};\n\nexport const getColumnWidthGetter: GetColumnWidthGetterFn = (\n  tableColumns, tableWidth, minColumnWidth,\n) => {\n  const colsHavingWidth = tableColumns.filter(col => typeof col.width === 'number');\n  const columnsWidth = colsHavingWidth.reduce((acc, col) => (acc + (col.width as number)!), 0);\n  const autoWidth = (tableWidth - columnsWidth) / (tableColumns.length - colsHavingWidth.length);\n  const autoColWidth = Math.max(autoWidth, minColumnWidth!);\n\n  return column => (column.type === TABLE_FLEX_TYPE\n    ? null\n    : typeof column.width === 'number' ? column.width : autoColWidth);\n};\n\nexport const getCollapsedGrids: GetCollapsedGridsFn = ({\n    headerRows = [],\n    bodyRows = [],\n    footerRows = [],\n    columns,\n    loadedRowsStart,\n    totalRowCount,\n    getCellColSpan,\n    viewport,\n    getRowHeight,\n    getColumnWidth,\n  },\n) => {\n  const getColSpan = (\n    tableRow: any, tableColumn: any,\n  ) => getCellColSpan!({ tableRow, tableColumn, tableColumns: columns });\n\n  const getCollapsedGridBlock: PureComputed<\n    [any[], any[]?, number?, number?], CollapsedGrid\n  > = (\n    rows, rowsVisibleBoundary, rowCount = rows.length, offset = 0,\n  ) => getCollapsedGrid({\n    rows,\n    columns,\n    rowsVisibleBoundary,\n    columnsVisibleBoundary: viewport.columns,\n    getColumnWidth,\n    getRowHeight,\n    getColSpan,\n    totalRowCount: rowCount,\n    offset,\n  });\n\n  const headerGrid = getCollapsedGridBlock(\n    headerRows, getRenderRowBounds(viewport.headerRows, headerRows.length),\n  );\n  const bodyGrid = getCollapsedGridBlock(\n    bodyRows,\n    adjustedRenderRowBounds(\n      viewport.rows, bodyRows.length, loadedRowsStart,\n    ),\n    totalRowCount || 1,\n    loadedRowsStart,\n  );\n  const footerGrid = getCollapsedGridBlock(\n    footerRows, getRenderRowBounds(viewport.footerRows, footerRows.length),\n  );\n\n  return {\n    headerGrid,\n    bodyGrid,\n    footerGrid,\n  };\n};\n\nconst getRenderRowBounds: PureComputed<[VisibleBoundary, number], number[]> = (\n  visibleBounds, rowCount,\n) => getRowsRenderBoundary(\n  rowCount,\n  visibleBounds,\n);\n\nconst adjustedRenderRowBounds: PureComputed<[VisibleBoundary, number, number], number[]> = (\n  visibleBounds, rowCount, loadedRowsStart,\n) => {\n  const renderRowBoundaries = getRenderRowBounds(\n    visibleBounds, loadedRowsStart + rowCount,\n  );\n  const adjustedInterval = intervalUtil.intersect(\n    { start: renderRowBoundaries[0], end: renderRowBoundaries[1] },\n    { start: loadedRowsStart, end: loadedRowsStart + rowCount },\n  );\n  return [adjustedInterval.start, adjustedInterval.end];\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_GROUP_TYPE } from './constants';\nimport { TableRow, TableColumn, IsSpecificCellFn, Grouping, GroupSummaryItem } from '../../types';\nimport { TABLE_STUB_TYPE } from '../../utils/virtual-table';\nimport { TABLE_DATA_TYPE, TABLE_FLEX_TYPE } from '../table/constants';\n\ntype IsGroupIndentCellFn = PureComputed<[TableRow, TableColumn, Grouping[]], boolean>;\n\nconst getGroupIndexByColumn: PureComputed<[Grouping[], TableColumn], number> = (\n  grouping, tableColumn,\n) => grouping.findIndex(\n  columnGrouping => !!tableColumn.column && columnGrouping.columnName === tableColumn.column.name,\n);\n\nconst isIndentCell: IsGroupIndentCellFn = (\n    tableRow,\n    tableColumn,\n    grouping,\n  ) => {\n  if (tableColumn.column && tableRow.row.groupedBy === tableColumn.column.name) return false;\n  const rowGroupIndex = grouping.findIndex(\n    columnGrouping => columnGrouping.columnName === tableRow.row.groupedBy,\n  );\n  const columnGroupIndex = getGroupIndexByColumn(grouping, tableColumn);\n\n  return columnGroupIndex < rowGroupIndex;\n};\n\nexport const isGroupTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => !!(tableRow.type === TABLE_GROUP_TYPE && tableColumn.type === TABLE_GROUP_TYPE\n  && tableColumn.column\n  && tableColumn.column.name === tableRow.row.groupedBy);\n\nexport const isGroupIndentTableCell: IsGroupIndentCellFn = (\n  tableRow, tableColumn, grouping,\n) => (\n  tableRow.type === TABLE_GROUP_TYPE && tableColumn.type === TABLE_GROUP_TYPE &&\n  isIndentCell(tableRow, tableColumn, grouping)\n);\n\nexport const isGroupIndentStubTableCell: IsGroupIndentCellFn = (\n  tableRow, tableColumn, grouping,\n) => (\n  (tableRow.type === TABLE_GROUP_TYPE && tableColumn.type === TABLE_STUB_TYPE &&\n    isIndentCell(tableRow, tableColumn, grouping))\n);\n\nexport const isGroupTableRow = (tableRow: TableRow) => tableRow.type === TABLE_GROUP_TYPE;\n\nexport const isGroupRowOrdinaryCell: IsSpecificCellFn = (tableRow, tableColumn) => (\n  isGroupTableRow(tableRow) && !isGroupTableCell(tableRow, tableColumn)\n);\n\nconst columnHasGroupRowSummary: PureComputed<[TableColumn, GroupSummaryItem[]], boolean> = (\n  tableColumn, groupSummaryItems,\n) => (\n  !!(groupSummaryItems && groupSummaryItems\n    .some(item => (\n      (!item.showInGroupFooter && item.alignByColumn)\n        && item.columnName === (tableColumn.column && tableColumn.column.name)\n    )))\n);\n\nexport const isRowSummaryCell: PureComputed<\n  [TableRow, TableColumn, Grouping[], GroupSummaryItem[]], boolean\n> = (\n  tableRow, tableColumn, grouping, groupSummaryItems,\n) => (\n  columnHasGroupRowSummary(tableColumn, groupSummaryItems)\n  && !isGroupIndentTableCell(tableRow, tableColumn, grouping)\n);\n\nexport const isPreviousCellContainSummary: PureComputed<\n  [TableRow, TableColumn, TableColumn[], Grouping[], GroupSummaryItem[]], boolean\n> = (\n  tableRow, tableColumn, tableColumns, grouping, groupSummaryItems,\n) => {\n  const columnIndex = tableColumns.indexOf(tableColumn);\n  return columnIndex > 0 && isRowSummaryCell(\n    tableRow, tableColumns[columnIndex - 1], grouping, groupSummaryItems,\n  );\n};\n\nexport const calculateGroupCellIndent: PureComputed<[TableColumn, Grouping[], number], number> = (\n  tableColumn, grouping, indentWidth,\n) => (\n  indentWidth * getGroupIndexByColumn(grouping, tableColumn)\n);\n\nexport const sortAndSpliceColumns: PureComputed<[TableColumn[], number]> = (\n  tableColumns, firstVisibleColumnIndex,\n) => {\n  const groupColumns = tableColumns.filter(col => col.type === TABLE_GROUP_TYPE);\n  const dataColumns = tableColumns.filter(col => col.type === TABLE_DATA_TYPE);\n  const flexColumns = tableColumns.filter(col => col.type === TABLE_FLEX_TYPE);\n  const otherColumns = tableColumns.filter(\n    col =>\n      col.type !== TABLE_DATA_TYPE &&\n      col.type !== TABLE_GROUP_TYPE &&\n      col.type !== TABLE_FLEX_TYPE,\n  );\n\n  if (firstVisibleColumnIndex) {\n    const firstGroupIndex = tableColumns.indexOf(groupColumns[0]);\n    otherColumns.splice(0, Math.min(firstVisibleColumnIndex, firstGroupIndex));\n  }\n\n  return [...groupColumns, ...otherColumns, ...dataColumns, ...flexColumns];\n};\n","import { TABLE_DATA_TYPE } from '../table/constants';\nimport { TABLE_GROUP_TYPE } from './constants';\nimport { PureComputed } from '@devexpress/dx-core';\nimport {\n  TableColumn, TableRow, IsSpecificRowFn,\n  TableColumnsWithDraftGroupingFn,\n  TableColumnsWithGroupingFn,\n  GroupCellColSpanGetter,\n  GroupSummaryChainsFn,\n  SummaryItem,\n} from '../../types';\nimport { sortAndSpliceColumns } from './helpers';\n\nconst tableColumnsWithDraftGrouping: TableColumnsWithDraftGroupingFn = (\n  tableColumns, grouping, draftGrouping, showColumnWhenGrouped,\n) => tableColumns\n  .reduce((acc, tableColumn) => {\n    if (tableColumn.type !== TABLE_DATA_TYPE) {\n      acc.push(tableColumn);\n      return acc;\n    }\n\n    const columnName = tableColumn.column && tableColumn.column.name || '';\n    const columnGroupingExists = grouping\n      .some(columnGrouping => columnGrouping.columnName === columnName);\n    const columnDraftGroupingExists = draftGrouping\n      .some(columnGrouping => columnGrouping.columnName === columnName);\n\n    if ((!columnGroupingExists && !columnDraftGroupingExists)\n        || showColumnWhenGrouped(columnName)) {\n      acc.push(tableColumn);\n    } else if ((!columnGroupingExists && columnDraftGroupingExists)\n        || (columnGroupingExists && !columnDraftGroupingExists)) {\n      acc.push({\n        ...tableColumn,\n        draft: true,\n      });\n    }\n    return acc;\n  // tslint:disable-next-line: prefer-array-literal\n  }, [] as Array<TableColumn & { draft?: boolean }>);\n\nexport const tableColumnsWithGrouping: TableColumnsWithGroupingFn = (\n  columns, tableColumns, grouping, draftGrouping, indentColumnWidth, showColumnWhenGrouped,\n) => [\n  ...grouping.map((columnGrouping) => {\n    const groupedColumn = columns.find(column => column.name === columnGrouping.columnName);\n    return {\n      key: `${TABLE_GROUP_TYPE.toString()}_${groupedColumn!.name}`,\n      type: TABLE_GROUP_TYPE,\n      column: groupedColumn,\n      width: indentColumnWidth,\n    };\n  }),\n  ...tableColumnsWithDraftGrouping(tableColumns, grouping, draftGrouping, showColumnWhenGrouped),\n];\n\nexport const tableRowsWithGrouping: PureComputed<[TableRow[], IsSpecificRowFn]> = (\n  tableRows, isGroupRow,\n) => tableRows.map((tableRow) => {\n  if (tableRow.type !== TABLE_DATA_TYPE || !isGroupRow(tableRow.row)) {\n    return tableRow;\n  }\n  return {\n    ...tableRow,\n    key: `${TABLE_GROUP_TYPE.toString()}_${tableRow.row.compoundKey}`,\n    type: TABLE_GROUP_TYPE,\n  };\n});\n\nconst isRowLevelSummary: PureComputed<[SummaryItem[], string], boolean> = (\n  groupSummaryItems, colName,\n) => (\n  groupSummaryItems.some((item: any) => (\n    !item.showInGroupFooter && item.alignByColumn && item.columnName === colName),\n  )\n);\n\nconst groupSummaryChains: GroupSummaryChainsFn = (\n  tableRow,\n  tableColumns,\n  groupSummaryItems,\n  firstVisibleColumnIndex,\n) => {\n  let captionStarted = false;\n  return sortAndSpliceColumns(tableColumns, firstVisibleColumnIndex)\n    .reduce((acc, col) => {\n      const colName = (col.column && col.column.name) as string;\n      const isStartOfGroupCaption = col.type === TABLE_GROUP_TYPE\n        && tableRow.row.groupedBy === colName;\n      const isIndentColumn = col.type === TABLE_GROUP_TYPE\n        && tableRow.row.groupedBy !== colName && !captionStarted;\n\n      if (isStartOfGroupCaption) {\n        captionStarted = true;\n      }\n\n      if (isStartOfGroupCaption || isIndentColumn) {\n        acc.push([colName]);\n      } else if (groupSummaryItems && isRowLevelSummary(groupSummaryItems, colName)) {\n        acc.push([colName]);\n        acc.push([]);\n      } else {\n        acc[acc.length - 1].push(colName);\n      }\n      return acc;\n    }, [[]] as string[][]);\n};\n\nexport const tableGroupCellColSpanGetter: GroupCellColSpanGetter = (\n  getTableCellColSpan, groupSummaryItems, firstVisibleColumnIndex,\n) => (params) => {\n  const { tableRow, tableColumns, tableColumn } = params;\n\n  if (tableRow.type === TABLE_GROUP_TYPE) {\n    const colName = tableColumn.column?.name;\n    const dataColumnGroupedBy =\n      tableRow.row.groupedBy === colName && tableColumn.type !== TABLE_GROUP_TYPE;\n    const chains = groupSummaryChains(\n      tableRow, tableColumns, groupSummaryItems, firstVisibleColumnIndex,\n    );\n    const chain = chains.find(ch => !dataColumnGroupedBy && ch[0] === colName);\n\n    if (chain) {\n      return chain.length;\n    }\n  }\n  return getTableCellColSpan(params);\n};\n","import { TABLE_HEADING_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport {\n  IsSpecificCellFn, IsSpecificRowFn, HeaderColumnChain,\n  SplitHeaderColumnChainsFn, FindChainByColumnIndexFn,\n  GenerateChainsFn,\n  NextColumnNameFn,\n  GetNextColumnNameFn,\n} from '../../types';\n\nexport const isHeadingTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_HEADING_TYPE && tableColumn.type === TABLE_DATA_TYPE;\n\nexport const isHeadingTableRow: IsSpecificRowFn = tableRow => (\n  tableRow.type === TABLE_HEADING_TYPE\n);\n\nexport const findChainByColumnIndex: FindChainByColumnIndexFn = (chains, columnIndex) => (\n  chains.find(chain => (\n    chain.start <= columnIndex && columnIndex < chain.start + chain.columns.length\n  ))!\n);\n\nexport const splitHeaderColumnChains: SplitHeaderColumnChainsFn = (\n  tableColumnChains, tableColumns, shouldSplitChain, extendChainProps,\n) => (\n  tableColumnChains.map((row, rowIndex) => row\n    .reduce((acc, chain) => {\n      let currentChain: any = null;\n      chain.columns.forEach((col) => {\n        const column = tableColumns.find(c => c.key === col.key);\n        const isNewGroup = shouldSplitChain(currentChain, column!, rowIndex);\n\n        if (isNewGroup) {\n          const start = currentChain\n            ? (currentChain.start + currentChain.columns.length)\n            : chain.start;\n\n          acc.push({\n            ...chain,\n            ...extendChainProps(column!),\n            start,\n            columns: [],\n          });\n          currentChain = acc[acc.length - 1];\n        }\n\n        currentChain.columns.push(column);\n      });\n\n      return acc;\n    }, [] as HeaderColumnChain[]))\n);\n\nexport const generateSimpleChains: GenerateChainsFn = (rows, columns) => (\n  rows.map(() => ([{\n    columns,\n    start: 0,\n  }]))\n);\n\nconst nextColumnName: NextColumnNameFn = (tableColumns , index) => {\n  const isNextColumnHasName = index < tableColumns.length - 1 && tableColumns[index + 1].column;\n  return isNextColumnHasName\n    ? tableColumns[index + 1].column!.name\n    : undefined;\n};\n\nexport const getNextColumnName: GetNextColumnNameFn = (tableColumns, columnName) => {\n  const index = tableColumns.findIndex(elem =>\n    elem.column && elem.column.name === columnName,\n  );\n  return index >= 0\n    ? nextColumnName(tableColumns, index)\n    : undefined;\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_HEADING_TYPE } from './constants';\nimport { TableRow } from '../../types';\n\nexport const tableRowsWithHeading: PureComputed<[TableRow[]]> = headerRows => [\n  { key: TABLE_HEADING_TYPE.toString(), type: TABLE_HEADING_TYPE },\n  ...headerRows];\n","export const TABLE_BAND_TYPE = Symbol('band');\nexport const BAND_GROUP_CELL = 'bandGroupCell';\nexport const BAND_HEADER_CELL = 'bandHeaderCell';\nexport const BAND_EMPTY_CELL = 'bandEmptyCell';\nexport const BAND_DUPLICATE_RENDER = 'bandDuplicateRender';\nexport const BAND_FILL_LEVEL_CELL = 'bandFillLevelCell';\n","import {\n  TABLE_BAND_TYPE, BAND_GROUP_CELL, BAND_HEADER_CELL, BAND_EMPTY_CELL,\n  BAND_DUPLICATE_RENDER, BAND_FILL_LEVEL_CELL,\n} from './constants';\nimport { TABLE_HEADING_TYPE } from '../table-header-row/constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { findChainByColumnIndex } from '../table-header-row/helpers';\nimport {\n  IsSpecificRowFn, GetColumnBandMetaFn, GetBandComponentFn, CalculateBandFn,\n} from '../../types';\nimport { TABLE_STUB_TYPE } from '../../utils/virtual-table';\n\nexport const isBandedTableRow: IsSpecificRowFn = tableRow => (tableRow.type === TABLE_BAND_TYPE);\nexport const isBandedOrHeaderRow: IsSpecificRowFn = tableRow => isBandedTableRow(tableRow)\n  || tableRow.type === TABLE_HEADING_TYPE;\nexport const isNoDataColumn = (columnType: symbol) => columnType !== TABLE_DATA_TYPE;\n\nexport const getColumnMeta: GetColumnBandMetaFn = (\n  columnName, bands, tableRowLevel, key = '',\n  level = 0, title = null, result = null,\n) => bands.reduce((acc, band) => {\n  if (band.columnName === columnName) {\n    return { ...acc, title, level, key };\n  }\n  if (band.children !== undefined) {\n    const rowLevelPassed = level > tableRowLevel;\n    const bandTitle = rowLevelPassed ? title : band.title;\n    const bandKey = rowLevelPassed ? key : `${key}_${bandTitle}`;\n\n    return getColumnMeta(\n      columnName,\n      band.children,\n      tableRowLevel,\n      bandKey,\n      level + 1,\n      bandTitle,\n      acc,\n    );\n  }\n  return acc;\n}, result || { level, title, key: title });\n\nexport const calculateBand: CalculateBandFn = (visibleBound, headerChain) => {\n  if (visibleBound) {\n    const bandStart = Math.max(visibleBound[0], headerChain.start);\n\n    const bandEnd = Math.min(\n      visibleBound[1] + 1,\n      headerChain.start + headerChain.columns.length,\n    );\n\n    return [bandStart, bandEnd];\n  }\n\n  return [headerChain.start, headerChain.start + headerChain.columns.length];\n};\n\nexport const getBandComponent: GetBandComponentFn = (\n  { tableColumn: currentTableColumn, tableRow, rowSpan },\n  tableHeaderRows, tableColumns, columnBands, tableHeaderColumnChains,\n  columnVisibleIntervals, bandLevelsVisibility,\n) => {\n  if (rowSpan) return { type: BAND_DUPLICATE_RENDER, payload: null };\n\n  const maxLevel = tableHeaderRows.filter(column => column.type === TABLE_BAND_TYPE).length + 1;\n  const { level } = tableRow;\n  const currentRowLevel = level === undefined\n    ? maxLevel - 1 : level;\n  const currentColumnMeta = currentTableColumn.type === TABLE_DATA_TYPE\n    ? getColumnMeta(currentTableColumn.column!.name, columnBands, currentRowLevel)\n    : { level: 0, title: '' };\n\n  const currentColumnIndex = tableColumns\n    .findIndex(column => column.key === currentTableColumn.key);\n\n  const levelsCount = bandLevelsVisibility.length;\n  const visibleLevelsCount = bandLevelsVisibility.filter(Boolean).length;\n\n  if (currentColumnMeta.level < currentRowLevel) {\n    const shouldFillLevel = currentRowLevel > 0 && visibleLevelsCount < levelsCount\n      && !bandLevelsVisibility[currentRowLevel] && currentTableColumn.type === TABLE_STUB_TYPE;\n\n    if (shouldFillLevel) {\n      return { type: BAND_FILL_LEVEL_CELL, payload: null };\n    }\n    return { type: BAND_EMPTY_CELL, payload: null };\n  }\n\n  const previousTableColumn = tableColumns[currentColumnIndex - 1];\n  let beforeBorder = false;\n  if (currentColumnIndex > 0 && currentTableColumn.type === TABLE_DATA_TYPE\n    && isNoDataColumn(previousTableColumn.type)) {\n    beforeBorder = true;\n  }\n\n  const isStubColumn = currentTableColumn.type === TABLE_STUB_TYPE;\n  const isColumnVisible = currentColumnIndex >= 0;\n\n  if (currentColumnMeta.level === currentRowLevel) {\n    if (isStubColumn) {\n      const cellRowSpan = visibleLevelsCount < levelsCount\n        ? visibleLevelsCount || 1\n        : maxLevel;\n\n      return {\n        type: BAND_FILL_LEVEL_CELL,\n        payload: {\n          rowSpan: cellRowSpan,\n        },\n      };\n    }\n\n    if (isColumnVisible) {\n      return {\n        type: BAND_HEADER_CELL,\n        payload: {\n          tableRow: tableHeaderRows.find(row => row.type === TABLE_HEADING_TYPE),\n          rowSpan: maxLevel - currentRowLevel,\n          ...beforeBorder && { beforeBorder },\n        },\n      };\n    }\n  }\n\n  if (!isColumnVisible) return { type: BAND_EMPTY_CELL, payload: null };\n\n  const currentColumnChain = findChainByColumnIndex(\n    tableHeaderColumnChains[currentRowLevel],\n    currentColumnIndex,\n  );\n  const columnVisibleBoundary = columnVisibleIntervals.find(([start, end]) => (\n    start <= currentColumnIndex && currentColumnIndex <= end\n  ));\n\n  const [bandStart, bandEnd] = calculateBand(columnVisibleBoundary, currentColumnChain);\n\n  if (bandStart < currentColumnIndex) {\n    return { type: null, payload: null };\n  }\n\n  return {\n    type: BAND_GROUP_CELL,\n    payload: {\n      colSpan: bandEnd - bandStart,\n      value: currentColumnMeta.title!,\n      column: currentColumnMeta,\n      ...beforeBorder && { beforeBorder },\n    },\n  };\n};\n","import { intervalUtil } from './utils';\nimport {\n  VirtualRows, Row, MergeRowsFn, CalculateRequestedRangeFn,\n  Interval, GridViewport, GetRequestMeta, CorrectRangeFn,\n} from '../../types';\nimport { PureComputed } from '@devexpress/dx-core';\n\nexport const emptyVirtualRows: VirtualRows = {\n  skip: Number.POSITIVE_INFINITY,\n  rows: [],\n};\n\nconst pluckSubarray: PureComputed<[Row[], ...number[]]> = (source, sourceStart, left, right) => (\n  source.slice(left - sourceStart, right - sourceStart)\n);\n\nexport const mergeRows: MergeRowsFn = (\n  rowsInterval, cacheInterval, rows, cacheRows, rowsStart, cacheStart,\n) => {\n  const breakpoints = [\n    rowsInterval.start, rowsInterval.end,\n    cacheInterval.start, cacheInterval.end,\n  ]\n    .filter(i => 0 <= i && i < Number.POSITIVE_INFINITY)\n    .sort((a, b) => a - b);\n\n  let result: Row[] = [];\n  if (breakpoints.length > 1) {\n    for (let i = 0; i < breakpoints.length - 1; i += 1) {\n      const left = breakpoints[i];\n      const right = breakpoints[i + 1];\n      const chunk = rowsInterval.start <= left && right <= rowsInterval.end\n        ? pluckSubarray(rows, rowsStart, left, right) // rows have higher priority\n        : pluckSubarray(cacheRows, cacheStart, left, right);\n\n      result = result.concat(chunk);\n    }\n  }\n\n  return {\n    skip: breakpoints[0],\n    rows: result,\n  };\n};\n\nconst correctRequestedRange: CorrectRangeFn = (calculatedRange, referenceIndex, pageSize) => {\n  const { start, end } = calculatedRange;\n\n  if (start - referenceIndex > pageSize / 2) {\n    return { start: start - pageSize, end: start };\n  }\n  return { start, end };\n};\n\nexport const calculateRequestedRange: CalculateRequestedRangeFn = (\n  virtualRows, newRange, pageSize, referenceIndex, isInfiniteScroll,\n) => {\n  const loadedInterval = intervalUtil.getRowsInterval(virtualRows);\n  const isAdjacentPage = Math.abs(loadedInterval.start - newRange.start) < 2 * pageSize;\n  if (isAdjacentPage) {\n    const calculatedRange = intervalUtil.difference(newRange, loadedInterval);\n    if (isInfiniteScroll && calculatedRange !== intervalUtil.empty) {\n      return correctRequestedRange(calculatedRange, referenceIndex, pageSize);\n    }\n    return calculatedRange;\n  }\n\n  // load 3 pages at once because a missing page will be loaded anyway\n  return newRange;\n};\n\nexport const rowToPageIndex: PureComputed<[number, number]> = (\n  rowIndex, pageSize,\n) => Math.floor(rowIndex / pageSize);\n\nexport const recalculateBounds: PureComputed<[number, number, number], Interval> = (\n  middleIndex, pageSize, totalCount,\n) => {\n  const currentPageIndex = rowToPageIndex(middleIndex, pageSize);\n\n  const prevPageIndex = currentPageIndex - 1;\n  const nextPageIndex = currentPageIndex + 2;\n  const start = Math.max(0, prevPageIndex * pageSize);\n  const end = Math.min(nextPageIndex * pageSize, totalCount);\n\n  return {\n    start,\n    end,\n  };\n};\n\nexport const trimRowsToInterval: PureComputed<[VirtualRows, Interval]> = (\n  virtualRows, targetInterval,\n) => {\n  const rowsInterval = intervalUtil.getRowsInterval(virtualRows);\n  const intersection = intervalUtil.intersect(rowsInterval, targetInterval);\n  if (intervalUtil.empty === intersection) {\n    return emptyVirtualRows;\n  }\n\n  const rows = pluckSubarray(\n    virtualRows.rows, virtualRows.skip, intersection.start, intersection.end,\n  );\n\n  return {\n    rows,\n    skip: intersection.start,\n  };\n};\n\nexport const getAvailableRowCount: PureComputed<[boolean, number, number, number], number> = (\n  isInfiniteScroll, newRowCount, lastRowCount, totalRowCount,\n) => {\n  return (isInfiniteScroll\n    ? Math.min(\n        Math.max(newRowCount, lastRowCount),\n        totalRowCount)\n    : totalRowCount\n  );\n};\n\nexport const getForceReloadInterval: PureComputed<[VirtualRows, number, number], Interval> = (\n  virtualRows, pageSize, totalRowCount,\n) => {\n  const { start, end: intervalEnd } = intervalUtil.getRowsInterval(virtualRows);\n  const end = Math.min(\n    Math.max(start + pageSize * 2, intervalEnd),\n    Math.max(start + pageSize * 2, totalRowCount),\n  );\n  return {\n    start,\n    end,\n  };\n};\n\nexport const getRequestMeta: GetRequestMeta = (\n  referenceIndex, virtualRows, pageSize, totalRowCount, forceReload, isInfiniteScroll,\n) => {\n  const actualBounds = forceReload\n    ? getForceReloadInterval(virtualRows, pageSize!, totalRowCount)\n    : recalculateBounds(referenceIndex, pageSize!, totalRowCount);\n  const requestedRange = forceReload\n    ? actualBounds\n    : calculateRequestedRange(\n        virtualRows, actualBounds, pageSize!, referenceIndex, isInfiniteScroll,\n      );\n\n  return { requestedRange, actualBounds };\n};\n\nexport const needFetchMorePages: PureComputed<[VirtualRows, number, number], boolean> = (\n  virtualRows, referenceIndex,  pageSize,\n) => {\n  const { start, end } = intervalUtil.getRowsInterval(virtualRows);\n  const loadCount = end - start;\n  const topTriggerIndex = start > 0 ? start + pageSize! : 0;\n  const bottomTriggerIndex = Math.max(topTriggerIndex + pageSize, end - pageSize! * 1.5);\n\n  if (loadCount <= 0) {\n    return false;\n  }\n\n  return (referenceIndex < topTriggerIndex || bottomTriggerIndex < referenceIndex);\n};\n\nexport const getReferenceIndex: PureComputed<[GridViewport], number> = (\n  { rows: [top, bottom] },\n) => (\n  (top + bottom) / 2\n);\n\nexport const shouldSendRequest: PureComputed<[Interval, number], boolean> = (\n  { start, end }, requestedPageIndex,\n) => {\n  const newPageIndex = start;\n  const loadCount = (end - start);\n  return newPageIndex !== requestedPageIndex && loadCount > 0;\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { emptyVirtualRows } from './helpers';\nimport { Interval, VirtualRows } from '../../types';\n\nconst empty: Interval = {\n  start: Number.POSITIVE_INFINITY,\n  end: Number.NEGATIVE_INFINITY,\n};\n\nconst getRowsInterval: PureComputed<[VirtualRows], Interval> = r => (\n  r === emptyVirtualRows\n    ? empty\n    : {\n      start: r.skip,\n      end: r.skip + r.rows.length,\n    }\n);\n\nconst getLength = (a: Interval) => a.end - a.start;\n\nconst intersect = (a: Interval, b: Interval) => {\n  if (a.end < b.start || b.end < a.start) {\n    return empty;\n  }\n\n  return {\n    start: Math.max(a.start, b.start),\n    end: Math.min(a.end, b.end),\n  };\n};\n\nconst difference = (a: Interval, b: Interval) => {\n  if (empty === intervalUtil.intersect(a, b)) {\n    return a;\n  }\n\n  if (b.end < a.end) {\n    return {\n      start: b.end,\n      end: a.end,\n    };\n  }\n  if (a.start < b.start) {\n    return {\n      start: a.start,\n      end: b.start,\n    };\n  }\n  return empty;\n};\n\nexport const intervalUtil = {\n  empty,\n\n  getRowsInterval,\n  getLength,\n\n  intersect,\n  difference,\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_BAND_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { getColumnMeta } from './helpers';\nimport { splitHeaderColumnChains, generateSimpleChains } from '../table-header-row/helpers';\nimport {\n  ColumnBands, GetHeaderColumnChainsFn, ShouldSplitChainFn,\n  GetMaxNestedLevelFn, TableRow, TableColumn, HeaderColumnChainRows,\n  BandLevels, BandColumnChainExtension, HeaderColumnChain, VisibleBoundary, GridViewport,\n} from '../../types';\nimport { intervalUtil } from '../virtual-table-state/utils';\n\nexport const tableRowsWithBands: PureComputed<\n  [TableRow[], ColumnBands[], TableColumn[]]\n> = (\n  tableHeaderRows, columnBands, tableColumns,\n) => {\n  const tableDataColumns = tableColumns.filter(column => column.type === TABLE_DATA_TYPE);\n  const getMaxNestedLevel: GetMaxNestedLevelFn = (bands, level = 0, result = null) => (\n    bands.reduce((acc, column) => {\n      if (column.children !== undefined) {\n        return getMaxNestedLevel(column.children, level + 1, acc);\n      }\n      const isDataColumn = tableDataColumns.findIndex(\n        dataColumn => !!dataColumn.column && dataColumn.column.name === column.columnName,\n      ) > -1;\n      if (level > acc.level && isDataColumn) {\n        return { ...acc, level };\n      }\n      return acc;\n    }, result || { level: 0 })\n  );\n\n  const tableBandHeaders = Array.from({\n    length: getMaxNestedLevel(columnBands as ColumnBands[], 0).level,\n  })\n    .map((row, index) => ({\n      key: `${TABLE_BAND_TYPE.toString()}_${index}`,\n      type: TABLE_BAND_TYPE,\n      level: index,\n    }));\n  return [...tableBandHeaders, ...tableHeaderRows];\n};\n\nexport const tableHeaderColumnChainsWithBands: GetHeaderColumnChainsFn<\n  TableRow[], TableColumn[], ColumnBands[]\n> = (\n  tableHeaderRows, tableColumns, bands,\n) => {\n  const chains = generateSimpleChains(tableHeaderRows, tableColumns);\n  const maxBandRowIndex = tableHeaderRows\n    .filter(row => row.type === TABLE_BAND_TYPE)\n    .length;\n  const rawBandChains = chains.slice(0, maxBandRowIndex);\n\n  let currentBand: any = null;\n  const shouldSplitChain: ShouldSplitChainFn = (chain, column, rowIndex) => {\n    if (rowIndex > maxBandRowIndex) return false;\n\n    const columnName = column.column && column.column.name || '';\n    currentBand = getColumnMeta(columnName, bands, rowIndex);\n    return !chain\n      || (chain as any).key !== currentBand.key;\n  };\n  const extendChainProps = () => ({\n    bandTitle: currentBand?.title,\n    key: currentBand?.key,\n  });\n\n  const bandChains = splitHeaderColumnChains(\n    rawBandChains,\n    tableColumns,\n    shouldSplitChain,\n    extendChainProps,\n  );\n\n  return [...bandChains, ...chains.slice(maxBandRowIndex)];\n};\n\nconst getBandLevel: PureComputed<[ColumnBands[], string, number?], number> = (\n  bands, bandTitle, level = 0,\n) => {\n  for (const band of bands) {\n    if (band.title === bandTitle) {\n      return level;\n    }\n    if (band.children !== undefined) {\n      const result = getBandLevel(band.children, bandTitle, level + 1);\n      if (result >= 0) return result;\n    }\n  }\n  return -1;\n};\n\nconst getBandLevels = (columnsBands: readonly ColumnBands[], levels = {}, level = 0) => {\n  columnsBands.forEach((band) => {\n    if (band.title) {\n      levels[band.title] = level;\n    }\n    if (band.children) {\n      getBandLevels(band.children, levels, level + 1);\n    }\n  });\n  return levels;\n};\n\nexport const columnBandLevels: PureComputed<[ColumnBands[]], BandLevels> = columnsBands => (\n  getBandLevels(columnsBands)\n);\n\nexport const bandLevelsVisibility: PureComputed<\n  [VisibleBoundary[], HeaderColumnChainRows<BandColumnChainExtension>, BandLevels],\n  boolean[]\n> = (columnIntervals, tableHeaderColumnChains, bandLevels) => {\n  const rowsWithBands = tableHeaderColumnChains\n    .filter(r => r.filter(ch => !!ch.bandTitle).length);\n\n  const visibleIntervals = columnIntervals.map(([start, end]) => ({ start, end }));\n\n  const isBandChainVisible = (chain: HeaderColumnChain) => (\n    visibleIntervals.some(interval => (\n      intervalUtil.intersect(\n        interval,\n        { start: chain.start, end: chain.start + chain.columns.length - 1 },\n      ) !== intervalUtil.empty\n    ),\n  ));\n\n  const getVisibleBandsByLevel = (level: number) => (\n    // Note: a visible band level always matches with it's row\n    rowsWithBands[level]\n    ? rowsWithBands[level].filter(chain => (\n        bandLevels[chain.bandTitle] === level && isBandChainVisible(chain)\n      ))\n    : []\n  );\n\n  return rowsWithBands.reduce((acc, _, index) => {\n    const rowBands = getVisibleBandsByLevel(index);\n    return [...acc, !!rowBands.length];\n  }, [] as boolean[]);\n};\n\nexport const columnVisibleIntervals: PureComputed<\n  [GridViewport, TableColumn[]],\n  VisibleBoundary[]\n> = (\n  viewport, tableColumns,\n) => (\n  viewport ? viewport.columns : [[0, tableColumns.length]]\n);\n","import { toggle } from '../../utils/common-reducers';\nimport { ToggleRowFieldReducer } from '../../types';\n\nexport const toggleDetailRowExpanded: ToggleRowFieldReducer = (\n  prevExpanded, { rowId, state },\n) => toggle(prevExpanded, [rowId], state);\n","export const TABLE_DETAIL_TYPE = Symbol('detail');\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_DETAIL_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { IsSpecificCellFn, IsSpecificRowFn, TableColumn, RowId } from '../../types';\n\nexport const isDetailRowExpanded: PureComputed<[RowId[], RowId], boolean> = (\n  expandedDetailRowIds, rowId,\n) => expandedDetailRowIds.indexOf(rowId) > -1;\n\nexport const isDetailToggleTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableColumn.type === TABLE_DETAIL_TYPE && tableRow.type === TABLE_DATA_TYPE;\n\nexport const isDetailTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_DETAIL_TYPE;\n\nexport const isDetailTableCell: PureComputed<[TableColumn, TableColumn[]], boolean> = (\n  tableColumn, tableColumns,\n) => tableColumns.indexOf(tableColumn) === 0;\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_DETAIL_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TableRow, TableColumn, CellColSpanGetter } from '../../types';\n\nexport const tableRowsWithExpandedDetail: PureComputed<[TableRow[], number[], number]> = (\n  tableRows, expandedDetailRowIds, rowHeight,\n) => {\n  let result = tableRows;\n  expandedDetailRowIds\n    .forEach((expandedRowId) => {\n      const rowIndex = result.findIndex(\n        tableRow => tableRow.type === TABLE_DATA_TYPE && tableRow.rowId === expandedRowId,\n      );\n      if (rowIndex === -1) return;\n      const insertIndex = rowIndex + 1;\n      const { row, rowId } = result[rowIndex];\n      result = [\n        ...result.slice(0, insertIndex),\n        {\n          rowId,\n          row,\n          key: `${TABLE_DETAIL_TYPE.toString()}_${rowId}`,\n          type: TABLE_DETAIL_TYPE,\n          height: rowHeight,\n        },\n        ...result.slice(insertIndex),\n      ];\n    });\n  return result;\n};\n\nexport const tableColumnsWithDetail: PureComputed<[TableColumn[], number]> = (\n  tableColumns, toggleColumnWidth,\n) => [\n  { key: TABLE_DETAIL_TYPE.toString(), type: TABLE_DETAIL_TYPE, width: toggleColumnWidth },\n  ...tableColumns,\n];\n\nexport const tableDetailCellColSpanGetter: CellColSpanGetter = getTableCellColSpan => (params) => {\n  const { tableRow, tableColumns, tableColumn } = params;\n  if (tableRow.type === TABLE_DETAIL_TYPE && tableColumns.indexOf(tableColumn) === 0) {\n    return tableColumns.length;\n  }\n  return getTableCellColSpan(params);\n};\n","export const TABLE_SELECT_TYPE = Symbol('select');\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_SELECT_TYPE } from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TABLE_HEADING_TYPE } from '../table-header-row/constants';\nimport { IsSpecificCellFn, TableRow } from '../../types';\n\nexport const isSelectTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableColumn.type === TABLE_SELECT_TYPE && tableRow.type === TABLE_DATA_TYPE;\nexport const isSelectAllTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableColumn.type === TABLE_SELECT_TYPE && tableRow.type === TABLE_HEADING_TYPE;\n\nexport const isRowHighlighted: PureComputed<[boolean, any[], TableRow], boolean> = (\n  highlightRow, selection, tableRow,\n) => (\n  highlightRow && selection && selection.includes(tableRow.rowId)\n);\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_SELECT_TYPE } from './constants';\nimport { TableColumn } from '../../types';\n\nexport const tableColumnsWithSelection: PureComputed<[TableColumn[], number]> = (\n  tableColumns, selectionColumnWidth,\n) => [\n  { key: TABLE_SELECT_TYPE.toString(), type: TABLE_SELECT_TYPE, width: selectionColumnWidth },\n  ...tableColumns,\n];\n","import { TABLE_DATA_TYPE, TABLE_NODATA_TYPE } from './constants';\nimport {\n  IsSpecificCellFn, IsSpecificRowFn, TableRow, TableColumn, CheckColumnExtensionsFn,\n} from '../../types';\nimport { TABLE_STUB_TYPE } from '../../utils/virtual-table';\nimport { isValidValue } from '../table-column-resizing/helpers';\n\nconst VALID_UNITS = ['px', '%', 'em', 'rem', 'vm', 'vh', 'vmin', 'vmax', ''];\nconst TABLE_ERROR = 'The columnExtension property of the Table plugin is given an invalid value.';\n\nexport const isDataTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_DATA_TYPE && tableColumn.type === TABLE_DATA_TYPE;\nexport const isHeaderStubTableCell: IsSpecificCellFn<TableRow, TableRow[]> = (\n  tableRow, headerRows,\n) => headerRows.indexOf(tableRow) > -1;\nexport const isDataTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_DATA_TYPE;\nexport const isNoDataTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_NODATA_TYPE;\nexport const isNoDataTableCell: IsSpecificCellFn<TableColumn, TableColumn[]> = (\n  tableColumn, tableColumns,\n) => tableColumns.indexOf(tableColumn as any) === 0;\nexport const isStubTableCell: IsSpecificRowFn = tableRow => (\n  tableRow.type === TABLE_STUB_TYPE\n);\n\nexport const checkTableColumnExtensions: CheckColumnExtensionsFn = (columnExtensions) => {\n  if (columnExtensions) {\n    columnExtensions.map((column) => {\n      const { width } = column;\n      if (typeof width === 'string') {\n        if (!isValidValue(width, VALID_UNITS)) {\n          throw new Error(TABLE_ERROR);\n        }\n      }\n    });\n  }\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  GridColumnExtension, GetColumnExtensionValueGetterFn,\n} from '../types';\n\nexport const getColumnExtension: PureComputed<\n  [GridColumnExtension[] | undefined, string], GridColumnExtension\n> = (columnExtensions, columnName) => {\n  if (!columnExtensions) {\n    // tslint:disable-next-line:no-object-literal-type-assertion\n    return {} as GridColumnExtension;\n  }\n  const columnExtension = columnExtensions.find(extension => extension.columnName === columnName);\n  if (!columnExtension) {\n    // tslint:disable-next-line:no-object-literal-type-assertion\n    return {} as GridColumnExtension;\n  }\n  return columnExtension;\n};\n\nexport const getColumnExtensionValueGetter: GetColumnExtensionValueGetterFn = (\n  columnExtensions, extensionName, defaultValue,\n) => (columnName) => {\n  if (columnExtensions) {\n    const columnExtension = getColumnExtension(columnExtensions, columnName);\n    const extensionValue = columnExtension[extensionName];\n    return extensionValue !== undefined ? extensionValue : defaultValue;\n  }\n  return defaultValue;\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_DATA_TYPE, TABLE_NODATA_TYPE } from './constants';\nimport { getColumnExtension } from '../../utils/column-extension';\nimport { GridColumnExtension, GetCellColSpanFn } from './../../types/table.types';\nimport { Row, GetRowIdFn } from '../../types';\nimport { convertWidth } from '../table-column-resizing/helpers';\n\nexport const tableColumnsWithDataRows: PureComputed<[any[], GridColumnExtension[]]> = (\n  columns, columnExtensions,\n) => columns.map((column) => {\n  const { name } = column;\n  const columnExtension = getColumnExtension(columnExtensions as GridColumnExtension[], name);\n  const width = convertWidth(columnExtension.width!);\n  return {\n    column,\n    key: `${TABLE_DATA_TYPE.toString()}_${name}`,\n    type: TABLE_DATA_TYPE,\n    width,\n    align: columnExtension.align,\n    wordWrapEnabled: columnExtension.wordWrapEnabled,\n  };\n});\n\nexport const tableRowsWithDataRows: PureComputed<[Row[], GetRowIdFn, number]> = (\n  rows, getRowId, isRemoteRowsLoading,\n) => (\n  !rows.length && !isRemoteRowsLoading\n    ? [{ key: TABLE_NODATA_TYPE.toString(), type: TABLE_NODATA_TYPE }]\n    : rows.map((row, dataIndex) => {\n      const rowId = getRowId(row);\n      return {\n        row,\n        // dataIndex,\n        rowId,\n        type: TABLE_DATA_TYPE,\n        key: `${TABLE_DATA_TYPE.toString()}_${rowId}`,\n      };\n    }));\n\nexport const tableCellColSpanGetter: GetCellColSpanFn = (params) => {\n  const { tableRow, tableColumns, tableColumn } = params;\n  if (tableRow.type === TABLE_NODATA_TYPE && tableColumns.indexOf(tableColumn) === 0) {\n    return tableColumns.length;\n  }\n  return 1;\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { TableColumn } from '../../types';\n\nexport const visibleTableColumns: PureComputed<[TableColumn[], string[]]> = (\n  tableColumns = [], hiddenColumnNames,\n) => tableColumns.filter(tableColumn => tableColumn.type !== TABLE_DATA_TYPE\n    || hiddenColumnNames.indexOf(tableColumn.column!.name) === -1);\n","import { TABLE_DATA_TYPE } from '../table/constants';\nimport { TableColumn } from '../../types';\n\nexport const tableDataColumnsExist = (tableColumns: TableColumn[]) => tableColumns.some(\n  column => column.type === TABLE_DATA_TYPE,\n);\n","import { PureComputed } from '@devexpress/dx-core';\nimport { Column } from '../../types/grid-core.types';\nimport { ColumnChooserItem } from '../../types';\n\nexport const columnChooserItems: PureComputed<[Column[], string[]], ColumnChooserItem[]> = (\n  columns, hiddenColumnNames,\n) => columns.map(column => ({\n  column,\n  hidden: hiddenColumnNames.indexOf(column.name) !== -1,\n}));\n","import { PureReducer } from '@devexpress/dx-core';\n\nexport const toggleColumn: PureReducer<string[], string> = (\n  hiddenColumnNames, columnName,\n) => (\n  hiddenColumnNames.indexOf(columnName) === -1\n    ? [...hiddenColumnNames, columnName]\n    : hiddenColumnNames.filter(hiddenColumn => hiddenColumn !== columnName)\n);\n","import { toggle } from '../../utils/common-reducers';\nimport { ToggleRowFieldReducer } from '../../types';\n\nexport const toggleRowExpanded: ToggleRowFieldReducer = (\n  prevExpanded, { rowId, state },\n) => toggle(prevExpanded, [rowId], state);\n","export const GRID_TREE_NODE_TYPE = Symbol('treeNode');\n","import { PureComputed } from '@devexpress/dx-core';\nimport { GRID_TREE_NODE_TYPE } from './constants';\nimport {\n  RowsWithTreeMetaMap, RowsWithCollapsedRowsMetaMap, IsSpecificTreeRowGetter, GetRowIdFn,\n  GetRowLevelKeyFn, GetCollapsedRowsFn, CustomTreeRowsWithMetaComputed,\n  UnwrapRowsComputed, GetTreeRowLevelGetter, ExpandedTreeRowsFn, Row,\n} from '../../types';\n\nexport const customTreeRowsWithMeta: CustomTreeRowsWithMetaComputed = (\n  rows, getChildRows,\n) => {\n  const rowsToProcess = [{ row: null, level: -1 }] as Row[];\n  const treeRows = [] as { row: Row, level: number, leaf: boolean }[];\n\n  while (rowsToProcess?.length) {\n    const { row: currentRow, level } = rowsToProcess.shift()!;\n    const rowIndex = treeRows.findIndex(({ row }) => row === currentRow);\n    const nestedRows = getChildRows(currentRow, rows as Row[])?.map(\n      (childRow: Row) => ({\n        row: childRow,\n        level: level + 1,\n        leaf: !getChildRows(childRow, rows as Row[]),\n      }),\n    );\n\n    if (nestedRows) {\n      if (rowIndex > -1) {\n        treeRows.splice(rowIndex + 1, 0, ...nestedRows);\n      } else {\n        treeRows.push(...nestedRows);\n      }\n      rowsToProcess.push(...nestedRows);\n    }\n  }\n\n  const result = treeRows.reduce((acc, { row, level, leaf }) => {\n    acc.rows.push(row);\n    acc.treeMeta.push([row, { level, leaf }]);\n\n    return acc;\n  }, { rows: [] as Row[], treeMeta: [] as any[] });\n\n  return {\n    rows: result.rows,\n    treeMeta: new Map(result.treeMeta),\n  };\n};\n\nexport const customTreeRowIdGetter: PureComputed<[GetRowIdFn, RowsWithTreeMetaMap]> = (\n  getRowId, { rows, treeMeta },\n) => {\n  const firstNestedRowIndex = rows.findIndex(row => treeMeta.get(row)!.level > 0);\n  if (firstNestedRowIndex === -1 || getRowId(rows[firstNestedRowIndex]) !== undefined) {\n    return getRowId;\n  }\n  const map = new Map(rows\n    .map((row, rowIndex) => [row, rowIndex] as [any, any]));\n  return row => map.get(row);\n};\n\nexport const customTreeRowLevelKeyGetter: PureComputed<\n  [GetRowLevelKeyFn, RowsWithTreeMetaMap]\n> = (\n  getRowLevelKey, { treeMeta },\n) => (row) => {\n  const rowMeta = treeMeta.get(row);\n  if (rowMeta !== undefined) {\n    return `${GRID_TREE_NODE_TYPE.toString()}_${rowMeta.level}`;\n  }\n  return getRowLevelKey && getRowLevelKey();\n};\n\nexport const expandedTreeRows: ExpandedTreeRowsFn = (\n  { rows, treeMeta }, getRowId, expandedRowIds,\n) => {\n  const expandedRowIdsSet = new Set(expandedRowIds);\n\n  let currentExpanded = true;\n  let currentLevel = 0;\n\n  const collapsedRowsMeta = new Map();\n  const resultRows: object[] = [];\n\n  rows.forEach((row) => {\n    const rowMeta = treeMeta.get(row);\n    const level = rowMeta && rowMeta.level;\n    if (level === undefined && currentExpanded) {\n      resultRows.push(row);\n    } else if (!currentExpanded && (level === undefined || level > currentLevel)) {\n      const lastRow = resultRows[resultRows.length - 1];\n      let collapsedItems = collapsedRowsMeta.get(lastRow);\n      if (!collapsedItems) {\n        collapsedItems = [];\n        collapsedRowsMeta.set(lastRow, collapsedItems);\n      }\n      collapsedItems.push(row);\n    } else {\n      currentExpanded = expandedRowIdsSet.has(getRowId(row));\n      currentLevel = level!;\n\n      resultRows.push(row);\n    }\n  });\n\n  return {\n    treeMeta,\n    collapsedRowsMeta,\n    rows: resultRows,\n  };\n};\n\nexport const collapsedTreeRowsGetter: PureComputed<\n  [GetCollapsedRowsFn, RowsWithCollapsedRowsMetaMap]\n> = (\n  getCollapsedRows, { collapsedRowsMeta },\n) => row => collapsedRowsMeta.get(row) || (getCollapsedRows && getCollapsedRows(row));\n\nexport const isTreeRowLeafGetter: IsSpecificTreeRowGetter = ({ treeMeta }) => (row) => {\n  const rowMeta = treeMeta.get(row);\n  return rowMeta && rowMeta.leaf;\n};\n\nexport const getTreeRowLevelGetter: GetTreeRowLevelGetter = ({ treeMeta }) => (row) => {\n  const rowMeta = treeMeta.get(row);\n  return (rowMeta && rowMeta.level) as number;\n};\n\nexport const unwrappedCustomTreeRows: UnwrapRowsComputed = ({ rows }) => rows;\n","import { TABLE_DATA_TYPE } from '../table/constants';\nimport { IsSpecificCellFn, TableRow, TableColumn } from '../../types';\n\nexport const isTreeTableCell: IsSpecificCellFn<TableRow, TableColumn, string> = (\n  tableRow, tableColumn, forColumnName,\n) => tableRow.type === TABLE_DATA_TYPE && tableColumn.type === TABLE_DATA_TYPE\n  && tableColumn.column!.name === forColumnName;\n","export const changeSearchValue = (\n  prevSearchValue: string, searchValue: string,\n) => searchValue;\n","import { SearchFilterExpressionFn, FilterExpression } from '../../types';\n\nexport const searchFilterExpression: SearchFilterExpressionFn = (\n  searchValue, columns, filterExpression,\n) => {\n  const filters = columns.map(({ name }) => ({ columnName: name, value: searchValue }));\n  const selfFilterExpression: FilterExpression = { filters, operator: 'or' };\n  if (!filterExpression) {\n    return selfFilterExpression;\n  }\n  return {\n    operator: 'and',\n    filters: [filterExpression as FilterExpression, selfFilterExpression],\n  };\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { GetAvailableFilterOperationsFn, FilterOperation } from '../../types';\n\nexport const getAvailableFilterOperationsGetter: PureComputed<\n  [GetAvailableFilterOperationsFn, FilterOperation[], string[]]\n> = (\n  getAvailableFilterOperations,\n  availableFilterOperations,\n  columnNames,\n) => columnName => (columnNames.indexOf(columnName) > -1 && availableFilterOperations)\n// tslint:disable-next-line: max-line-length\n    || (typeof getAvailableFilterOperations === 'function' && getAvailableFilterOperations(columnName))\n    || undefined;\n","export const FIXED_COLUMN_LEFT_SIDE = 'left';\nexport const FIXED_COLUMN_RIGHT_SIDE = 'right';\nexport const TABLE_FIXED_TYPE = Symbol('fixed');\n","import { slice } from '@devexpress/dx-core';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport {\n  FIXED_COLUMN_LEFT_SIDE, TABLE_FIXED_TYPE,\n} from './constants';\nimport { findChainByColumnIndex } from '../table-header-row/helpers';\nimport {\n  GetFixedColumnKeysFn, IsSpecificRowFn, CalculatePositionFn, CalculateFixedColumnPropsFn,\n} from '../../types';\n\nexport const getFixedColumnKeys: GetFixedColumnKeysFn = (tableColumns, fixedNames) => tableColumns\n  .filter(tableColumn => (\n    (tableColumn.type === TABLE_DATA_TYPE && fixedNames.indexOf(tableColumn.column!.name) !== -1)\n    || fixedNames.indexOf(tableColumn.type) !== -1\n  ))\n  .map(({ key }) => key);\n\nexport const isFixedTableRow: IsSpecificRowFn = tableRow => tableRow.type === TABLE_FIXED_TYPE;\n\nconst calculatePosition: CalculatePositionFn = (array, index, tableColumnDimensions) => (\n  index === 0\n    ? 0\n    : array\n      .slice(0, index)\n      .reduce((acc, target) => acc + tableColumnDimensions[target] || 0, 0)\n);\n\nexport const calculateFixedColumnProps: CalculateFixedColumnPropsFn = (\n  { tableColumn },\n  { leftColumns, rightColumns },\n  tableColumns,\n  tableColumnDimensions,\n  tableHeaderColumnChains,\n) => {\n  const side = tableColumn.fixed!;\n  const targetArray = side === FIXED_COLUMN_LEFT_SIDE\n    ? getFixedColumnKeys(tableColumns, leftColumns)\n    : slice(getFixedColumnKeys(tableColumns, rightColumns)).reverse();\n\n  const index = tableColumns.findIndex(({ key }) => key === tableColumn.key);\n  const fixedIndex = targetArray.indexOf(tableColumn.key);\n  const columnChain = findChainByColumnIndex(tableHeaderColumnChains[0], index)!;\n\n  const showLeftDivider = columnChain.start === index && index !== 0;\n  const showRightDivider = columnChain.start + columnChain.columns.length - 1 === index\n    && index < tableColumns.length - 1;\n\n  const position = calculatePosition(targetArray, fixedIndex, tableColumnDimensions);\n\n  return {\n    showRightDivider,\n    showLeftDivider,\n    position,\n    side,\n  };\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport { FIXED_COLUMN_LEFT_SIDE, FIXED_COLUMN_RIGHT_SIDE, TABLE_FIXED_TYPE } from './constants';\nimport { splitHeaderColumnChains, generateSimpleChains } from '../table-header-row/helpers';\nimport {\n  FixedColumnName, TableColumn, FixedColumnSide, TableRow, HeaderColumnChainRows,\n  ShouldSplitChainFn,\n} from '../../types';\n\nexport const tableColumnsWithFixed: PureComputed<\n  [TableColumn[], FixedColumnName[], FixedColumnName[]]\n> = (\n  tableColumns, leftColumns, rightColumns,\n) => tableColumns\n  .map((tableColumn) => {\n    let fixed!: FixedColumnSide;\n    if ((tableColumn.type === TABLE_DATA_TYPE\n      && leftColumns.indexOf(tableColumn.column!.name) !== -1)\n      || leftColumns.indexOf(tableColumn.type) !== -1) {\n      fixed = FIXED_COLUMN_LEFT_SIDE;\n    }\n    if ((tableColumn.type === TABLE_DATA_TYPE\n      && rightColumns.indexOf(tableColumn.column!.name) !== -1)\n      || rightColumns.indexOf(tableColumn.type) !== -1) {\n      fixed = FIXED_COLUMN_RIGHT_SIDE;\n    }\n    return fixed ? { ...tableColumn, fixed } : tableColumn;\n  });\n\nexport const tableHeaderRowsWithFixed: PureComputed<[TableRow[]]> = tableHeaderRows => [\n  ...tableHeaderRows,\n  { key: TABLE_FIXED_TYPE.toString(), type: TABLE_FIXED_TYPE, height: 0 },\n];\n\nexport const tableHeaderColumnChainsWithFixed: PureComputed<\n  [HeaderColumnChainRows, TableRow[], TableColumn[]]\n> = (\n  tableHeaderColumnChains, tableHeaderRows, tableColumns,\n) => {\n  const chains = tableHeaderColumnChains\n    || generateSimpleChains(tableHeaderRows, tableColumns);\n\n  const shouldSplitChain: ShouldSplitChainFn = (currentGroup, column) => (\n    !currentGroup || (currentGroup as any).fixed !== column.fixed\n  );\n  const extendChainProps = (column: TableColumn) => ({\n    fixed: column.fixed,\n  });\n  return splitHeaderColumnChains(\n    chains,\n    tableColumns,\n    shouldSplitChain,\n    extendChainProps,\n  );\n};\n","import {\n  SummaryValue, SummaryCalculator,\n  DefaultSummaryCalculators,\n  Row,\n  TotalSummaryValuesFn,\n  GroupSummaryValuesFn,\n  TreeSummaryValuesFn,\n  RowsSummaryValuesFn,\n  ExpandRowsFn,\n  TableRow,\n  GroupLevel,\n} from '../../types';\n\nconst defaultSummaryCalculators: DefaultSummaryCalculators = {\n  count: rows => rows.length,\n  sum: (rows, getValue) => rows.reduce((acc, row) => acc + getValue(row), 0),\n  max: (rows, getValue) => (rows.length\n    ? rows.reduce((acc, row) => Math.max(acc, getValue(row)), -Infinity)\n    : null),\n  min: (rows, getValue) => (rows.length\n    ? rows.reduce((acc, row) => Math.min(acc, getValue(row)), Infinity)\n    : null),\n  avg: (rows, getValue) => (rows.length\n    ? rows.reduce((acc, row) => acc + getValue(row), 0) / rows.length\n    : null),\n};\n\nexport const defaultSummaryCalculator: SummaryCalculator = (type, rows, getValue) => {\n  const summaryCalculator = defaultSummaryCalculators[type];\n  if (!summaryCalculator) {\n    throw new Error(`The summary type '${type}' is not defined`);\n  }\n  return summaryCalculator(rows, getValue);\n};\n\nconst rowsSummary: RowsSummaryValuesFn = (\n  rows, summaryItems, getCellValue, calculator,\n) => summaryItems\n  .reduce((acc, { type, columnName }) => {\n    const getValue = (row: Row) => getCellValue(row, columnName);\n    acc.push(calculator(type, rows as any[], getValue));\n    return acc;\n  }, [] as SummaryValue[]);\n\nconst expandRows: ExpandRowsFn = (\n  rows, getRowLevelKey, getCollapsedRows, isGroupRow, includeGroupRow = false,\n) => {\n  const shouldIncludeRow = includeGroupRow || !isGroupRow\n    ? () => true\n    : (row: TableRow) => !isGroupRow(row);\n\n  return rows\n    .reduce((acc, row) => {\n      if (getRowLevelKey && getRowLevelKey(row)) {\n        if (shouldIncludeRow(row)) {\n          acc.push(row);\n        }\n        const collapsedRows = getCollapsedRows && getCollapsedRows(row);\n        if (collapsedRows) {\n          acc.push(...collapsedRows);\n        }\n        return acc;\n      }\n      acc.push(row);\n      return acc;\n    }, [] as TableRow[]);\n};\n\nexport const totalSummaryValues: TotalSummaryValuesFn = (\n  rows,\n  summaryItems,\n  getCellValue,\n  getRowLevelKey,\n  isGroupRow,\n  getCollapsedRows,\n  calculator = defaultSummaryCalculator,\n) => {\n  const plainRows = expandRows(rows, getRowLevelKey, getCollapsedRows, isGroupRow);\n  return rowsSummary(plainRows, summaryItems, getCellValue, calculator);\n};\n\nexport const groupSummaryValues: GroupSummaryValuesFn = (\n  rows,\n  summaryItems,\n  getCellValue,\n  getRowLevelKey,\n  isGroupRow,\n  getCollapsedRows,\n  calculator = defaultSummaryCalculator,\n) => {\n  let levels: GroupLevel[] = [];\n  const getLevelIndex = (levelKey: string) => (\n    levels.findIndex(level => level.levelKey === levelKey)\n  );\n  const summaries = {};\n\n  const anyRowLevelSummaryExist = summaryItems.some(item => (\n    !(item as any).showInGroupFooter\n  ));\n  const expandedRows = anyRowLevelSummaryExist\n    ? expandRows(rows, getRowLevelKey, getCollapsedRows, isGroupRow, true)\n    : rows;\n\n  expandedRows.forEach((row) => {\n    const levelKey = getRowLevelKey(row);\n    const collapsedRows = getCollapsedRows && getCollapsedRows(row);\n    let levelIndex = getLevelIndex(levelKey);\n    if (levelIndex > -1) {\n      levels.forEach((level) => {\n        summaries[level.row.compoundKey] = rowsSummary(\n          level.rows, summaryItems, getCellValue, calculator,\n        );\n      });\n      levels = levels.slice(0, levelIndex);\n    }\n    if (isGroupRow!(row)) {\n      levels.push({\n        levelKey,\n        row,\n        rows: [],\n      });\n      levelIndex = getLevelIndex(levelKey);\n    }\n    // when row level summary exists, these rows had already been expanded earlier\n    const isCollapsedNestedGroupRow = collapsedRows && levelIndex > 0 && !anyRowLevelSummaryExist;\n    const rowsToAppend = !levelKey ? [row] : collapsedRows;\n    if (!levelKey || isCollapsedNestedGroupRow) {\n      levels.forEach((level) => {\n        level.rows.push(...rowsToAppend);\n      });\n    }\n  }, {});\n  levels.forEach((level) => {\n    summaries[level.row.compoundKey] = rowsSummary(\n      level.rows, summaryItems, getCellValue, calculator,\n    );\n  });\n  return summaries;\n};\n\nexport const treeSummaryValues: TreeSummaryValuesFn = (\n  rows,\n  summaryItems,\n  getCellValue,\n  getRowLevelKey,\n  isGroupRow,\n  getRowId,\n  calculator = defaultSummaryCalculator,\n) => {\n  let levels: any[] = [];\n  const summaries = {};\n  rows.forEach((row) => {\n    const levelKey = getRowLevelKey(row);\n    if (!levelKey) {\n      levels[levels.length - 1].rows.push(row);\n      return;\n    }\n    const levelIndex = levels.findIndex(level => level.levelKey === levelKey);\n    if (levelIndex > -1) {\n      levels.slice(levelIndex).forEach((level) => {\n        if (level.rows.length) {\n          summaries[getRowId(level.row)] = rowsSummary(\n            level.rows, summaryItems, getCellValue, calculator,\n          );\n        }\n      });\n      levels = levels.slice(0, levelIndex);\n    }\n    if (!isGroupRow || !isGroupRow(row)) {\n      if (levels.length) {\n        levels[levels.length - 1].rows.push(row);\n      }\n      levels.push({\n        levelKey,\n        row,\n        rows: [],\n      });\n    }\n  }, {});\n  levels.forEach((level) => {\n    if (level.rows.length) {\n      summaries[getRowId(level.row)] = rowsSummary(\n        level.rows, summaryItems, getCellValue, calculator,\n      );\n    }\n  });\n  return summaries;\n};\n","export const TABLE_TOTAL_SUMMARY_TYPE = Symbol('totalSummary');\nexport const TABLE_GROUP_SUMMARY_TYPE = Symbol('groupSummary');\nexport const TABLE_TREE_SUMMARY_TYPE = Symbol('treeSummary');\n\nexport const defaultFormatlessSummaries = ['count'];\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  TABLE_TOTAL_SUMMARY_TYPE, TABLE_GROUP_SUMMARY_TYPE, TABLE_TREE_SUMMARY_TYPE,\n} from './constants';\nimport { TABLE_DATA_TYPE } from '../table/constants';\nimport {\n  GetColumnSummariesFn, IsSpecificCellFn, IsSpecificRowFn, SummaryItem,\n  GetGroupInlineSummariesFn, ColumnInlineSummaries, GroupSummaryItem,\n} from '../../types';\n\nexport const isTotalSummaryTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_TOTAL_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE;\nexport const isGroupSummaryTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_GROUP_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE;\nexport const isTreeSummaryTableCell: IsSpecificCellFn = (\n  tableRow, tableColumn,\n) => tableRow.type === TABLE_TREE_SUMMARY_TYPE && tableColumn.type === TABLE_DATA_TYPE;\nexport const isTotalSummaryTableRow: IsSpecificRowFn = tableRow => (\n  tableRow.type === TABLE_TOTAL_SUMMARY_TYPE\n);\nexport const isGroupSummaryTableRow: IsSpecificRowFn = tableRow => (\n  tableRow.type === TABLE_GROUP_SUMMARY_TYPE\n);\nexport const isTreeSummaryTableRow: IsSpecificRowFn = tableRow => (\n  tableRow.type === TABLE_TREE_SUMMARY_TYPE\n);\n\nexport const getColumnSummaries: GetColumnSummariesFn = (\n  summaryItems, columnName, summaryValues, predicate = () => true,\n) => summaryItems\n  .map((item, index) => [item, index] as [SummaryItem, number])\n  .filter(([item]) => item.columnName === columnName && predicate(item))\n  .map(([item, index]) => ({\n    type: item.type,\n    value: summaryValues[index],\n  }));\n\nexport const isFooterSummary: PureComputed<[SummaryItem], boolean> = summaryItem => (\n  (summaryItem as GroupSummaryItem).showInGroupFooter!\n);\nexport const isInlineGroupCaptionSummary: PureComputed<[SummaryItem], boolean> = summaryItem => (\n  !((summaryItem as GroupSummaryItem).showInGroupFooter ||\n  (summaryItem as GroupSummaryItem).alignByColumn)\n);\nexport const groupFooterSummaryExists: PureComputed<[GroupSummaryItem[]], boolean> =\n  groupSummaryItems => groupSummaryItems?.some(isFooterSummary);\n\nexport const getGroupInlineSummaries: GetGroupInlineSummariesFn = (\n  summaryItems, columns, summaryValues,\n) => {\n  if (!summaryItems.some(isInlineGroupCaptionSummary)) {\n    return [];\n  }\n\n  return columns.reduce((acc, column) => {\n    const colName = column.name;\n    const summaries = getColumnSummaries(\n      summaryItems, colName, summaryValues, isInlineGroupCaptionSummary,\n    );\n    if (summaries.length) {\n      acc.push({\n        column,\n        summaries,\n      });\n    }\n\n    return acc;\n  }, [] as ColumnInlineSummaries[]);\n};\n","import { PureComputed } from '@devexpress/dx-core';\nimport {\n  TABLE_TOTAL_SUMMARY_TYPE,\n  TABLE_GROUP_SUMMARY_TYPE,\n  TABLE_TREE_SUMMARY_TYPE,\n} from './constants';\nimport {\n  TableRow, RowLevel, TableRowsWithSummariesFn,\n} from '../../types';\nimport { groupFooterSummaryExists } from './helpers';\n\nexport const tableRowsWithTotalSummaries: PureComputed<[TableRow[]]> = footerRows => [\n  { key: TABLE_TOTAL_SUMMARY_TYPE.toString(), type: TABLE_TOTAL_SUMMARY_TYPE },\n  ...footerRows,\n];\n\nexport const tableRowsWithSummaries: TableRowsWithSummariesFn = (\n  tableRows, groupSummaryItems, treeSummaryItems, getRowLevelKey, isGroupRow, getRowId,\n) => {\n  const hasGroupFooterSummary = groupFooterSummaryExists(groupSummaryItems);\n  if (!getRowLevelKey || !(hasGroupFooterSummary || treeSummaryItems.length)) return tableRows;\n\n  const result: TableRow[] = [];\n  const closeLevel = (level: RowLevel) => {\n    if (!level.opened) return;\n    if (hasGroupFooterSummary && isGroupRow && isGroupRow(level.row)) {\n      const { compoundKey } = level.row;\n      result.push({\n        key: `${TABLE_GROUP_SUMMARY_TYPE.toString()}_${compoundKey}`,\n        type: TABLE_GROUP_SUMMARY_TYPE,\n        row: level.row,\n      });\n    } else if (treeSummaryItems.length) {\n      const rowId = getRowId(level.row);\n      result.push({\n        key: `${TABLE_TREE_SUMMARY_TYPE.toString()}_${rowId}`,\n        type: TABLE_TREE_SUMMARY_TYPE,\n        row: level.row,\n      });\n    }\n  };\n\n  let levels: RowLevel[] = [];\n  tableRows.forEach((tableRow) => {\n    const { row } = tableRow;\n    const levelKey = getRowLevelKey(row);\n    if (levelKey) {\n      const levelIndex = levels.findIndex(level => level.levelKey === levelKey);\n      if (levelIndex > -1) {\n        levels.slice(levelIndex).reverse().forEach(closeLevel);\n        levels = levels.slice(0, levelIndex);\n      }\n      if (!isGroupRow || !isGroupRow(row)) {\n        levels = levels.map(level => ({\n          ...level,\n          opened: true,\n        }));\n      }\n      levels.push({\n        levelKey,\n        row,\n        opened: false,\n      });\n    } else {\n      levels = levels.map(level => ({\n        ...level,\n        opened: true,\n      }));\n    }\n    result.push(tableRow);\n  });\n  levels.slice().reverse().forEach(closeLevel);\n\n  return result;\n};\n","import { GroupSummaryItem } from '../../types';\n\nexport const prepareGroupSummaryItems = (items: GroupSummaryItem[]) => (\n  !!items\n    ? items.map(item => ({\n      ...item,\n      showInGroupFooter: (\n        item.showInGroupFooter === undefined && !item.alignByColumn\n      )\n        ? true\n        : item.showInGroupFooter,\n    }))\n    : items\n);\n","import { GetTargetColumnGeometriesFn, GetNodeGeometriesFn } from '../types';\n\nexport const getTargetColumnGeometries: GetTargetColumnGeometriesFn = (\n  columnGeometries, sourceIndex,\n) => {\n  const sourceWidth = columnGeometries[sourceIndex].right - columnGeometries[sourceIndex].left;\n  const getWidthDifference = (index: number) => columnGeometries[index].right\n                                      - columnGeometries[index].left\n                                      - sourceWidth;\n\n  return columnGeometries\n    .map(({\n      top, right, bottom, left,\n    }, targetIndex) => {\n      let leftBorder = left;\n      if (targetIndex > 0 && targetIndex <= sourceIndex) {\n        leftBorder = Math.min(leftBorder, leftBorder - getWidthDifference(targetIndex - 1));\n      }\n      if (targetIndex > sourceIndex) {\n        leftBorder = Math.max(leftBorder, leftBorder + getWidthDifference(targetIndex));\n      }\n      let rightBorder = right;\n      if (targetIndex < columnGeometries.length - 1 && targetIndex >= sourceIndex) {\n        rightBorder = Math.max(rightBorder, rightBorder + getWidthDifference(targetIndex + 1));\n      }\n      if (targetIndex < sourceIndex) {\n        rightBorder = Math.min(rightBorder, rightBorder - getWidthDifference(targetIndex));\n      }\n\n      return {\n        top,\n        bottom,\n        right: rightBorder,\n        left: leftBorder,\n      };\n    });\n};\n\nexport const getCellGeometries: GetNodeGeometriesFn = (node) => {\n  const { left, right, width } = node.getBoundingClientRect();\n  const styleLeft = parseInt(node.style.left?.toString().replace('px', ''), 10);\n  const styleRight = parseInt(node.style.right?.toString().replace('px', ''), 10);\n\n  if (!isNaN(styleLeft)) {\n    const calculatedLeft = Math.max(styleLeft, left);\n    return {\n      left: calculatedLeft,\n      right: calculatedLeft + width,\n      isFixed: true,\n    };\n  }\n\n  if (!isNaN(styleRight)) {\n    // NOTE: get tableContainer (parent of first DIV element) to calculate 'right' value\n    let tableContainer = node as HTMLElement | null;\n    while (tableContainer && tableContainer.nodeName !== 'DIV') {\n      tableContainer = tableContainer.parentNode as HTMLElement;\n    }\n    tableContainer = tableContainer?.parentNode as HTMLElement;\n\n    if (tableContainer) {\n      const { width: tableWidth } = tableContainer.getBoundingClientRect();\n      const calculatedRight = Math.min(tableWidth - styleRight, right);\n      return {\n        left: calculatedRight - width,\n        right: calculatedRight,\n        isFixed: true,\n      };\n    }\n  }\n\n  return { left, right };\n};\n","import { easeOutCubic } from '@devexpress/dx-core';\nimport {\n  GetTableColumnGeometriesFn, GetTableTargetColumnIndexFn, ColumnAnimation,\n  GetColumnAnimationsFn, ColumnGeometry, FilterActiveAnimationsFn, EvalAnimationsFn,\n} from '../types';\n\nexport const getTableColumnGeometries: GetTableColumnGeometriesFn = (columns, tableWidth) => {\n  const columnWidths = columns\n    .map(column => column.width);\n\n  const freeSpace = tableWidth;\n  const restrictedSpace = columnWidths\n    .reduce(\n      (accum, width) => (accum as number)! + (typeof width === 'number' ? width : 0), 0) as number;\n  const freeSpacePortions = columnWidths\n    .reduce(\n      (accum, width) => (accum as number)! + (typeof width !== 'number' ? 1 : 0), 0) as number;\n  const freeSpacePortion = (freeSpace - restrictedSpace!) / freeSpacePortions!;\n\n  let lastRightPosition = 0;\n  return columnWidths\n    .map(width => (typeof width !== 'number' ? freeSpacePortion : width))\n    .map((width) => {\n      lastRightPosition += width;\n      return {\n        left: lastRightPosition - width,\n        right: lastRightPosition,\n      };\n    });\n};\n\nexport const getTableTargetColumnIndex: GetTableTargetColumnIndexFn = (\n  columnGeometries, offset,\n) => {\n  const indexes = columnGeometries.reduce((acc, { left, right }, index) => {\n    if (offset > left && offset < right) {\n      acc.push(index);\n    }\n    return acc;\n  }, [] as number[]);\n\n  if (indexes.length === 2) {\n    return indexes.find(index => columnGeometries[index].isFixed)!;\n  }\n  if (indexes.length === 1) {\n    return indexes[0];\n  }\n  return -1;\n};\n\nconst ANIMATION_DURATION = 200;\n\nconst getAnimationProgress = (animation: ColumnAnimation) => (\n  new Date().getTime() - animation.startTime) / ANIMATION_DURATION;\n\nexport const getAnimations: GetColumnAnimationsFn = (\n  prevColumns,\n  nextColumns,\n  tableWidth,\n  prevAnimations,\n) => {\n  const resizing = prevColumns.map(column => column.key).join()\n    === nextColumns.map(column => column.key).join();\n\n  const prevColumnGeometries = new Map<string, ColumnGeometry>(\n    getTableColumnGeometries(prevColumns, tableWidth)\n      .map((geometry, index) => [prevColumns[index].key, geometry] as [string, ColumnGeometry])\n      .map(([key, geometry]) => {\n        const animation = prevAnimations.get(key);\n        if (!animation) return [key, geometry];\n        const progress = easeOutCubic(getAnimationProgress(animation));\n        const { to, from } = animation.left!;\n        const left = ((to - from) * progress) + from;\n        return [key, {\n          left,\n          right: geometry.right - (geometry.left - left),\n        }];\n      // tslint:disable-next-line:array-type\n      }) as [string, ColumnGeometry][],\n    );\n\n  const nextColumnGeometries = new Map(\n    getTableColumnGeometries(nextColumns, tableWidth)\n      // tslint:disable-next-line:array-type\n      .map((geometry, index) => [nextColumns[index].key, geometry]) as [string, ColumnGeometry][],\n  );\n\n  return new Map([...nextColumnGeometries.keys()]\n    .map((key) => {\n      const prev: any = prevColumnGeometries.get(key);\n      const next: any = nextColumnGeometries.get(key);\n\n      const result: ColumnAnimation = { startTime: new Date().getTime(), style: {} };\n      const takePrevColumnIntoAccount = !!prevAnimations.get(key) || (prev && !resizing);\n      if (Math.abs((takePrevColumnIntoAccount ? prev!.left : next!.left) - next!.left) > 1) {\n        result.left = { from: prev.left, to: next.left };\n      }\n      return [key, result] as [string, ColumnAnimation];\n    })\n    .filter((animation: [string, ColumnAnimation]) => animation[1].left));\n};\n\nexport const filterActiveAnimations: FilterActiveAnimationsFn = animations => new Map(\n  [...animations.entries()]\n    .filter(([, animation]) => getAnimationProgress(animation) < 1),\n);\n\nexport const evalAnimations: EvalAnimationsFn = animations => new Map([...animations.entries()]\n  .map(([key, animation]): [string, object] => {\n    const progress = easeOutCubic(getAnimationProgress(animation));\n    const result = { ...animation.style };\n    if (animation.left) {\n      const offset = (animation.left.to - animation.left.from) * (progress - 1);\n      (result as any).transform = `translateX(${offset}px)`;\n    }\n    return [key, result];\n  }));\n","import { getTargetColumnGeometries } from './column-geometries';\nimport { TargetColumnGeometry, GetGroupCellTargetIndexFn } from '../types';\nimport { PureComputed } from '@devexpress/dx-core';\n\nconst isOnTheSameLine: PureComputed<[TargetColumnGeometry, number], boolean> = (geometry, y) => (\n  y >= geometry.top && y <= geometry.bottom\n);\n\nconst rectToObject = ({\n  top, right, bottom, left,\n}: TargetColumnGeometry) => ({\n  top, right, bottom, left,\n});\n\nconst collapseGapsBetweenItems: PureComputed<[TargetColumnGeometry[]]> = geometries => (\n  geometries.map((geometry, index) => {\n    if (index !== geometries.length - 1 && geometry.top === geometries[index + 1].top) {\n      return {\n        ...geometry,\n        right: geometries[index + 1].left,\n      };\n    }\n    return geometry;\n  }));\n\nexport const getGroupCellTargetIndex: GetGroupCellTargetIndexFn = (\n  geometries, sourceIndex, { x, y },\n) => {\n  if (geometries.length === 0) return 0;\n\n  const targetGeometries = sourceIndex !== -1\n    ? getTargetColumnGeometries(geometries, sourceIndex)\n    : geometries.map(rectToObject);\n\n  const targetIndex = collapseGapsBetweenItems(targetGeometries)\n    .findIndex((geometry, index) => {\n      const inVerticalBounds = isOnTheSameLine(geometry, y);\n      const inHorizontalBounds = x >= geometry.left && x <= geometry.right;\n      const shouldGoFirst = index === 0 && x < geometry.left;\n      const shouldGoOnLineBreak = !inVerticalBounds\n        && !!geometries[index - 1]\n        && isOnTheSameLine(geometries[index - 1], y);\n\n      return (inVerticalBounds && inHorizontalBounds)\n        || shouldGoFirst\n        || shouldGoOnLineBreak;\n    });\n\n  return targetIndex === -1 ? geometries.length : targetIndex;\n};\n","import { PureComputed } from '@devexpress/dx-core';\n\ntype CompareFn = (...args: [any, any]) => boolean;\n/** @internal */\nexport const arraysEqual: PureComputed<[any[], any[], CompareFn?], boolean> = (\n  arrA, arrB, comparator = (a, b) => a === b,\n) => {\n  if (arrA.length !== arrB.length) {\n    return false;\n  }\n  for (let i = 0; i < arrA.length; i += 1) {\n    if (!comparator(arrA[i], arrB[i])) {\n      return false;\n    }\n  }\n  return true;\n};\n","import { GridViewport } from '../../types';\n\n/** @internal */\nexport const emptyViewport: GridViewport = {\n  columns: [[0, 0]],\n  rows: [0, 0],\n  headerRows: [0, 0],\n  footerRows: [0, 0],\n  top: 0,\n  left: 0,\n  width: 800,\n  height: 600,\n};\n\nexport const TOP_POSITION = Symbol('top');\nexport const BOTTOM_POSITION = Symbol('bottom');\n","import {\n  getRowsVisibleBoundary, getColumnBoundaries,\n} from '../../utils/virtual-table';\nimport {\n  GetViewportFn,\n  CheckTableColumnWidths,\n  TableColumn,\n  GetScrollHeightByIndex,\n  GetScrollPosition,\n  GetTopRowId,\n} from '../../types';\nimport { arraysEqual } from './utils';\nimport { TOP_POSITION, BOTTOM_POSITION } from './constants';\n\nconst VALID_UNITS = ['px', ''];\n/* tslint:disable max-line-length */\nconst VIRTUAL_TABLE_ERROR = 'The columnExtension property of the VirtualTable plugin is given an invalid value.';\n\nexport const getViewport: GetViewportFn = (\n  state, getters, estimatedRowHeight, getRowHeight, getColumnWidth,\n) => {\n  const {\n    viewportTop, viewportLeft, containerWidth, containerHeight, headerHeight, footerHeight,\n  } = state;\n  const {\n    loadedRowsStart,\n    bodyRows: tableBodyRows,\n    columns: tableColumns,\n    headerRows: tableHeaderRows = [],\n    footerRows: tableFooterRows = [],\n    isDataRemote,\n    viewport,\n  } = getters;\n\n  const rows = getRowsVisibleBoundary(\n    tableBodyRows, viewportTop, containerHeight - headerHeight - footerHeight,\n    getRowHeight, loadedRowsStart, estimatedRowHeight, isDataRemote,\n  );\n  const headerRows = getRowsVisibleBoundary(\n    tableHeaderRows, 0, headerHeight,\n    getRowHeight, 0, estimatedRowHeight, false,\n  );\n  const footerRows = getRowsVisibleBoundary(\n    tableFooterRows, 0, footerHeight,\n    getRowHeight, 0, estimatedRowHeight, false,\n  );\n  const columns = getColumnBoundaries(\n    tableColumns, viewportLeft, containerWidth, getColumnWidth,\n  );\n\n  // NOTE: prevent unnecessary updates\n  // e.g. when rows changed but bounds remain the same.\n  let result = viewport;\n  if (viewportTop !== viewport.top) {\n    result = { ...result, top: viewportTop };\n  }\n  if (viewportLeft !== viewport.left) {\n    result = { ...result, left: viewportLeft };\n  }\n  if (containerWidth !== viewport.width) {\n    result = { ...result, width: containerWidth };\n  }\n  if (containerHeight !== viewport.height) {\n    result = { ...result, height: containerHeight };\n  }\n  if (!arraysEqual(rows, viewport.rows)) {\n    result = { ...result, rows };\n  }\n  if (!arraysEqual(headerRows, viewport.headerRows)) {\n    result = { ...result, headerRows };\n  }\n  if (!arraysEqual(footerRows, viewport.footerRows)) {\n    result = { ...result, footerRows };\n  }\n  if (!arraysEqual(columns, viewport.columns, arraysEqual)) {\n    result = { ...result, columns };\n  }\n\n  return result;\n};\n\nexport const checkColumnWidths: CheckTableColumnWidths = (tableColumns) => {\n  return tableColumns.reduce((acc, tableColumn) => {\n    const { width } = tableColumn;\n    if (typeof width === 'string') {\n      const numb = parseInt(width, 10);\n      const unit = numb ? width.substr(numb.toString().length) : width;\n      const isValidUnit = VALID_UNITS.some(validUnit => validUnit === unit);\n      if (!isValidUnit) {\n        throw new Error(VIRTUAL_TABLE_ERROR);\n      }\n      acc.push({ ...tableColumn, width: numb });\n    } else {\n      acc.push(tableColumn);\n    }\n    return acc;\n  }, []  as TableColumn[]);\n};\n\nexport const calculateScrollHeight: GetScrollHeightByIndex = (rowHeight, index) =>\n  index > -1 ? rowHeight * index : undefined;\n\nexport const getScrollTop: GetScrollPosition = (rows, rowsCount, rowId, rowHeight, isDataRemote) => {\n  if (rowId === TOP_POSITION) {\n    return 0;\n  }\n  if (rowId === BOTTOM_POSITION) {\n    return rowsCount * rowHeight;\n  }\n\n  const searchIndexRequired = !isDataRemote && rowId !== undefined;\n  const indexById = searchIndexRequired\n    ? rows.findIndex(row => row.rowId === rowId)\n    : undefined;\n\n  return calculateScrollHeight(\n    rowHeight,\n    indexById!,\n  );\n};\n\nexport const getTopRowId: GetTopRowId = (viewport, tableBodyRows, isDataRemote) => {\n  const hasViewportRows = viewport && viewport.rows;\n  const hasBodyRows = tableBodyRows && tableBodyRows.length;\n  if (hasViewportRows && hasBodyRows && !isDataRemote) {\n    const index = viewport.rows[0];\n\n    return index < tableBodyRows.length ? tableBodyRows[index].rowId : undefined;\n  }\n\n  return undefined;\n};\n","import { mergeRows } from './helpers';\nimport { intervalUtil } from './utils';\nimport { VirtualRowsWithCacheFn, PlainRowsFn, LoadedRowsStartFn } from '../../types';\n\nexport const virtualRowsWithCache: VirtualRowsWithCacheFn = (skip, rows, cache) => {\n  const rowsInterval = intervalUtil.getRowsInterval({ skip, rows });\n  const cacheInterval = intervalUtil.getRowsInterval(cache);\n\n  return mergeRows(rowsInterval, cacheInterval, rows, cache.rows, skip, cache.skip);\n};\n\nexport const plainRows: PlainRowsFn = (virtualRows, availableRowCount) => {\n  return virtualRows.rows.length > availableRowCount\n    ? virtualRows.rows.slice(0, availableRowCount)\n    : virtualRows.rows;\n};\n\nexport const loadedRowsStart: LoadedRowsStartFn = virtualRows => virtualRows.skip;\n"],"sourceRoot":""}