{"version":3,"sources":["../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/clientSideRowModel.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/clientSideNodeManager.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/filterStage.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/sortStage.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/flattenStage.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/sortService.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/filterService.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModel/immutableService.js","../node_modules/@ag-grid-community/client-side-row-model/dist/es6/clientSideRowModelModule.js","../node_modules/@ag-grid-community/all-modules/dist/es6/main.js"],"names":["RecursionType","ClientSideNodeManager","rootNode","gridOptionsWrapper","context","eventService","columnController","gridApi","columnApi","selectionController","this","nextId","allNodesMap","group","level","id","ROOT_NODE_ID","allLeafChildren","childrenAfterGroup","childrenAfterSort","childrenAfterFilter","postConstruct","prototype","getNodeChildDetails","getNodeChildDetailsFunc","suppressParentsInRowNodes","isSuppressParentsInRowNodes","doesDataFlower","getDoesDataFlowerFunc","isRowMasterFunc","getIsRowMasterFunc","doingLegacyTreeData","exists","doingMasterDetail","isMasterDetail","console","warn","getCopyOfNodesMap","cloneObject","getRowNode","setRowData","rowData","childrenMapped","result","recursiveFunction","TOP_LEVEL","setLeafChildren","updateRowData","rowDataTran","rowNodeOrder","isLegacyTreeData","rowNodeTransaction","remove","update","add","executeAdd","executeRemove","executeUpdate","sortRowNodesByOrder","_this","addIndex","reverse","forEach","item","newRowNode","addRowNode","push","rowIdsRemoved","anyNodesSelected","rowNode","lookupRowNode","isSelected","setSelected","clearRowTop","filter","updateGroupsFromChildrenSelections","event_1","type","EVENT_SELECTION_CHANGED","api","dispatchEvent","updateData","data","index","newNode","createNode","insertIntoArray","rowNodeIdFunc","getRowNodeIdFunc","error","find","parent","rowNodes","dataItem","node","wireBean","doingTreeData","isTreeData","nodeChildDetails","children","expanded","field","key","canFlower","master","rowGroupColumns","getRowGroupColumns","masterRowLevel","length","isExpanded","setDataAndId","toString","expandByDefault","getGroupDefaultExpanded","childAfterGroup","leafChild","__decorate","decorators","target","desc","d","c","arguments","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","ClientSideRowModel","init","refreshEverythingFunc","refreshModel","bind","step","STEP_EVERYTHING","refreshEverythingAfterColsChangedFunc","afterColumnsChanged","addModalPriorityEventListener","EVENT_COLUMN_EVERYTHING_CHANGED","EVENT_COLUMN_ROW_GROUP_CHANGED","EVENT_COLUMN_VALUE_CHANGED","onValueChanged","EVENT_COLUMN_PIVOT_CHANGED","STEP_PIVOT","EVENT_ROW_GROUP_OPENED","onRowGroupOpened","EVENT_FILTER_CHANGED","onFilterChanged","EVENT_SORT_CHANGED","onSortChanged","EVENT_COLUMN_PIVOT_MODE_CHANGED","refreshMapFunc","STEP_MAP","keepRenderedRows","animate","addEventListener","PROP_GROUP_REMOVE_SINGLE_CHILDREN","PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN","nodeManager","start","getRowData","ensureRowHeightsValid","startPixel","endPixel","startLimitIndex","endLimitIndex","atLeastOneChange","res","rowAtStartPixel","getRowIndexAtPixel","rowAtEndPixel","firstRow","Math","max","lastRow","min","rowIndex","getRow","rowHeightEstimated","rowHeight","getRowHeightForNode","setRowHeight","height","setRowTops","nextRowTop","rowsToDisplay","allowEstimate","getDomLayout","DOM_LAYOUT_NORMAL","missing","estimated","setRowTop","setRowIndex","resetRowTops","changedPath","hasChildren","isActive","sibling","detailNode","ensureRowAtPixel","pixel","indexAtPixelNow","removeFromArray","keepEditingRows","isLastRowFound","getRowCount","getTopLevelRowCount","getTopLevelRowDisplayedIndex","topLevelIndex","isGroupHideOpenParents","getRowBounds","rowTop","isAnimateRows","STEP_FILTER","STEP_SORT","getType","ROW_MODEL_TYPE_CLIENT_SIDE","isPivotActive","STEP_AGGREGATE","createChangePath","rowNodeTransactions","noTransactions","missingOrEmpty","setInactive","params","doRowGrouping","groupState","doFilter","doPivot","doAggregate","doSort","doRowsToDisplay","event","EVENT_MODEL_UPDATED","newData","newPage","$scope","window","setTimeout","$apply","isEmpty","rowsMissing","isReady","isRowsToRender","getNodesInRangeForSelection","firstInRange","lastInRange","firstRowHit","lastRowHit","groupsSelectChildren","isGroupSelectsChildren","forEachNodeAfterFilterAndSort","lookingForLastRow","inRange","childOfLastRow","isParentOfNode","setDatasource","datasource","getTopLevelNodes","getRootNode","isRowPresent","indexOf","pixelToMatch","bottomPointer","topPointer","last","midPointer","floor","currentRowNode","isRowInPixel","topPixel","bottomPixel","getCurrentPageHeight","forEachLeafNode","callback","forEachNode","recursivelyWalkNodesAndCallback","Normal","forEachNodeAfterFilter","AfterFilter","AfterFilterAndSort","forEachPivotNode","PivotNodes","nodes","recursionType","nodeChildren","leafGroup","aggregationStage","execute","expandOrCollapseAll","expand","usingTreeData","recursiveExpandOrCollapse","eventSource","EVENT_EXPAND_COLLAPSE_ALL","source","sortStage","groupStage","merged_1","tran","pushAll","removeGroupsFromSelection","restoreGroupState","traverseNodesWithKey","filterStage","pivotStage","getGroupState","isRememberGroupStateWhenNewData","rowDataChangedEvent","EVENT_ROW_DATA_CHANGED","batchUpdateRowData","rowDataTransaction","rowDataTransactionBatch","waitMillis","getBatchUpdateWaitMillis","executeBatchUpdateRowData","valueCache","onDataChanged","callbackFuncsBound","rowNodeTrans","tranItem","rowNodeTran","commonUpdateRowData","func","EVENT_ROW_DATA_UPDATED","flattenStage","onRowHeightChanged","resetRowHeights","FilterStage","filterService","selectableService","updateSelectableAfterFiltering","SortStage","sortOptions","sortController","getSortForRowController","sortActive","deltaSort","isDeltaSort","dirtyLeafNodes","calculateDirtyNodes","valueColumns","getValueColumns","noAggregations","sortService","sort","dirtyNodes","addNodesFunc","FlattenStage","value","skipLeafNodes","isPivotMode","showRootNode","topList","recursivelyAddToRowsToDisplay","isGroupIncludeTotalFooter","ensureFooterNodeExists","addRowNodeToRowsToDisplay","rowsToFlatten","uiLevel","groupSuppressRow","isGroupSuppressRow","hideOpenParents","groupRemoveSingleChildren","isGroupRemoveSingleChildren","groupRemoveLowestSingleChildren","isGroupRemoveLowestSingleChildren","isParent","isGroupSuppressedNode","isSkippedLeafNode","isRemovedSingleChildrenGroup","isRemovedLowestSingleChildrenGroup","neverAllowToExpand","isHiddenOpenParent","excludedParent","uiLevelForChildren","isGroupIncludeFooter","createDetailNode","isGroupMultiAutoColumn","setUiLevel","groupNode","footerNode","keys","footer","oldRowTop","masterNode","detail","selectable","flower","childFlower","SortService","postSortFunc","getPostSortFunc","forEachChangedNodeDepthFirst","pullDownGroupDataForHideOpenParents","sortedRowNodes","doDeltaSort","doFullSort","map","sorted","slice","updateChildIndexes","updateGroupDataForHiddenOpenParents","mapNodeToSortedNode","compareRowNodes","pos","currentPos","cleanNodes","passesDirtyNodesCheck","passesChangedPathCheck","canSkip","cleanNodesMapped","sortedRowNode","changedNodes","mergeSortedArrays","arr1","arr2","j","sortedNodeA","sortedNodeB","nodeA","nodeB","len","sortOption","isInverted","inverter","valueA","getValue","column","valueB","comparatorResult","getColDef","comparator","defaultComparator","isAccentedSort","valueService","listToSort","child","firstChild","lastChild","setFirstChild","setLastChild","setChildIndex","executeFromRootNode","clearOperation","childRowNode","getGroupDisplayColumns","groupDisplayCol","showRowGroup","displayingGroupKey","rowGroupColumn","getPrimaryColumn","setGroupValue","getId","parentToStealFrom","getFirstChildOfFirstChild","FilterService","filterActive","filterManager","isAnyFilterPresent","filterNodes","filterCallback","includeChildNodes","childNode","passBecauseChildren","passBecauseDataPasses","doesRowPassFilter","setAllChildrenCount","doingTreeDataFiltering","treeDataDepthFirstFilter_1","alreadyFoundInParent","foundInParent","setAllChildrenCountTreeData","allChildrenCount","setAllChildrenCountGridGrouping","isExcludeChildrenWhenTreeDataFiltering","ImmutableService","rowModel","clientSideRowModel","createTransactionForRowData","transaction","existingNodesMap","orderMap","isSuppressMaintainUnsortedOrder","existingNode","undefined","iterateObject","ClientSideRowModelModule","moduleName","beans","rowModels","clientSide","AllCommunityModules"],"mappings":"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","file":"static/js/defaultVendors~main~6662500b.7aa2ae4b.chunk.js","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { _, Autowired, Bean, ChangedPath, Constants as constants, Constants, Events, GridOptionsWrapper, Optional, PostConstruct, RowNode } from \"@ag-grid-community/core\";\nimport { ClientSideNodeManager } from \"./clientSideNodeManager\";\nvar RecursionType;\n(function (RecursionType) {\n    RecursionType[RecursionType[\"Normal\"] = 0] = \"Normal\";\n    RecursionType[RecursionType[\"AfterFilter\"] = 1] = \"AfterFilter\";\n    RecursionType[RecursionType[\"AfterFilterAndSort\"] = 2] = \"AfterFilterAndSort\";\n    RecursionType[RecursionType[\"PivotNodes\"] = 3] = \"PivotNodes\";\n})(RecursionType || (RecursionType = {}));\nvar ClientSideRowModel = /** @class */ (function () {\n    function ClientSideRowModel() {\n    }\n    ClientSideRowModel.prototype.init = function () {\n        var refreshEverythingFunc = this.refreshModel.bind(this, { step: Constants.STEP_EVERYTHING });\n        var refreshEverythingAfterColsChangedFunc = this.refreshModel.bind(this, { step: Constants.STEP_EVERYTHING, afterColumnsChanged: true });\n        this.eventService.addModalPriorityEventListener(Events.EVENT_COLUMN_EVERYTHING_CHANGED, refreshEverythingAfterColsChangedFunc);\n        this.eventService.addModalPriorityEventListener(Events.EVENT_COLUMN_ROW_GROUP_CHANGED, refreshEverythingFunc);\n        this.eventService.addModalPriorityEventListener(Events.EVENT_COLUMN_VALUE_CHANGED, this.onValueChanged.bind(this));\n        this.eventService.addModalPriorityEventListener(Events.EVENT_COLUMN_PIVOT_CHANGED, this.refreshModel.bind(this, { step: Constants.STEP_PIVOT }));\n        this.eventService.addModalPriorityEventListener(Events.EVENT_ROW_GROUP_OPENED, this.onRowGroupOpened.bind(this));\n        this.eventService.addModalPriorityEventListener(Events.EVENT_FILTER_CHANGED, this.onFilterChanged.bind(this));\n        this.eventService.addModalPriorityEventListener(Events.EVENT_SORT_CHANGED, this.onSortChanged.bind(this));\n        this.eventService.addModalPriorityEventListener(Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, refreshEverythingFunc);\n        var refreshMapFunc = this.refreshModel.bind(this, {\n            step: Constants.STEP_MAP,\n            keepRenderedRows: true,\n            animate: true\n        });\n        this.gridOptionsWrapper.addEventListener(GridOptionsWrapper.PROP_GROUP_REMOVE_SINGLE_CHILDREN, refreshMapFunc);\n        this.gridOptionsWrapper.addEventListener(GridOptionsWrapper.PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN, refreshMapFunc);\n        this.rootNode = new RowNode();\n        this.nodeManager = new ClientSideNodeManager(this.rootNode, this.gridOptionsWrapper, this.context, this.eventService, this.columnController, this.gridApi, this.columnApi, this.selectionController);\n        this.context.wireBean(this.rootNode);\n    };\n    ClientSideRowModel.prototype.start = function () {\n        var rowData = this.gridOptionsWrapper.getRowData();\n        if (rowData) {\n            this.setRowData(rowData);\n        }\n    };\n    ClientSideRowModel.prototype.ensureRowHeightsValid = function (startPixel, endPixel, startLimitIndex, endLimitIndex) {\n        var atLeastOneChange;\n        var res = false;\n        // we do this multiple times as changing the row heights can also change the first and last rows,\n        // so the first pass can make lots of rows smaller, which means the second pass we end up changing\n        // more rows.\n        do {\n            atLeastOneChange = false;\n            var rowAtStartPixel = this.getRowIndexAtPixel(startPixel);\n            var rowAtEndPixel = this.getRowIndexAtPixel(endPixel);\n            // keep check to current page if doing pagination\n            var firstRow = Math.max(rowAtStartPixel, startLimitIndex);\n            var lastRow = Math.min(rowAtEndPixel, endLimitIndex);\n            for (var rowIndex = firstRow; rowIndex <= lastRow; rowIndex++) {\n                var rowNode = this.getRow(rowIndex);\n                if (rowNode.rowHeightEstimated) {\n                    var rowHeight = this.gridOptionsWrapper.getRowHeightForNode(rowNode);\n                    rowNode.setRowHeight(rowHeight.height);\n                    atLeastOneChange = true;\n                    res = true;\n                }\n            }\n            if (atLeastOneChange) {\n                this.setRowTops();\n            }\n        } while (atLeastOneChange);\n        return res;\n    };\n    ClientSideRowModel.prototype.setRowTops = function () {\n        var nextRowTop = 0;\n        for (var i = 0; i < this.rowsToDisplay.length; i++) {\n            // we don't estimate if doing fullHeight or autoHeight, as all rows get rendered all the time\n            // with these two layouts.\n            var allowEstimate = this.gridOptionsWrapper.getDomLayout() === Constants.DOM_LAYOUT_NORMAL;\n            var rowNode = this.rowsToDisplay[i];\n            if (_.missing(rowNode.rowHeight)) {\n                var rowHeight = this.gridOptionsWrapper.getRowHeightForNode(rowNode, allowEstimate);\n                rowNode.setRowHeight(rowHeight.height, rowHeight.estimated);\n            }\n            rowNode.setRowTop(nextRowTop);\n            rowNode.setRowIndex(i);\n            nextRowTop += rowNode.rowHeight;\n        }\n    };\n    ClientSideRowModel.prototype.resetRowTops = function (rowNode, changedPath) {\n        rowNode.clearRowTop();\n        if (rowNode.hasChildren()) {\n            if (rowNode.childrenAfterGroup) {\n                // if a changedPath is active, it means we are here because of a transaction update or\n                // a change detection. neither of these impacts the open/closed state of groups. so if\n                // a group is not open this time, it was not open last time. so we know all closed groups\n                // already have their top positions cleared. so there is no need to traverse all the way\n                // when changedPath is active and the rowNode is not expanded.\n                var skipChildren = changedPath.isActive() && !rowNode.expanded;\n                if (!skipChildren) {\n                    for (var i = 0; i < rowNode.childrenAfterGroup.length; i++) {\n                        this.resetRowTops(rowNode.childrenAfterGroup[i], changedPath);\n                    }\n                }\n            }\n            if (rowNode.sibling) {\n                rowNode.sibling.clearRowTop();\n            }\n        }\n        if (rowNode.detailNode) {\n            rowNode.detailNode.clearRowTop();\n        }\n    };\n    // returns false if row was moved, otherwise true\n    ClientSideRowModel.prototype.ensureRowAtPixel = function (rowNode, pixel) {\n        var indexAtPixelNow = this.getRowIndexAtPixel(pixel);\n        var rowNodeAtPixelNow = this.getRow(indexAtPixelNow);\n        if (rowNodeAtPixelNow === rowNode) {\n            return false;\n        }\n        _.removeFromArray(this.rootNode.allLeafChildren, rowNode);\n        _.insertIntoArray(this.rootNode.allLeafChildren, rowNode, indexAtPixelNow);\n        this.refreshModel({\n            step: Constants.STEP_EVERYTHING,\n            keepRenderedRows: true,\n            animate: true,\n            keepEditingRows: true\n        });\n        return true;\n    };\n    ClientSideRowModel.prototype.isLastRowFound = function () {\n        return true;\n    };\n    ClientSideRowModel.prototype.getRowCount = function () {\n        if (this.rowsToDisplay) {\n            return this.rowsToDisplay.length;\n        }\n        else {\n            return 0;\n        }\n    };\n    ClientSideRowModel.prototype.getTopLevelRowCount = function () {\n        var showingRootNode = this.rowsToDisplay && this.rowsToDisplay[0] === this.rootNode;\n        if (showingRootNode) {\n            return 1;\n        }\n        else {\n            return this.rootNode.childrenAfterFilter ? this.rootNode.childrenAfterFilter.length : 0;\n        }\n    };\n    ClientSideRowModel.prototype.getTopLevelRowDisplayedIndex = function (topLevelIndex) {\n        var showingRootNode = this.rowsToDisplay && this.rowsToDisplay[0] === this.rootNode;\n        if (showingRootNode) {\n            return topLevelIndex;\n        }\n        else {\n            var rowNode = this.rootNode.childrenAfterSort[topLevelIndex];\n            if (this.gridOptionsWrapper.isGroupHideOpenParents()) {\n                // if hideOpenParents, and this row open, then this row is now displayed at this index, first child is\n                while (rowNode.expanded && rowNode.childrenAfterSort && rowNode.childrenAfterSort.length > 0) {\n                    rowNode = rowNode.childrenAfterSort[0];\n                }\n            }\n            return rowNode.rowIndex;\n        }\n    };\n    ClientSideRowModel.prototype.getRowBounds = function (index) {\n        if (_.missing(this.rowsToDisplay)) {\n            return null;\n        }\n        var rowNode = this.rowsToDisplay[index];\n        if (rowNode) {\n            return {\n                rowTop: rowNode.rowTop,\n                rowHeight: rowNode.rowHeight\n            };\n        }\n        else {\n            return null;\n        }\n    };\n    ClientSideRowModel.prototype.onRowGroupOpened = function () {\n        var animate = this.gridOptionsWrapper.isAnimateRows();\n        this.refreshModel({ step: Constants.STEP_MAP, keepRenderedRows: true, animate: animate });\n    };\n    ClientSideRowModel.prototype.onFilterChanged = function () {\n        var animate = this.gridOptionsWrapper.isAnimateRows();\n        this.refreshModel({ step: Constants.STEP_FILTER, keepRenderedRows: true, animate: animate });\n    };\n    ClientSideRowModel.prototype.onSortChanged = function () {\n        var animate = this.gridOptionsWrapper.isAnimateRows();\n        this.refreshModel({ step: Constants.STEP_SORT, keepRenderedRows: true, animate: animate, keepEditingRows: true });\n    };\n    ClientSideRowModel.prototype.getType = function () {\n        return Constants.ROW_MODEL_TYPE_CLIENT_SIDE;\n    };\n    ClientSideRowModel.prototype.onValueChanged = function () {\n        if (this.columnController.isPivotActive()) {\n            this.refreshModel({ step: Constants.STEP_PIVOT });\n        }\n        else {\n            this.refreshModel({ step: Constants.STEP_AGGREGATE });\n        }\n    };\n    ClientSideRowModel.prototype.createChangePath = function (rowNodeTransactions) {\n        // for updates, if the row is updated at all, then we re-calc all the values\n        // in that row. we could compare each value to each old value, however if we\n        // did this, we would be calling the valueService twice, once on the old value\n        // and once on the new value. so it's less valueGetter calls if we just assume\n        // each column is different. that way the changedPath is used so that only\n        // the impacted parent rows are recalculated, parents who's children have\n        // not changed are not impacted.\n        var noTransactions = _.missingOrEmpty(rowNodeTransactions);\n        var changedPath = new ChangedPath(false, this.rootNode);\n        if (noTransactions || this.gridOptionsWrapper.isTreeData()) {\n            changedPath.setInactive();\n        }\n        return changedPath;\n    };\n    ClientSideRowModel.prototype.refreshModel = function (params) {\n        // this goes through the pipeline of stages. what's in my head is similar\n        // to the diagram on this page:\n        // http://commons.apache.org/sandbox/commons-pipeline/pipeline_basics.html\n        // however we want to keep the results of each stage, hence we manually call\n        // each step rather than have them chain each other.\n        var _this = this;\n        // fallthrough in below switch is on purpose,\n        // eg if STEP_FILTER, then all steps below this\n        // step get done\n        // let start: number;\n        // console.log('======= start =======');\n        var changedPath = this.createChangePath(params.rowNodeTransactions);\n        switch (params.step) {\n            case constants.STEP_EVERYTHING:\n                // start = new Date().getTime();\n                this.doRowGrouping(params.groupState, params.rowNodeTransactions, params.rowNodeOrder, changedPath, params.afterColumnsChanged);\n            // console.log('rowGrouping = ' + (new Date().getTime() - start));\n            case constants.STEP_FILTER:\n                // start = new Date().getTime();\n                this.doFilter(changedPath);\n            // console.log('filter = ' + (new Date().getTime() - start));\n            case constants.STEP_PIVOT:\n                this.doPivot(changedPath);\n            case constants.STEP_AGGREGATE: // depends on agg fields\n                // start = new Date().getTime();\n                this.doAggregate(changedPath);\n            // console.log('aggregation = ' + (new Date().getTime() - start));\n            case constants.STEP_SORT:\n                // start = new Date().getTime();\n                this.doSort(params.rowNodeTransactions, changedPath);\n            // console.log('sort = ' + (new Date().getTime() - start));\n            case constants.STEP_MAP:\n                // start = new Date().getTime();\n                this.doRowsToDisplay();\n            // console.log('rowsToDisplay = ' + (new Date().getTime() - start));\n        }\n        // set all row tops to null, then set row tops on all visible rows. if we don't\n        // do this, then the algorithm below only sets row tops, old row tops from old rows\n        // will still lie around\n        this.resetRowTops(this.rootNode, changedPath);\n        this.setRowTops();\n        var event = {\n            type: Events.EVENT_MODEL_UPDATED,\n            api: this.gridApi,\n            columnApi: this.columnApi,\n            animate: params.animate,\n            keepRenderedRows: params.keepRenderedRows,\n            newData: params.newData,\n            newPage: false\n        };\n        this.eventService.dispatchEvent(event);\n        if (this.$scope) {\n            window.setTimeout(function () {\n                _this.$scope.$apply();\n            }, 0);\n        }\n    };\n    ClientSideRowModel.prototype.isEmpty = function () {\n        var rowsMissing;\n        var doingLegacyTreeData = _.exists(this.gridOptionsWrapper.getNodeChildDetailsFunc());\n        if (doingLegacyTreeData) {\n            rowsMissing = _.missing(this.rootNode.childrenAfterGroup) || this.rootNode.childrenAfterGroup.length === 0;\n        }\n        else {\n            rowsMissing = _.missing(this.rootNode.allLeafChildren) || this.rootNode.allLeafChildren.length === 0;\n        }\n        var empty = _.missing(this.rootNode) || rowsMissing || !this.columnController.isReady();\n        return empty;\n    };\n    ClientSideRowModel.prototype.isRowsToRender = function () {\n        return _.exists(this.rowsToDisplay) && this.rowsToDisplay.length > 0;\n    };\n    ClientSideRowModel.prototype.getNodesInRangeForSelection = function (firstInRange, lastInRange) {\n        // if lastSelectedNode is missing, we start at the first row\n        var firstRowHit = !lastInRange;\n        var lastRowHit = false;\n        var lastRow;\n        var result = [];\n        var groupsSelectChildren = this.gridOptionsWrapper.isGroupSelectsChildren();\n        this.forEachNodeAfterFilterAndSort(function (rowNode) {\n            var lookingForLastRow = firstRowHit && !lastRowHit;\n            // check if we need to flip the select switch\n            if (!firstRowHit) {\n                if (rowNode === lastInRange || rowNode === firstInRange) {\n                    firstRowHit = true;\n                }\n            }\n            var skipThisGroupNode = rowNode.group && groupsSelectChildren;\n            if (!skipThisGroupNode) {\n                var inRange = firstRowHit && !lastRowHit;\n                var childOfLastRow = rowNode.isParentOfNode(lastRow);\n                if (inRange || childOfLastRow) {\n                    result.push(rowNode);\n                }\n            }\n            if (lookingForLastRow) {\n                if (rowNode === lastInRange || rowNode === firstInRange) {\n                    lastRowHit = true;\n                    if (rowNode === lastInRange) {\n                        lastRow = lastInRange;\n                    }\n                    else {\n                        lastRow = firstInRange;\n                    }\n                }\n            }\n        });\n        return result;\n    };\n    ClientSideRowModel.prototype.setDatasource = function (datasource) {\n        console.error('ag-Grid: should never call setDatasource on clientSideRowController');\n    };\n    ClientSideRowModel.prototype.getTopLevelNodes = function () {\n        return this.rootNode ? this.rootNode.childrenAfterGroup : null;\n    };\n    ClientSideRowModel.prototype.getRootNode = function () {\n        return this.rootNode;\n    };\n    ClientSideRowModel.prototype.getRow = function (index) {\n        return this.rowsToDisplay[index];\n    };\n    ClientSideRowModel.prototype.isRowPresent = function (rowNode) {\n        return this.rowsToDisplay.indexOf(rowNode) >= 0;\n    };\n    ClientSideRowModel.prototype.getRowIndexAtPixel = function (pixelToMatch) {\n        if (this.isEmpty()) {\n            return -1;\n        }\n        // do binary search of tree\n        // http://oli.me.uk/2013/06/08/searching-javascript-arrays-with-a-binary-search/\n        var bottomPointer = 0;\n        var topPointer = this.rowsToDisplay.length - 1;\n        // quick check, if the pixel is out of bounds, then return last row\n        if (pixelToMatch <= 0) {\n            // if pixel is less than or equal zero, it's always the first row\n            return 0;\n        }\n        var lastNode = _.last(this.rowsToDisplay);\n        if (lastNode.rowTop <= pixelToMatch) {\n            return this.rowsToDisplay.length - 1;\n        }\n        while (true) {\n            var midPointer = Math.floor((bottomPointer + topPointer) / 2);\n            var currentRowNode = this.rowsToDisplay[midPointer];\n            if (this.isRowInPixel(currentRowNode, pixelToMatch)) {\n                return midPointer;\n            }\n            else if (currentRowNode.rowTop < pixelToMatch) {\n                bottomPointer = midPointer + 1;\n            }\n            else if (currentRowNode.rowTop > pixelToMatch) {\n                topPointer = midPointer - 1;\n            }\n        }\n    };\n    ClientSideRowModel.prototype.isRowInPixel = function (rowNode, pixelToMatch) {\n        var topPixel = rowNode.rowTop;\n        var bottomPixel = rowNode.rowTop + rowNode.rowHeight;\n        var pixelInRow = topPixel <= pixelToMatch && bottomPixel > pixelToMatch;\n        return pixelInRow;\n    };\n    ClientSideRowModel.prototype.getCurrentPageHeight = function () {\n        if (this.rowsToDisplay && this.rowsToDisplay.length > 0) {\n            var lastRow = _.last(this.rowsToDisplay);\n            var lastPixel = lastRow.rowTop + lastRow.rowHeight;\n            return lastPixel;\n        }\n        else {\n            return 0;\n        }\n    };\n    ClientSideRowModel.prototype.forEachLeafNode = function (callback) {\n        if (this.rootNode.allLeafChildren) {\n            this.rootNode.allLeafChildren.forEach(function (rowNode, index) { return callback(rowNode, index); });\n        }\n    };\n    ClientSideRowModel.prototype.forEachNode = function (callback) {\n        this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterGroup, callback, RecursionType.Normal, 0);\n    };\n    ClientSideRowModel.prototype.forEachNodeAfterFilter = function (callback) {\n        this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterFilter, callback, RecursionType.AfterFilter, 0);\n    };\n    ClientSideRowModel.prototype.forEachNodeAfterFilterAndSort = function (callback) {\n        this.recursivelyWalkNodesAndCallback(this.rootNode.childrenAfterSort, callback, RecursionType.AfterFilterAndSort, 0);\n    };\n    ClientSideRowModel.prototype.forEachPivotNode = function (callback) {\n        this.recursivelyWalkNodesAndCallback([this.rootNode], callback, RecursionType.PivotNodes, 0);\n    };\n    // iterates through each item in memory, and calls the callback function\n    // nodes - the rowNodes to traverse\n    // callback - the user provided callback\n    // recursion type - need this to know what child nodes to recurse, eg if looking at all nodes, or filtered notes etc\n    // index - works similar to the index in forEach in javascript's array function\n    ClientSideRowModel.prototype.recursivelyWalkNodesAndCallback = function (nodes, callback, recursionType, index) {\n        if (nodes) {\n            for (var i = 0; i < nodes.length; i++) {\n                var node = nodes[i];\n                callback(node, index++);\n                // go to the next level if it is a group\n                if (node.hasChildren()) {\n                    // depending on the recursion type, we pick a difference set of children\n                    var nodeChildren = null;\n                    switch (recursionType) {\n                        case RecursionType.Normal:\n                            nodeChildren = node.childrenAfterGroup;\n                            break;\n                        case RecursionType.AfterFilter:\n                            nodeChildren = node.childrenAfterFilter;\n                            break;\n                        case RecursionType.AfterFilterAndSort:\n                            nodeChildren = node.childrenAfterSort;\n                            break;\n                        case RecursionType.PivotNodes:\n                            // for pivot, we don't go below leafGroup levels\n                            nodeChildren = !node.leafGroup ? node.childrenAfterSort : null;\n                            break;\n                    }\n                    if (nodeChildren) {\n                        index = this.recursivelyWalkNodesAndCallback(nodeChildren, callback, recursionType, index);\n                    }\n                }\n            }\n        }\n        return index;\n    };\n    // it's possible to recompute the aggregate without doing the other parts\n    // + gridApi.recomputeAggregates()\n    ClientSideRowModel.prototype.doAggregate = function (changedPath) {\n        if (this.aggregationStage) {\n            this.aggregationStage.execute({ rowNode: this.rootNode, changedPath: changedPath });\n        }\n    };\n    // + gridApi.expandAll()\n    // + gridApi.collapseAll()\n    ClientSideRowModel.prototype.expandOrCollapseAll = function (expand) {\n        var usingTreeData = this.gridOptionsWrapper.isTreeData();\n        if (this.rootNode) {\n            recursiveExpandOrCollapse(this.rootNode.childrenAfterGroup);\n        }\n        function recursiveExpandOrCollapse(rowNodes) {\n            if (!rowNodes) {\n                return;\n            }\n            rowNodes.forEach(function (rowNode) {\n                var shouldExpandOrCollapse = usingTreeData ? _.exists(rowNode.childrenAfterGroup) : rowNode.group;\n                if (shouldExpandOrCollapse) {\n                    rowNode.expanded = expand;\n                    recursiveExpandOrCollapse(rowNode.childrenAfterGroup);\n                }\n            });\n        }\n        this.refreshModel({ step: Constants.STEP_MAP });\n        var eventSource = expand ? 'expandAll' : 'collapseAll';\n        var event = {\n            api: this.gridApi,\n            columnApi: this.columnApi,\n            type: Events.EVENT_EXPAND_COLLAPSE_ALL,\n            source: eventSource\n        };\n        this.eventService.dispatchEvent(event);\n    };\n    ClientSideRowModel.prototype.doSort = function (rowNodeTransactions, changedPath) {\n        this.sortStage.execute({\n            rowNode: this.rootNode,\n            rowNodeTransactions: rowNodeTransactions,\n            changedPath: changedPath\n        });\n    };\n    ClientSideRowModel.prototype.doRowGrouping = function (groupState, rowNodeTransactions, rowNodeOrder, changedPath, afterColumnsChanged) {\n        // grouping is enterprise only, so if service missing, skip the step\n        var doingLegacyTreeData = _.exists(this.gridOptionsWrapper.getNodeChildDetailsFunc());\n        if (doingLegacyTreeData) {\n            return;\n        }\n        if (this.groupStage) {\n            if (rowNodeTransactions) {\n                var merged_1 = {\n                    add: [],\n                    remove: [],\n                    update: []\n                };\n                rowNodeTransactions.forEach(function (tran) {\n                    _.pushAll(merged_1.add, tran.add);\n                    _.pushAll(merged_1.remove, tran.remove);\n                    _.pushAll(merged_1.update, tran.update);\n                });\n                this.groupStage.execute({\n                    rowNode: this.rootNode,\n                    rowNodeTransaction: merged_1,\n                    rowNodeOrder: rowNodeOrder,\n                    changedPath: changedPath\n                });\n            }\n            else {\n                // groups are about to get disposed, so need to deselect any that are selected\n                this.selectionController.removeGroupsFromSelection();\n                this.groupStage.execute({\n                    rowNode: this.rootNode,\n                    changedPath: changedPath,\n                    afterColumnsChanged: afterColumnsChanged\n                });\n                // set open/closed state on groups\n                this.restoreGroupState(groupState);\n            }\n            if (this.gridOptionsWrapper.isGroupSelectsChildren()) {\n                this.selectionController.updateGroupsFromChildrenSelections(changedPath);\n            }\n        }\n        else {\n            this.rootNode.childrenAfterGroup = this.rootNode.allLeafChildren;\n        }\n    };\n    ClientSideRowModel.prototype.restoreGroupState = function (groupState) {\n        if (!groupState) {\n            return;\n        }\n        _.traverseNodesWithKey(this.rootNode.childrenAfterGroup, function (node, key) {\n            // if the group was open last time, then open it this time. however\n            // if was not open last time, then don't touch the group, so the 'groupDefaultExpanded'\n            // setting will take effect.\n            if (typeof groupState[key] === 'boolean') {\n                node.expanded = groupState[key];\n            }\n        });\n    };\n    ClientSideRowModel.prototype.doFilter = function (changedPath) {\n        this.filterStage.execute({ rowNode: this.rootNode, changedPath: changedPath });\n    };\n    ClientSideRowModel.prototype.doPivot = function (changedPath) {\n        if (this.pivotStage) {\n            this.pivotStage.execute({ rowNode: this.rootNode, changedPath: changedPath });\n        }\n    };\n    ClientSideRowModel.prototype.getGroupState = function () {\n        if (!this.rootNode.childrenAfterGroup || !this.gridOptionsWrapper.isRememberGroupStateWhenNewData()) {\n            return null;\n        }\n        var result = {};\n        _.traverseNodesWithKey(this.rootNode.childrenAfterGroup, function (node, key) { return result[key] = node.expanded; });\n        return result;\n    };\n    ClientSideRowModel.prototype.getCopyOfNodesMap = function () {\n        return this.nodeManager.getCopyOfNodesMap();\n    };\n    ClientSideRowModel.prototype.getRowNode = function (id) {\n        return this.nodeManager.getRowNode(id);\n    };\n    // rows: the rows to put into the model\n    ClientSideRowModel.prototype.setRowData = function (rowData) {\n        // no need to invalidate cache, as the cache is stored on the rowNode,\n        // so new rowNodes means the cache is wiped anyway.\n        // remember group state, so we can expand groups that should be expanded\n        var groupState = this.getGroupState();\n        this.nodeManager.setRowData(rowData);\n        // this event kicks off:\n        // - clears selection\n        // - updates filters\n        // - shows 'no rows' overlay if needed\n        var rowDataChangedEvent = {\n            type: Events.EVENT_ROW_DATA_CHANGED,\n            api: this.gridApi,\n            columnApi: this.columnApi\n        };\n        this.eventService.dispatchEvent(rowDataChangedEvent);\n        this.refreshModel({\n            step: Constants.STEP_EVERYTHING,\n            groupState: groupState,\n            newData: true\n        });\n    };\n    ClientSideRowModel.prototype.batchUpdateRowData = function (rowDataTransaction, callback) {\n        var _this = this;\n        if (!this.rowDataTransactionBatch) {\n            this.rowDataTransactionBatch = [];\n            var waitMillis = this.gridOptionsWrapper.getBatchUpdateWaitMillis();\n            window.setTimeout(function () {\n                _this.executeBatchUpdateRowData();\n                _this.rowDataTransactionBatch = null;\n            }, waitMillis);\n        }\n        this.rowDataTransactionBatch.push({ rowDataTransaction: rowDataTransaction, callback: callback });\n    };\n    ClientSideRowModel.prototype.executeBatchUpdateRowData = function () {\n        var _this = this;\n        this.valueCache.onDataChanged();\n        var callbackFuncsBound = [];\n        var rowNodeTrans = [];\n        if (this.rowDataTransactionBatch) {\n            this.rowDataTransactionBatch.forEach(function (tranItem) {\n                var rowNodeTran = _this.nodeManager.updateRowData(tranItem.rowDataTransaction, null);\n                rowNodeTrans.push(rowNodeTran);\n                if (tranItem.callback) {\n                    callbackFuncsBound.push(tranItem.callback.bind(null, rowNodeTran));\n                }\n            });\n        }\n        this.commonUpdateRowData(rowNodeTrans);\n        // do callbacks in next VM turn so it's async\n        if (callbackFuncsBound.length > 0) {\n            window.setTimeout(function () {\n                callbackFuncsBound.forEach(function (func) { return func(); });\n            }, 0);\n        }\n    };\n    ClientSideRowModel.prototype.updateRowData = function (rowDataTran, rowNodeOrder) {\n        this.valueCache.onDataChanged();\n        var rowNodeTran = this.nodeManager.updateRowData(rowDataTran, rowNodeOrder);\n        this.commonUpdateRowData([rowNodeTran], rowNodeOrder);\n        return rowNodeTran;\n    };\n    // common to updateRowData and batchUpdateRowData\n    ClientSideRowModel.prototype.commonUpdateRowData = function (rowNodeTrans, rowNodeOrder) {\n        this.refreshModel({\n            step: Constants.STEP_EVERYTHING,\n            rowNodeTransactions: rowNodeTrans,\n            rowNodeOrder: rowNodeOrder,\n            keepRenderedRows: true,\n            animate: true,\n            keepEditingRows: true\n        });\n        var event = {\n            type: Events.EVENT_ROW_DATA_UPDATED,\n            api: this.gridApi,\n            columnApi: this.columnApi\n        };\n        this.eventService.dispatchEvent(event);\n    };\n    ClientSideRowModel.prototype.doRowsToDisplay = function () {\n        this.rowsToDisplay = this.flattenStage.execute({ rowNode: this.rootNode });\n    };\n    ClientSideRowModel.prototype.onRowHeightChanged = function () {\n        this.refreshModel({ step: Constants.STEP_MAP, keepRenderedRows: true, keepEditingRows: true });\n    };\n    ClientSideRowModel.prototype.resetRowHeights = function () {\n        this.forEachNode(function (rowNode) { return rowNode.setRowHeight(null); });\n        this.onRowHeightChanged();\n    };\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], ClientSideRowModel.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        Autowired('columnController')\n    ], ClientSideRowModel.prototype, \"columnController\", void 0);\n    __decorate([\n        Autowired('filterManager')\n    ], ClientSideRowModel.prototype, \"filterManager\", void 0);\n    __decorate([\n        Autowired('$scope')\n    ], ClientSideRowModel.prototype, \"$scope\", void 0);\n    __decorate([\n        Autowired('selectionController')\n    ], ClientSideRowModel.prototype, \"selectionController\", void 0);\n    __decorate([\n        Autowired('eventService')\n    ], ClientSideRowModel.prototype, \"eventService\", void 0);\n    __decorate([\n        Autowired('context')\n    ], ClientSideRowModel.prototype, \"context\", void 0);\n    __decorate([\n        Autowired('valueService')\n    ], ClientSideRowModel.prototype, \"valueService\", void 0);\n    __decorate([\n        Autowired('valueCache')\n    ], ClientSideRowModel.prototype, \"valueCache\", void 0);\n    __decorate([\n        Autowired('columnApi')\n    ], ClientSideRowModel.prototype, \"columnApi\", void 0);\n    __decorate([\n        Autowired('gridApi')\n    ], ClientSideRowModel.prototype, \"gridApi\", void 0);\n    __decorate([\n        Autowired('filterStage')\n    ], ClientSideRowModel.prototype, \"filterStage\", void 0);\n    __decorate([\n        Autowired('sortStage')\n    ], ClientSideRowModel.prototype, \"sortStage\", void 0);\n    __decorate([\n        Autowired('flattenStage')\n    ], ClientSideRowModel.prototype, \"flattenStage\", void 0);\n    __decorate([\n        Optional('groupStage')\n    ], ClientSideRowModel.prototype, \"groupStage\", void 0);\n    __decorate([\n        Optional('aggregationStage')\n    ], ClientSideRowModel.prototype, \"aggregationStage\", void 0);\n    __decorate([\n        Optional('pivotStage')\n    ], ClientSideRowModel.prototype, \"pivotStage\", void 0);\n    __decorate([\n        PostConstruct\n    ], ClientSideRowModel.prototype, \"init\", null);\n    ClientSideRowModel = __decorate([\n        Bean('rowModel')\n    ], ClientSideRowModel);\n    return ClientSideRowModel;\n}());\nexport { ClientSideRowModel };\n","import { RowNode, Events, _ } from \"@ag-grid-community/core\";\nvar ClientSideNodeManager = /** @class */ (function () {\n    function ClientSideNodeManager(rootNode, gridOptionsWrapper, context, eventService, columnController, gridApi, columnApi, selectionController) {\n        this.nextId = 0;\n        // when user is provide the id's, we also keep a map of ids to row nodes for convenience\n        this.allNodesMap = {};\n        this.rootNode = rootNode;\n        this.gridOptionsWrapper = gridOptionsWrapper;\n        this.context = context;\n        this.eventService = eventService;\n        this.columnController = columnController;\n        this.gridApi = gridApi;\n        this.columnApi = columnApi;\n        this.selectionController = selectionController;\n        this.rootNode.group = true;\n        this.rootNode.level = -1;\n        this.rootNode.id = ClientSideNodeManager.ROOT_NODE_ID;\n        this.rootNode.allLeafChildren = [];\n        this.rootNode.childrenAfterGroup = [];\n        this.rootNode.childrenAfterSort = [];\n        this.rootNode.childrenAfterFilter = [];\n        // if we make this class a bean, then can annotate postConstruct\n        this.postConstruct();\n    }\n    // @PostConstruct - this is not a bean, so postConstruct called by constructor\n    ClientSideNodeManager.prototype.postConstruct = function () {\n        // func below doesn't have 'this' pointer, so need to pull out these bits\n        this.getNodeChildDetails = this.gridOptionsWrapper.getNodeChildDetailsFunc();\n        this.suppressParentsInRowNodes = this.gridOptionsWrapper.isSuppressParentsInRowNodes();\n        this.doesDataFlower = this.gridOptionsWrapper.getDoesDataFlowerFunc();\n        this.isRowMasterFunc = this.gridOptionsWrapper.getIsRowMasterFunc();\n        this.doingLegacyTreeData = _.exists(this.getNodeChildDetails);\n        this.doingMasterDetail = this.gridOptionsWrapper.isMasterDetail();\n        if (this.getNodeChildDetails) {\n            console.warn(\"ag-Grid: the callback nodeChildDetailsFunc() is now deprecated. The new way of doing\\n                                    tree data in ag-Grid was introduced in v14 (released November 2017). In the next\\n                                    major release of ag-Grid we will be dropping support for the old version of\\n                                    tree data. If you are reading this message, please go to the docs to see how\\n                                    to implement Tree Data without using nodeChildDetailsFunc().\");\n        }\n    };\n    ClientSideNodeManager.prototype.getCopyOfNodesMap = function () {\n        var result = _.cloneObject(this.allNodesMap);\n        return result;\n    };\n    ClientSideNodeManager.prototype.getRowNode = function (id) {\n        return this.allNodesMap[id];\n    };\n    ClientSideNodeManager.prototype.setRowData = function (rowData) {\n        this.rootNode.childrenAfterFilter = null;\n        this.rootNode.childrenAfterGroup = null;\n        this.rootNode.childrenAfterSort = null;\n        this.rootNode.childrenMapped = null;\n        this.nextId = 0;\n        this.allNodesMap = {};\n        if (!rowData) {\n            this.rootNode.allLeafChildren = [];\n            this.rootNode.childrenAfterGroup = [];\n            return;\n        }\n        // kick off recursion\n        // we add rootNode as the parent, however if using ag-grid-enterprise, the grouping stage\n        // sets the parent node on each row (even if we are not grouping). so setting parent node\n        // here is for benefit of ag-grid-community users\n        var result = this.recursiveFunction(rowData, this.rootNode, ClientSideNodeManager.TOP_LEVEL);\n        if (this.doingLegacyTreeData) {\n            this.rootNode.childrenAfterGroup = result;\n            this.setLeafChildren(this.rootNode);\n        }\n        else {\n            this.rootNode.allLeafChildren = result;\n        }\n    };\n    ClientSideNodeManager.prototype.updateRowData = function (rowDataTran, rowNodeOrder) {\n        if (this.isLegacyTreeData()) {\n            return null;\n        }\n        var rowNodeTransaction = {\n            remove: [],\n            update: [],\n            add: []\n        };\n        this.executeAdd(rowDataTran, rowNodeTransaction);\n        this.executeRemove(rowDataTran, rowNodeTransaction);\n        this.executeUpdate(rowDataTran, rowNodeTransaction);\n        if (rowNodeOrder) {\n            _.sortRowNodesByOrder(this.rootNode.allLeafChildren, rowNodeOrder);\n        }\n        return rowNodeTransaction;\n    };\n    ClientSideNodeManager.prototype.executeAdd = function (rowDataTran, rowNodeTransaction) {\n        var _this = this;\n        var add = rowDataTran.add, addIndex = rowDataTran.addIndex;\n        if (!add) {\n            return;\n        }\n        var useIndex = typeof addIndex === 'number' && addIndex >= 0;\n        if (useIndex) {\n            // items get inserted in reverse order for index insertion\n            add.reverse().forEach(function (item) {\n                var newRowNode = _this.addRowNode(item, addIndex);\n                rowNodeTransaction.add.push(newRowNode);\n            });\n        }\n        else {\n            add.forEach(function (item) {\n                var newRowNode = _this.addRowNode(item);\n                rowNodeTransaction.add.push(newRowNode);\n            });\n        }\n    };\n    ClientSideNodeManager.prototype.executeRemove = function (rowDataTran, rowNodeTransaction) {\n        var _this = this;\n        var remove = rowDataTran.remove;\n        if (!remove) {\n            return;\n        }\n        var rowIdsRemoved = {};\n        var anyNodesSelected = false;\n        remove.forEach(function (item) {\n            var rowNode = _this.lookupRowNode(item);\n            if (!rowNode) {\n                return;\n            }\n            if (rowNode.isSelected()) {\n                anyNodesSelected = true;\n            }\n            // do delete - setting 'tailingNodeInSequence = true' to ensure EVENT_SELECTION_CHANGED is not raised for\n            // each row node updated, instead it is raised once by the calling code if any selected nodes exist.\n            rowNode.setSelected(false, false, true);\n            // so row renderer knows to fade row out (and not reposition it)\n            rowNode.clearRowTop();\n            // NOTE: were we could remove from allLeaveChildren, however _.removeFromArray() is expensive, especially\n            // if called multiple times (eg deleting lots of rows) and if allLeafChildren is a large list\n            rowIdsRemoved[rowNode.id] = true;\n            // _.removeFromArray(this.rootNode.allLeafChildren, rowNode);\n            delete _this.allNodesMap[rowNode.id];\n            rowNodeTransaction.remove.push(rowNode);\n        });\n        this.rootNode.allLeafChildren = this.rootNode.allLeafChildren.filter(function (rowNode) { return !rowIdsRemoved[rowNode.id]; });\n        if (anyNodesSelected) {\n            this.selectionController.updateGroupsFromChildrenSelections();\n            var event_1 = {\n                type: Events.EVENT_SELECTION_CHANGED,\n                api: this.gridApi,\n                columnApi: this.columnApi\n            };\n            this.eventService.dispatchEvent(event_1);\n        }\n    };\n    ClientSideNodeManager.prototype.executeUpdate = function (rowDataTran, rowNodeTransaction) {\n        var _this = this;\n        var update = rowDataTran.update;\n        if (!update) {\n            return;\n        }\n        update.forEach(function (item) {\n            var rowNode = _this.lookupRowNode(item);\n            if (!rowNode) {\n                return;\n            }\n            rowNode.updateData(item);\n            rowNodeTransaction.update.push(rowNode);\n        });\n    };\n    ClientSideNodeManager.prototype.addRowNode = function (data, index) {\n        var newNode = this.createNode(data, this.rootNode, ClientSideNodeManager.TOP_LEVEL);\n        if (_.exists(index)) {\n            _.insertIntoArray(this.rootNode.allLeafChildren, newNode, index);\n        }\n        else {\n            this.rootNode.allLeafChildren.push(newNode);\n        }\n        return newNode;\n    };\n    ClientSideNodeManager.prototype.lookupRowNode = function (data) {\n        var rowNodeIdFunc = this.gridOptionsWrapper.getRowNodeIdFunc();\n        var rowNode;\n        if (_.exists(rowNodeIdFunc)) {\n            // find rowNode using id\n            var id = rowNodeIdFunc(data);\n            rowNode = this.allNodesMap[id];\n            if (!rowNode) {\n                console.error(\"ag-Grid: could not find row id=\" + id + \", data item was not found for this id\");\n                return null;\n            }\n        }\n        else {\n            // find rowNode using object references\n            rowNode = _.find(this.rootNode.allLeafChildren, function (rowNode) { return rowNode.data === data; });\n            if (!rowNode) {\n                console.error(\"ag-Grid: could not find data item as object was not found\", data);\n                return null;\n            }\n        }\n        return rowNode;\n    };\n    ClientSideNodeManager.prototype.recursiveFunction = function (rowData, parent, level) {\n        var _this = this;\n        // make sure the rowData is an array and not a string of json - this was a commonly reported problem on the forum\n        if (typeof rowData === 'string') {\n            console.warn('ag-Grid: rowData must be an array, however you passed in a string. If you are loading JSON, make sure you convert the JSON string to JavaScript objects first');\n            return;\n        }\n        var rowNodes = [];\n        rowData.forEach(function (dataItem) {\n            var node = _this.createNode(dataItem, parent, level);\n            rowNodes.push(node);\n        });\n        return rowNodes;\n    };\n    ClientSideNodeManager.prototype.createNode = function (dataItem, parent, level) {\n        var node = new RowNode();\n        this.context.wireBean(node);\n        var doingTreeData = this.gridOptionsWrapper.isTreeData();\n        var doingLegacyTreeData = !doingTreeData && _.exists(this.getNodeChildDetails);\n        var nodeChildDetails = doingLegacyTreeData ? this.getNodeChildDetails(dataItem) : null;\n        if (nodeChildDetails && nodeChildDetails.group) {\n            node.group = true;\n            node.childrenAfterGroup = this.recursiveFunction(nodeChildDetails.children, node, level + 1);\n            node.expanded = nodeChildDetails.expanded === true;\n            node.field = nodeChildDetails.field;\n            node.key = nodeChildDetails.key;\n            /** @deprecated is now 'master' */\n            node.canFlower = node.master;\n            // pull out all the leaf children and add to our node\n            this.setLeafChildren(node);\n        }\n        else {\n            node.group = false;\n            if (doingTreeData) {\n                node.master = false;\n                node.expanded = false;\n            }\n            else {\n                // this is the default, for when doing grid data\n                if (this.doesDataFlower) {\n                    node.master = this.doesDataFlower(dataItem);\n                }\n                else if (this.doingMasterDetail) {\n                    // if we are doing master detail, then the\n                    // default is that everything can flower.\n                    if (this.isRowMasterFunc) {\n                        node.master = this.isRowMasterFunc(dataItem);\n                    }\n                    else {\n                        node.master = true;\n                    }\n                }\n                else {\n                    node.master = false;\n                }\n                var rowGroupColumns = this.columnController.getRowGroupColumns();\n                var numRowGroupColumns = rowGroupColumns ? rowGroupColumns.length : 0;\n                // need to take row group into account when determining level\n                var masterRowLevel = level + numRowGroupColumns;\n                node.expanded = node.master ? this.isExpanded(masterRowLevel) : false;\n            }\n        }\n        // support for backwards compatibility, canFlow is now called 'master'\n        node.canFlower = node.master;\n        if (parent && !this.suppressParentsInRowNodes) {\n            node.parent = parent;\n        }\n        node.level = level;\n        node.setDataAndId(dataItem, this.nextId.toString());\n        if (this.allNodesMap[node.id]) {\n            console.warn(\"ag-grid: duplicate node id '\" + node.id + \"' detected from getRowNodeId callback, this could cause issues in your grid.\");\n        }\n        this.allNodesMap[node.id] = node;\n        this.nextId++;\n        return node;\n    };\n    ClientSideNodeManager.prototype.isExpanded = function (level) {\n        var expandByDefault = this.gridOptionsWrapper.getGroupDefaultExpanded();\n        if (expandByDefault === -1) {\n            return true;\n        }\n        else {\n            return level < expandByDefault;\n        }\n    };\n    // this is only used for doing legacy tree data\n    ClientSideNodeManager.prototype.setLeafChildren = function (node) {\n        node.allLeafChildren = [];\n        if (node.childrenAfterGroup) {\n            node.childrenAfterGroup.forEach(function (childAfterGroup) {\n                if (childAfterGroup.group) {\n                    if (childAfterGroup.allLeafChildren) {\n                        childAfterGroup.allLeafChildren.forEach(function (leafChild) { return node.allLeafChildren.push(leafChild); });\n                    }\n                }\n                else {\n                    node.allLeafChildren.push(childAfterGroup);\n                }\n            });\n        }\n    };\n    ClientSideNodeManager.prototype.isLegacyTreeData = function () {\n        var rowsAlreadyGrouped = _.exists(this.gridOptionsWrapper.getNodeChildDetailsFunc());\n        if (rowsAlreadyGrouped) {\n            console.warn('ag-Grid: adding and removing rows is not supported when using nodeChildDetailsFunc, ie it is not ' +\n                'supported for legacy tree data. Please see the docs on the new preferred way of providing tree data that works with delta updates.');\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    ClientSideNodeManager.TOP_LEVEL = 0;\n    ClientSideNodeManager.ROOT_NODE_ID = 'ROOT_NODE_ID';\n    return ClientSideNodeManager;\n}());\nexport { ClientSideNodeManager };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { Autowired, Bean } from \"@ag-grid-community/core\";\nvar FilterStage = /** @class */ (function () {\n    function FilterStage() {\n    }\n    FilterStage.prototype.execute = function (params) {\n        var rowNode = params.rowNode, changedPath = params.changedPath;\n        this.filterService.filter(changedPath);\n        this.selectableService.updateSelectableAfterFiltering(rowNode);\n    };\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], FilterStage.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        Autowired('selectableService')\n    ], FilterStage.prototype, \"selectableService\", void 0);\n    __decorate([\n        Autowired('filterService')\n    ], FilterStage.prototype, \"filterService\", void 0);\n    FilterStage = __decorate([\n        Bean('filterStage')\n    ], FilterStage);\n    return FilterStage;\n}());\nexport { FilterStage };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { _, Autowired, Bean } from \"@ag-grid-community/core\";\nvar SortStage = /** @class */ (function () {\n    function SortStage() {\n    }\n    SortStage.prototype.execute = function (params) {\n        var sortOptions = this.sortController.getSortForRowController();\n        var sortActive = _.exists(sortOptions) && sortOptions.length > 0;\n        var deltaSort = sortActive\n            && _.exists(params.rowNodeTransactions)\n            // in time we can remove this check, so that delta sort is always\n            // on if transactions are present. it's off for now so that we can\n            // selectively turn it on and test it with some select users before\n            // rolling out to everyone.\n            && this.gridOptionsWrapper.isDeltaSort();\n        // we only need dirty nodes if doing delta sort\n        var dirtyLeafNodes = deltaSort ? this.calculateDirtyNodes(params.rowNodeTransactions) : null;\n        var valueColumns = this.columnController.getValueColumns();\n        var noAggregations = _.missingOrEmpty(valueColumns);\n        this.sortService.sort(sortOptions, sortActive, deltaSort, dirtyLeafNodes, params.changedPath, noAggregations);\n    };\n    SortStage.prototype.calculateDirtyNodes = function (rowNodeTransactions) {\n        var dirtyNodes = {};\n        var addNodesFunc = function (rowNodes) {\n            if (rowNodes) {\n                rowNodes.forEach(function (rowNode) { return dirtyNodes[rowNode.id] = true; });\n            }\n        };\n        // all leaf level nodes in the transaction were impacted\n        rowNodeTransactions.forEach(function (tran) {\n            addNodesFunc(tran.add);\n            addNodesFunc(tran.update);\n            addNodesFunc(tran.remove);\n        });\n        return dirtyNodes;\n    };\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], SortStage.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        Autowired('sortService')\n    ], SortStage.prototype, \"sortService\", void 0);\n    __decorate([\n        Autowired('sortController')\n    ], SortStage.prototype, \"sortController\", void 0);\n    __decorate([\n        Autowired('columnController')\n    ], SortStage.prototype, \"columnController\", void 0);\n    SortStage = __decorate([\n        Bean('sortStage')\n    ], SortStage);\n    return SortStage;\n}());\nexport { SortStage };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { _, Autowired, Bean, RowNode } from \"@ag-grid-community/core\";\nvar FlattenStage = /** @class */ (function () {\n    function FlattenStage() {\n    }\n    FlattenStage.prototype.execute = function (params) {\n        var rootNode = params.rowNode;\n        // even if not doing grouping, we do the mapping, as the client might\n        // of passed in data that already has a grouping in it somewhere\n        var result = [];\n        // putting value into a wrapper so it's passed by reference\n        var nextRowTop = { value: 0 };\n        var skipLeafNodes = this.columnController.isPivotMode();\n        // if we are reducing, and not grouping, then we want to show the root node, as that\n        // is where the pivot values are\n        var showRootNode = skipLeafNodes && rootNode.leafGroup;\n        var topList = showRootNode ? [rootNode] : rootNode.childrenAfterSort;\n        this.recursivelyAddToRowsToDisplay(topList, result, nextRowTop, skipLeafNodes, 0);\n        // we do not want the footer total if the gris is empty\n        var atLeastOneRowPresent = result.length > 0;\n        var includeGroupTotalFooter = !showRootNode\n            // don't show total footer when showRootNode is true (i.e. in pivot mode and no groups)\n            && atLeastOneRowPresent\n            && this.gridOptionsWrapper.isGroupIncludeTotalFooter();\n        if (includeGroupTotalFooter) {\n            this.ensureFooterNodeExists(rootNode);\n            this.addRowNodeToRowsToDisplay(rootNode.sibling, result, nextRowTop, 0);\n        }\n        return result;\n    };\n    FlattenStage.prototype.recursivelyAddToRowsToDisplay = function (rowsToFlatten, result, nextRowTop, skipLeafNodes, uiLevel) {\n        if (_.missingOrEmpty(rowsToFlatten)) {\n            return;\n        }\n        var groupSuppressRow = this.gridOptionsWrapper.isGroupSuppressRow();\n        var hideOpenParents = this.gridOptionsWrapper.isGroupHideOpenParents();\n        // these two are mutually exclusive, so if first set, we don't set the second\n        var groupRemoveSingleChildren = this.gridOptionsWrapper.isGroupRemoveSingleChildren();\n        var groupRemoveLowestSingleChildren = !groupRemoveSingleChildren && this.gridOptionsWrapper.isGroupRemoveLowestSingleChildren();\n        for (var i = 0; i < rowsToFlatten.length; i++) {\n            var rowNode = rowsToFlatten[i];\n            // check all these cases, for working out if this row should be included in the final mapped list\n            var isParent = rowNode.hasChildren();\n            var isGroupSuppressedNode = groupSuppressRow && isParent;\n            var isSkippedLeafNode = skipLeafNodes && !isParent;\n            var isRemovedSingleChildrenGroup = groupRemoveSingleChildren && isParent && rowNode.childrenAfterGroup.length === 1;\n            var isRemovedLowestSingleChildrenGroup = groupRemoveLowestSingleChildren && isParent && rowNode.leafGroup && rowNode.childrenAfterGroup.length === 1;\n            // hide open parents means when group is open, we don't show it. we also need to make sure the\n            // group is expandable in the first place (as leaf groups are not expandable if pivot mode is on).\n            // the UI will never allow expanding leaf  groups, however the user might via the API (or menu option 'expand all')\n            var neverAllowToExpand = skipLeafNodes && rowNode.leafGroup;\n            var isHiddenOpenParent = hideOpenParents && rowNode.expanded && (!neverAllowToExpand);\n            var thisRowShouldBeRendered = !isSkippedLeafNode && !isGroupSuppressedNode && !isHiddenOpenParent && !isRemovedSingleChildrenGroup && !isRemovedLowestSingleChildrenGroup;\n            if (thisRowShouldBeRendered) {\n                this.addRowNodeToRowsToDisplay(rowNode, result, nextRowTop, uiLevel);\n            }\n            // if we are pivoting, we never map below the leaf group\n            if (skipLeafNodes && rowNode.leafGroup) {\n                continue;\n            }\n            if (isParent) {\n                var excludedParent = isRemovedSingleChildrenGroup || isRemovedLowestSingleChildrenGroup;\n                // we traverse the group if it is expended, however we always traverse if the parent node\n                // was removed (as the group will never be opened if it is not displayed, we show the children instead)\n                if (rowNode.expanded || excludedParent) {\n                    // if the parent was excluded, then ui level is that of the parent\n                    var uiLevelForChildren = excludedParent ? uiLevel : uiLevel + 1;\n                    this.recursivelyAddToRowsToDisplay(rowNode.childrenAfterSort, result, nextRowTop, skipLeafNodes, uiLevelForChildren);\n                    // put a footer in if user is looking for it\n                    if (this.gridOptionsWrapper.isGroupIncludeFooter()) {\n                        this.ensureFooterNodeExists(rowNode);\n                        this.addRowNodeToRowsToDisplay(rowNode.sibling, result, nextRowTop, uiLevel);\n                    }\n                }\n            }\n            else if (rowNode.master && rowNode.expanded) {\n                var detailNode = this.createDetailNode(rowNode);\n                this.addRowNodeToRowsToDisplay(detailNode, result, nextRowTop, uiLevel);\n            }\n        }\n    };\n    // duplicated method, it's also in floatingRowModel\n    FlattenStage.prototype.addRowNodeToRowsToDisplay = function (rowNode, result, nextRowTop, uiLevel) {\n        result.push(rowNode);\n        var isGroupMultiAutoColumn = this.gridOptionsWrapper.isGroupMultiAutoColumn();\n        rowNode.setUiLevel(isGroupMultiAutoColumn ? 0 : uiLevel);\n    };\n    FlattenStage.prototype.ensureFooterNodeExists = function (groupNode) {\n        // only create footer node once, otherwise we have daemons and\n        // the animate screws up with the daemons hanging around\n        if (_.exists(groupNode.sibling)) {\n            return;\n        }\n        var footerNode = new RowNode();\n        this.context.wireBean(footerNode);\n        Object.keys(groupNode).forEach(function (key) {\n            footerNode[key] = groupNode[key];\n        });\n        footerNode.footer = true;\n        footerNode.rowTop = null;\n        footerNode.oldRowTop = null;\n        if (_.exists(footerNode.id)) {\n            footerNode.id = 'rowGroupFooter_' + footerNode.id;\n        }\n        // get both header and footer to reference each other as siblings. this is never undone,\n        // only overwritten. so if a group is expanded, then contracted, it will have a ghost\n        // sibling - but that's fine, as we can ignore this if the header is contracted.\n        footerNode.sibling = groupNode;\n        groupNode.sibling = footerNode;\n    };\n    FlattenStage.prototype.createDetailNode = function (masterNode) {\n        if (_.exists(masterNode.detailNode)) {\n            return masterNode.detailNode;\n        }\n        else {\n            var detailNode = new RowNode();\n            this.context.wireBean(detailNode);\n            detailNode.detail = true;\n            detailNode.selectable = false;\n            // flower was renamed to 'detail', but keeping for backwards compatibility\n            detailNode.flower = detailNode.detail;\n            detailNode.parent = masterNode;\n            if (_.exists(masterNode.id)) {\n                detailNode.id = 'detail_' + masterNode.id;\n            }\n            detailNode.data = masterNode.data;\n            detailNode.level = masterNode.level + 1;\n            masterNode.detailNode = detailNode;\n            masterNode.childFlower = masterNode.detailNode; // for backwards compatibility\n            return detailNode;\n        }\n    };\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], FlattenStage.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        Autowired('selectionController')\n    ], FlattenStage.prototype, \"selectionController\", void 0);\n    __decorate([\n        Autowired('eventService')\n    ], FlattenStage.prototype, \"eventService\", void 0);\n    __decorate([\n        Autowired('context')\n    ], FlattenStage.prototype, \"context\", void 0);\n    __decorate([\n        Autowired('columnController')\n    ], FlattenStage.prototype, \"columnController\", void 0);\n    FlattenStage = __decorate([\n        Bean('flattenStage')\n    ], FlattenStage);\n    return FlattenStage;\n}());\nexport { FlattenStage };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { _, Autowired, Bean, PostConstruct } from \"@ag-grid-community/core\";\nvar SortService = /** @class */ (function () {\n    function SortService() {\n    }\n    SortService.prototype.init = function () {\n        this.postSortFunc = this.gridOptionsWrapper.getPostSortFunc();\n    };\n    SortService.prototype.sort = function (sortOptions, sortActive, deltaSort, dirtyLeafNodes, changedPath, noAggregations) {\n        var _this = this;\n        var callback = function (rowNode) {\n            // we clear out the 'pull down open parents' first, as the values mix up the sorting\n            _this.pullDownGroupDataForHideOpenParents(rowNode.childrenAfterFilter, true);\n            // Javascript sort is non deterministic when all the array items are equals, ie Comparator always returns 0,\n            // so to ensure the array keeps its order, add an additional sorting condition manually, in this case we\n            // are going to inspect the original array position. This is what sortedRowNodes is for.\n            if (sortActive) {\n                var sortedRowNodes = deltaSort ?\n                    _this.doDeltaSort(rowNode, sortOptions, dirtyLeafNodes, changedPath, noAggregations)\n                    : _this.doFullSort(rowNode, sortOptions);\n                rowNode.childrenAfterSort = sortedRowNodes.map(function (sorted) { return sorted.rowNode; });\n            }\n            else {\n                rowNode.childrenAfterSort = rowNode.childrenAfterFilter.slice(0);\n            }\n            _this.updateChildIndexes(rowNode);\n            if (_this.postSortFunc) {\n                _this.postSortFunc(rowNode.childrenAfterSort);\n            }\n        };\n        changedPath.forEachChangedNodeDepthFirst(callback);\n        this.updateGroupDataForHiddenOpenParents(changedPath);\n    };\n    SortService.prototype.doFullSort = function (rowNode, sortOptions) {\n        var sortedRowNodes = rowNode.childrenAfterFilter\n            .map(this.mapNodeToSortedNode.bind(this));\n        sortedRowNodes.sort(this.compareRowNodes.bind(this, sortOptions));\n        return sortedRowNodes;\n    };\n    SortService.prototype.mapNodeToSortedNode = function (rowNode, pos) {\n        return { currentPos: pos, rowNode: rowNode };\n    };\n    SortService.prototype.doDeltaSort = function (rowNode, sortOptions, dirtyLeafNodes, changedPath, noAggregations) {\n        // clean nodes will be a list of all row nodes that remain in the set\n        // and ordered. we start with the old sorted set and take out any nodes\n        // that were removed or changed (but not added, added doesn't make sense,\n        // if a node was added, there is no way it could be here from last time).\n        var cleanNodes = rowNode.childrenAfterSort\n            .filter(function (rowNode) {\n            // take out all nodes that were changed as part of the current transaction.\n            // a changed node could a) be in a different sort position or b) may\n            // no longer be in this set as the changed node may not pass filtering,\n            // or be in a different group.\n            var passesDirtyNodesCheck = !dirtyLeafNodes[rowNode.id];\n            // also remove group nodes in the changed path, as they can have different aggregate\n            // values which could impact the sort order.\n            // note: changed path is not active if a) no value columns or b) no transactions. it is never\n            // (b) in deltaSort as we only do deltaSort for transactions. for (a) if no value columns, then\n            // there is no value in the group that could of changed (ie no aggregate values)\n            var passesChangedPathCheck = noAggregations || changedPath.canSkip(rowNode);\n            return passesDirtyNodesCheck && passesChangedPathCheck;\n        })\n            .map(this.mapNodeToSortedNode.bind(this));\n        // for fast access below, we map them\n        var cleanNodesMapped = {};\n        cleanNodes.forEach(function (sortedRowNode) { return cleanNodesMapped[sortedRowNode.rowNode.id] = sortedRowNode.rowNode; });\n        // these are all nodes that need to be placed\n        var changedNodes = rowNode.childrenAfterFilter\n            // ignore nodes in the clean list\n            .filter(function (rowNode) { return !cleanNodesMapped[rowNode.id]; })\n            .map(this.mapNodeToSortedNode.bind(this));\n        // sort changed nodes. note that we don't need to sort cleanNodes as they are\n        // already sorted from last time.\n        changedNodes.sort(this.compareRowNodes.bind(this, sortOptions));\n        if (changedNodes.length === 0) {\n            return cleanNodes;\n        }\n        else if (cleanNodes.length === 0) {\n            return changedNodes;\n        }\n        else {\n            return this.mergeSortedArrays(sortOptions, cleanNodes, changedNodes);\n        }\n    };\n    // Merge two sorted arrays into each other\n    SortService.prototype.mergeSortedArrays = function (sortOptions, arr1, arr2) {\n        var res = [];\n        var i = 0;\n        var j = 0;\n        // Traverse both array, adding them in order\n        while (i < arr1.length && j < arr2.length) {\n            // Check if current element of first\n            // array is smaller than current element\n            // of second array. If yes, store first\n            // array element and increment first array\n            // index. Otherwise do same with second array\n            var compareResult = this.compareRowNodes(sortOptions, arr1[i], arr2[j]);\n            if (compareResult < 0) {\n                res.push(arr1[i++]);\n            }\n            else {\n                res.push(arr2[j++]);\n            }\n        }\n        // add remaining from arr1\n        while (i < arr1.length) {\n            res.push(arr1[i++]);\n        }\n        // add remaining from arr2\n        while (j < arr2.length) {\n            res.push(arr2[j++]);\n        }\n        return res;\n    };\n    SortService.prototype.compareRowNodes = function (sortOptions, sortedNodeA, sortedNodeB) {\n        var nodeA = sortedNodeA.rowNode;\n        var nodeB = sortedNodeB.rowNode;\n        // Iterate columns, return the first that doesn't match\n        for (var i = 0, len = sortOptions.length; i < len; i++) {\n            var sortOption = sortOptions[i];\n            // let compared = compare(nodeA, nodeB, sortOption.column, sortOption.inverter === -1);\n            var isInverted = sortOption.inverter === -1;\n            var valueA = this.getValue(nodeA, sortOption.column);\n            var valueB = this.getValue(nodeB, sortOption.column);\n            var comparatorResult = void 0;\n            if (sortOption.column.getColDef().comparator) {\n                //if comparator provided, use it\n                comparatorResult = sortOption.column.getColDef().comparator(valueA, valueB, nodeA, nodeB, isInverted);\n            }\n            else {\n                //otherwise do our own comparison\n                comparatorResult = _.defaultComparator(valueA, valueB, this.gridOptionsWrapper.isAccentedSort());\n            }\n            if (comparatorResult !== 0) {\n                return comparatorResult * sortOption.inverter;\n            }\n        }\n        // All matched, we make is so that the original sort order is kept:\n        return sortedNodeA.currentPos - sortedNodeB.currentPos;\n    };\n    SortService.prototype.getValue = function (nodeA, column) {\n        return this.valueService.getValue(column, nodeA);\n    };\n    SortService.prototype.updateChildIndexes = function (rowNode) {\n        if (_.missing(rowNode.childrenAfterSort)) {\n            return;\n        }\n        var listToSort = rowNode.childrenAfterSort;\n        for (var i = 0; i < listToSort.length; i++) {\n            var child = listToSort[i];\n            var firstChild = i === 0;\n            var lastChild = i === rowNode.childrenAfterSort.length - 1;\n            child.setFirstChild(firstChild);\n            child.setLastChild(lastChild);\n            child.setChildIndex(i);\n        }\n    };\n    SortService.prototype.updateGroupDataForHiddenOpenParents = function (changedPath) {\n        var _this = this;\n        if (!this.gridOptionsWrapper.isGroupHideOpenParents()) {\n            return;\n        }\n        // recurse breadth first over group nodes after sort to 'pull down' group data to child groups\n        var callback = function (rowNode) {\n            _this.pullDownGroupDataForHideOpenParents(rowNode.childrenAfterSort, false);\n            rowNode.childrenAfterSort.forEach(function (child) {\n                if (child.hasChildren()) {\n                    callback(child);\n                }\n            });\n        };\n        changedPath.executeFromRootNode(function (rowNode) { return callback(rowNode); });\n    };\n    SortService.prototype.pullDownGroupDataForHideOpenParents = function (rowNodes, clearOperation) {\n        var _this = this;\n        if (_.missing(rowNodes)) {\n            return;\n        }\n        if (!this.gridOptionsWrapper.isGroupHideOpenParents()) {\n            return;\n        }\n        rowNodes.forEach(function (childRowNode) {\n            var groupDisplayCols = _this.columnController.getGroupDisplayColumns();\n            groupDisplayCols.forEach(function (groupDisplayCol) {\n                var showRowGroup = groupDisplayCol.getColDef().showRowGroup;\n                if (typeof showRowGroup !== 'string') {\n                    console.error('ag-Grid: groupHideOpenParents only works when specifying specific columns for colDef.showRowGroup');\n                    return;\n                }\n                var displayingGroupKey = showRowGroup;\n                var rowGroupColumn = _this.columnController.getPrimaryColumn(displayingGroupKey);\n                var thisRowNodeMatches = rowGroupColumn === childRowNode.rowGroupColumn;\n                if (thisRowNodeMatches) {\n                    return;\n                }\n                if (clearOperation) {\n                    // if doing a clear operation, we clear down the value for every possible group column\n                    childRowNode.setGroupValue(groupDisplayCol.getId(), null);\n                }\n                else {\n                    // if doing a set operation, we set only where the pull down is to occur\n                    var parentToStealFrom = childRowNode.getFirstChildOfFirstChild(rowGroupColumn);\n                    if (parentToStealFrom) {\n                        childRowNode.setGroupValue(groupDisplayCol.getId(), parentToStealFrom.key);\n                    }\n                }\n            });\n        });\n    };\n    __decorate([\n        Autowired('sortController')\n    ], SortService.prototype, \"sortController\", void 0);\n    __decorate([\n        Autowired('columnController')\n    ], SortService.prototype, \"columnController\", void 0);\n    __decorate([\n        Autowired('valueService')\n    ], SortService.prototype, \"valueService\", void 0);\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], SortService.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        PostConstruct\n    ], SortService.prototype, \"init\", null);\n    SortService = __decorate([\n        Bean('sortService')\n    ], SortService);\n    return SortService;\n}());\nexport { SortService };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { Autowired, Bean, PostConstruct } from \"@ag-grid-community/core\";\nvar FilterService = /** @class */ (function () {\n    function FilterService() {\n    }\n    FilterService.prototype.postConstruct = function () {\n        this.doingTreeData = this.gridOptionsWrapper.isTreeData();\n    };\n    FilterService.prototype.filter = function (changedPath) {\n        var filterActive = this.filterManager.isAnyFilterPresent();\n        this.filterNodes(filterActive, changedPath);\n    };\n    FilterService.prototype.filterNodes = function (filterActive, changedPath) {\n        var _this = this;\n        var filterCallback = function (rowNode, includeChildNodes) {\n            // recursively get all children that are groups to also filter\n            if (rowNode.hasChildren()) {\n                // result of filter for this node. when filtering tree data, includeChildNodes = true when parent passes\n                if (filterActive && !includeChildNodes) {\n                    rowNode.childrenAfterFilter = rowNode.childrenAfterGroup.filter(function (childNode) {\n                        // a group is included in the result if it has any children of it's own.\n                        // by this stage, the child groups are already filtered\n                        var passBecauseChildren = childNode.childrenAfterFilter && childNode.childrenAfterFilter.length > 0;\n                        // both leaf level nodes and tree data nodes have data. these get added if\n                        // the data passes the filter\n                        var passBecauseDataPasses = childNode.data && _this.filterManager.doesRowPassFilter(childNode);\n                        // note - tree data nodes pass either if a) they pass themselves or b) any children of that node pass\n                        return passBecauseChildren || passBecauseDataPasses;\n                    });\n                }\n                else {\n                    // if not filtering, the result is the original list\n                    rowNode.childrenAfterFilter = rowNode.childrenAfterGroup;\n                }\n                _this.setAllChildrenCount(rowNode);\n            }\n            else {\n                rowNode.childrenAfterFilter = rowNode.childrenAfterGroup;\n                rowNode.setAllChildrenCount(null);\n            }\n        };\n        if (this.doingTreeDataFiltering()) {\n            var treeDataDepthFirstFilter_1 = function (rowNode, alreadyFoundInParent) {\n                // tree data filter traverses the hierarchy depth first and includes child nodes if parent passes\n                // filter, and parent nodes will be include if any children exist.\n                if (rowNode.childrenAfterGroup) {\n                    for (var i = 0; i < rowNode.childrenAfterGroup.length; i++) {\n                        var childNode = rowNode.childrenAfterGroup[i];\n                        // first check if current node passes filter before invoking child nodes\n                        var foundInParent = alreadyFoundInParent || _this.filterManager.doesRowPassFilter(childNode);\n                        if (childNode.childrenAfterGroup) {\n                            treeDataDepthFirstFilter_1(rowNode.childrenAfterGroup[i], foundInParent);\n                        }\n                        else {\n                            filterCallback(childNode, foundInParent);\n                        }\n                    }\n                }\n                filterCallback(rowNode, alreadyFoundInParent);\n            };\n            var treeDataFilterCallback = function (rowNode) { return treeDataDepthFirstFilter_1(rowNode, false); };\n            changedPath.executeFromRootNode(treeDataFilterCallback);\n        }\n        else {\n            var defaultFilterCallback = function (rowNode) { return filterCallback(rowNode, false); };\n            changedPath.forEachChangedNodeDepthFirst(defaultFilterCallback, true);\n        }\n    };\n    FilterService.prototype.setAllChildrenCountTreeData = function (rowNode) {\n        // for tree data, we include all children, groups and leafs\n        var allChildrenCount = 0;\n        rowNode.childrenAfterFilter.forEach(function (child) {\n            // include child itself\n            allChildrenCount++;\n            // include children of children\n            allChildrenCount += child.allChildrenCount;\n        });\n        rowNode.setAllChildrenCount(allChildrenCount);\n    };\n    FilterService.prototype.setAllChildrenCountGridGrouping = function (rowNode) {\n        // for grid data, we only count the leafs\n        var allChildrenCount = 0;\n        rowNode.childrenAfterFilter.forEach(function (child) {\n            if (child.group) {\n                allChildrenCount += child.allChildrenCount;\n            }\n            else {\n                allChildrenCount++;\n            }\n        });\n        rowNode.setAllChildrenCount(allChildrenCount);\n    };\n    FilterService.prototype.setAllChildrenCount = function (rowNode) {\n        if (this.doingTreeData) {\n            this.setAllChildrenCountTreeData(rowNode);\n        }\n        else {\n            this.setAllChildrenCountGridGrouping(rowNode);\n        }\n    };\n    FilterService.prototype.doingTreeDataFiltering = function () {\n        return this.gridOptionsWrapper.isTreeData() && !this.gridOptionsWrapper.isExcludeChildrenWhenTreeDataFiltering();\n    };\n    __decorate([\n        Autowired('filterManager')\n    ], FilterService.prototype, \"filterManager\", void 0);\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], FilterService.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        PostConstruct\n    ], FilterService.prototype, \"postConstruct\", null);\n    FilterService = __decorate([\n        Bean(\"filterService\")\n    ], FilterService);\n    return FilterService;\n}());\nexport { FilterService };\n","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { _, Autowired, Bean, Constants, PostConstruct } from \"@ag-grid-community/core\";\nvar ImmutableService = /** @class */ (function () {\n    function ImmutableService() {\n    }\n    ImmutableService.prototype.postConstruct = function () {\n        if (this.rowModel.getType() === Constants.ROW_MODEL_TYPE_CLIENT_SIDE) {\n            this.clientSideRowModel = this.rowModel;\n        }\n    };\n    // converts the setRowData() command to a transaction\n    ImmutableService.prototype.createTransactionForRowData = function (data) {\n        if (_.missing(this.clientSideRowModel)) {\n            console.error('ag-Grid: ImmutableService only works with ClientSideRowModel');\n            return;\n        }\n        var getRowNodeIdFunc = this.gridOptionsWrapper.getRowNodeIdFunc();\n        if (!getRowNodeIdFunc || _.missing(getRowNodeIdFunc)) {\n            console.error('ag-Grid: ImmutableService requires getRowNodeId() callback to be implemented, your row data need IDs!');\n            return;\n        }\n        // convert the data into a transaction object by working out adds, removes and updates\n        var transaction = {\n            remove: [],\n            update: [],\n            add: []\n        };\n        var existingNodesMap = this.clientSideRowModel.getCopyOfNodesMap();\n        var suppressSortOrder = this.gridOptionsWrapper.isSuppressMaintainUnsortedOrder();\n        var orderMap = suppressSortOrder ? null : {};\n        if (_.exists(data)) {\n            // split all the new data in the following:\n            // if new, push to 'add'\n            // if update, push to 'update'\n            // if not changed, do not include in the transaction\n            data.forEach(function (dataItem, index) {\n                var id = getRowNodeIdFunc(dataItem);\n                var existingNode = existingNodesMap[id];\n                if (orderMap) {\n                    orderMap[id] = index;\n                }\n                if (existingNode) {\n                    var dataHasChanged = existingNode.data !== dataItem;\n                    if (dataHasChanged) {\n                        transaction.update.push(dataItem);\n                    }\n                    // otherwise, if data not changed, we just don't include it anywhere, as it's not a delta\n                    // remove from list, so we know the item is not to be removed\n                    existingNodesMap[id] = undefined;\n                }\n                else {\n                    transaction.add.push(dataItem);\n                }\n            });\n        }\n        // at this point, all rows that are left, should be removed\n        _.iterateObject(existingNodesMap, function (id, rowNode) {\n            if (rowNode) {\n                transaction.remove.push(rowNode.data);\n            }\n        });\n        return [transaction, orderMap];\n    };\n    __decorate([\n        Autowired('rowModel')\n    ], ImmutableService.prototype, \"rowModel\", void 0);\n    __decorate([\n        Autowired('gridOptionsWrapper')\n    ], ImmutableService.prototype, \"gridOptionsWrapper\", void 0);\n    __decorate([\n        PostConstruct\n    ], ImmutableService.prototype, \"postConstruct\", null);\n    ImmutableService = __decorate([\n        Bean('immutableService')\n    ], ImmutableService);\n    return ImmutableService;\n}());\nexport { ImmutableService };\n","import { ModuleNames } from \"@ag-grid-community/core\";\nimport { ClientSideRowModel } from \"./clientSideRowModel/clientSideRowModel\";\nimport { FilterStage } from \"./clientSideRowModel/filterStage\";\nimport { SortStage } from \"./clientSideRowModel/sortStage\";\nimport { FlattenStage } from \"./clientSideRowModel/flattenStage\";\nimport { SortService } from \"./clientSideRowModel/sortService\";\nimport { FilterService } from \"./clientSideRowModel/filterService\";\nimport { ImmutableService } from \"./clientSideRowModel/immutableService\";\nexport var ClientSideRowModelModule = {\n    moduleName: ModuleNames.ClientSideRowModelModule,\n    beans: [FilterStage, SortStage, FlattenStage, SortService, FilterService, ImmutableService],\n    rowModels: { clientSide: ClientSideRowModel }\n};\n","import { ClientSideRowModelModule } from '@ag-grid-community/client-side-row-model';\nimport { InfiniteRowModelModule } from '@ag-grid-community/infinite-row-model';\nimport { CsvExportModule } from '@ag-grid-community/csv-export';\nexport var AllCommunityModules = [ClientSideRowModelModule, InfiniteRowModelModule, CsvExportModule];\nexport * from \"@ag-grid-community/client-side-row-model\";\nexport * from \"@ag-grid-community/csv-export\";\nexport * from \"@ag-grid-community/infinite-row-model\";\nexport * from \"@ag-grid-community/core\";\n"],"sourceRoot":""}