d2coreui 23.0.29 → 23.0.30

package/components/grid/cell/rangeSelector.js

@@ -1,77 +1,169 @@
-import { _areEqual, _exists, _includes, _isDomLayout, _last, _makeNull, _missing, _removeFromArray, _shallowCompare, AutoScrollService, BeanStub } from "ag-grid-community";
+import { AutoScrollService, BeanStub, _areCellsEqual, _areEqual, _exists, _getAbsoluteRowIndex, _getCellCtrlForEventTarget, _getRowAbove, _getRowBelow, _getRowCtrlForEventTarget, _getRowNode, _getSuppressMultiRanges, _isDomLayout, _isRowBefore, _isSameRow, _isUsingNewCellSelectionAPI, _last, _makeNull, _missing, _warn, isRowNumberCol, _getRowSelectionMode, } from 'ag-grid-community';
+import { DragListenerFeature } from './dragListenerFeature';
+const SelectionMode = {
+    NORMAL: 0,
+    ALL_COLUMNS: 1,
+};
 export class RangeSelector extends BeanStub {
     constructor() {
-        super(...arguments);
-        this.beanName = "RangeSelector";
+        super();
+        this.beanName = 'rangeSvc';
+        this.bodyScrollListener = this.onBodyScroll.bind(this);
+        this.cellRanges = [];
+        this.dragging = false;
+        this.intersectionRange = false;
     }
     wireBeans(beans) {
         this.rowModel = beans.rowModel;
-        this.dragService = beans.dragService;
-        this.columnModel = beans.columnModel;
-        this.visibleColsService = beans.visibleColsService;
-        this.cellNavigationService = beans.cellNavigationService;
-        this.pinnedRowModel = beans.pinnedRowModel;
-        this.rowPositionUtils = beans.rowPositionUtils;
-        this.cellPositionUtils = beans.cellPositionUtils;
-        this.ctrlsService = beans.ctrlsService;
-        this.valueService = beans.valueService;
-        this.eventService = beans.eventService;
-        this.mouseEventService = beans.mouseEventService;
+        this.dragSvc = beans.dragSvc;
+        this.colModel = beans.colModel;
+        this.visibleCols = beans.visibleCols;
+        this.cellNavigation = beans.cellNavigation;
+        this.ctrlsSvc = beans.ctrlsSvc;
+        this.valueSvc = beans.valueSvc;
         this.gridApi = beans.gridApi;
-        this.eGridDiv = beans.eGridDiv;
-        this.focusService = beans.focusService;
-        this.gos = beans.gos;
     }
     postConstruct() {
-        this.cellRanges = [];
-        this.bodyScrollListener = this.onBodyScroll.bind(this);
-        this.dragging = false;
-        this.eventService.addEventListener("newColumnsLoaded", () => this.removeAllCellRanges());
-        this.eventService.addEventListener("columnPivotModeChanged", () => this.removeAllCellRanges());
-        this.eventService.addEventListener("columnRowGroupChanged", () => this.removeAllCellRanges());
-        this.eventService.addEventListener("columnPivotChanged", () => this.removeAllCellRanges());
-        this.eventService.addEventListener("columnGroupOpened", this.refreshLastRangeStart.bind(this));
-        this.eventService.addEventListener("columnMoved", this.refreshLastRangeStart.bind(this));
-        this.eventService.addEventListener("columnPinned", this.refreshLastRangeStart.bind(this));
-        this.eventService.addEventListener("columnVisible", this.onColumnVisibleChange.bind(this));
-        this.ctrlsService.whenReady(this, () => {
-            const gridBodyCon = this.ctrlsService.getGridBodyCtrl();
+        const onColumnsChanged = this.onColumnsChanged.bind(this);
+        const removeAllCellRanges = () => this.removeAllCellRanges();
+        const refreshLastRangeStart = this.refreshLastRangeStart.bind(this);
+        this.addManagedEventListeners({
+            newColumnsLoaded: onColumnsChanged,
+            columnVisible: onColumnsChanged,
+            columnValueChanged: onColumnsChanged,
+            columnPivotModeChanged: removeAllCellRanges,
+            columnRowGroupChanged: removeAllCellRanges,
+            columnPivotChanged: removeAllCellRanges,
+            columnGroupOpened: refreshLastRangeStart,
+            columnMoved: refreshLastRangeStart,
+            columnPinned: refreshLastRangeStart,
+        });
+        this.ctrlsSvc.whenReady(this, (p) => {
+            const gridBodyCtrl = p.gridBodyCtrl;
             this.autoScrollService = new AutoScrollService({
-                scrollContainer: gridBodyCon.getBodyViewportElement(),
+                scrollContainer: gridBodyCtrl.eBodyViewport,
                 scrollAxis: 'xy',
-                getVerticalPosition: () => gridBodyCon.getScrollFeature().getVScrollPosition().top,
-                setVerticalPosition: (position) => gridBodyCon.getScrollFeature().setVerticalScrollPosition(position),
-                getHorizontalPosition: () => gridBodyCon.getScrollFeature().getHScrollPosition().left,
-                setHorizontalPosition: (position) => gridBodyCon.getScrollFeature().setHorizontalScrollPosition(position),
+                getVerticalPosition: () => gridBodyCtrl.scrollFeature.getVScrollPosition().top,
+                setVerticalPosition: (position) => gridBodyCtrl.scrollFeature.setVerticalScrollPosition(position),
+                getHorizontalPosition: () => gridBodyCtrl.scrollFeature.getHScrollPosition().left,
+                setHorizontalPosition: (position) => gridBodyCtrl.scrollFeature.setHorizontalScrollPosition(position),
                 shouldSkipVerticalScroll: () => !_isDomLayout(this.gos, 'normal'),
-                shouldSkipHorizontalScroll: () => !gridBodyCon.getScrollFeature().isHorizontalScrollShowing()
+                shouldSkipHorizontalScroll: () => !gridBodyCtrl.scrollFeature.isHorizontalScrollShowing(),
             });
         });
-        const params = {
-            eElement: this.eGridDiv,
-            onDragStart: this.onDragStart.bind(this),
-            onDragStop: this.onDragStop.bind(this),
-            onDragging: this.onDragging.bind(this)
+    }
+    onDragStart(mouseEvent) {
+        var _a, _b;
+        const gos = this.gos;
+        if ((_a = _getRowCtrlForEventTarget(gos, mouseEvent.target)) === null || _a === void 0 ? void 0 : _a.isSuppressMouseEvent(mouseEvent)) {
+            return;
+        }
+        const { ctrlKey, metaKey, shiftKey } = mouseEvent;
+        const isMultiKey = ctrlKey || metaKey;
+        const allowMulti = !_getSuppressMultiRanges(gos);
+        const isMultiSelect = allowMulti ? isMultiKey : false;
+        const extendRange = shiftKey && !!((_b = this.cellRanges) === null || _b === void 0 ? void 0 : _b.length);
+        if (!isMultiSelect && (!extendRange || _exists(_last(this.cellRanges).type))) {
+            this.removeAllCellRanges(true);
+        }
+        const startTarget = this.dragSvc.startTarget;
+        if (startTarget) {
+            this.updateValuesOnMove(startTarget);
+        }
+        if (!this.lastCellHovered) {
+            return;
+        }
+        this.dragging = true;
+        this.lastMouseEvent = mouseEvent;
+        this.intersectionRange = isMultiSelect && this.getCellRangeCount(this.lastCellHovered) > 1;
+        if (!extendRange) {
+            this.setNewestRangeStartCell(this.lastCellHovered);
+        }
+        if (this.cellRanges.length > 0) {
+            this.draggingRange = _last(this.cellRanges);
+        }
+        else {
+            const mouseRowPosition = {
+                rowIndex: this.lastCellHovered.rowIndex,
+                rowPinned: this.lastCellHovered.rowPinned,
+            };
+            const columns = this.getColumnsFromModel([this.lastCellHovered.column]);
+            if (!(columns === null || columns === void 0 ? void 0 : columns.length)) {
+                return;
+            }
+            this.draggingRange = {
+                startRow: mouseRowPosition,
+                endRow: mouseRowPosition,
+                columns,
+                startColumn: this.newestRangeStartCell.column,
+            };
+            this.cellRanges.push(this.draggingRange);
+        }
+        this.ctrlsSvc
+            .getGridBodyCtrl()
+            .eBodyViewport.addEventListener('scroll', this.bodyScrollListener, { passive: true });
+        this.dispatchChangedEvent(true, false, this.draggingRange.id);
+    }
+    onDragging(mouseEvent) {
+        const { dragging, lastCellHovered, newestRangeStartCell, autoScrollService, cellHasChanged } = this;
+        if (!dragging || !mouseEvent) {
+            return;
+        }
+        this.updateValuesOnMove(mouseEvent.target);
+        this.lastMouseEvent = mouseEvent;
+        const isMouseAndStartInPinned = (position) => lastCellHovered && lastCellHovered.rowPinned === position && newestRangeStartCell.rowPinned === position;
+        const skipVerticalScroll = isMouseAndStartInPinned('top') || isMouseAndStartInPinned('bottom');
+        autoScrollService.check(mouseEvent, skipVerticalScroll);
+        if (!cellHasChanged || !lastCellHovered) {
+            return;
+        }
+        const startColumn = newestRangeStartCell === null || newestRangeStartCell === void 0 ? void 0 : newestRangeStartCell.column;
+        const currentColumn = lastCellHovered === null || lastCellHovered === void 0 ? void 0 : lastCellHovered.column;
+        const columns = this.calculateColumnsBetween(startColumn, currentColumn);
+        if (!columns) {
+            return;
+        }
+        const { rowIndex, rowPinned } = lastCellHovered;
+        this.draggingRange.endRow = {
+            rowIndex,
+            rowPinned,
         };
-        this.dragService.addDragSource(params);
-        this.dragService.addDestroyFunc(() => this.dragService.removeDragSource(params));
+        this.draggingRange.columns = columns;
+        this.dispatchChangedEvent(false, false, this.draggingRange.id);
     }
-    cellPositionEquals(cellA, cellB) {
-        const colsMatch = cellA.column === cellB.column;
-        const floatingMatch = cellA.rowPinned === cellB.rowPinned;
-        const indexMatch = cellA.rowIndex === cellB.rowIndex;
-        return colsMatch && floatingMatch && indexMatch;
+    onDragStop() {
+        if (!this.dragging) {
+            return;
+        }
+        const { id } = this.draggingRange;
+        this.autoScrollService.ensureCleared();
+        this.ctrlsSvc.getGridBodyCtrl().eBodyViewport.removeEventListener('scroll', this.bodyScrollListener);
+        this.lastMouseEvent = null;
+        this.dragging = false;
+        this.draggingRange = undefined;
+        this.lastCellHovered = undefined;
+        if (this.intersectionRange) {
+            this.intersectionRange = false;
+            this.intersectLastRange();
+        }
+        this.dispatchChangedEvent(false, true, id);
     }
-    onColumnVisibleChange() {
+    onColumnsChanged() {
         this.refreshLastRangeStart();
-        this.cellRanges.forEach(cellRange => {
+        const allColumns = this.visibleCols.allCols;
+        for (const cellRange of this.cellRanges) {
             const beforeCols = cellRange.columns;
-            cellRange.columns = cellRange.columns.filter(col => col.isVisible());
+            cellRange.columns = cellRange.columns.filter((col) => col.isVisible() && allColumns.indexOf(col) !== -1);
             const colsInRangeChanged = !_areEqual(beforeCols, cellRange.columns);
             if (colsInRangeChanged) {
                 this.dispatchChangedEvent(false, true, cellRange.id);
             }
-        });
+        }
+        const countBefore = this.cellRanges.length;
+        this.cellRanges = this.cellRanges.filter((range) => range.columns.length > 0);
+        if (countBefore > this.cellRanges.length) {
+            this.dispatchChangedEvent(false, true);
+        }
     }
     refreshLastRangeStart() {
         const lastRange = _last(this.cellRanges);
@@ -85,145 +177,206 @@ export class RangeSelector extends BeanStub {
         if (!rangeColumns.length) {
             return false;
         }
-        const allColumns = this.visibleColsService.getAllCols();
-        const allPositions = rangeColumns.map(c => allColumns.indexOf(c)).sort((a, b) => a - b);
+        const allColumns = this.visibleCols.allCols;
+        const allPositions = rangeColumns.map((c) => allColumns.indexOf(c)).sort((a, b) => a - b);
         return _last(allPositions) - allPositions[0] + 1 === rangeColumns.length;
     }
     getRangeStartRow(cellRange) {
+        var _a, _b;
         if (cellRange.startRow && cellRange.endRow) {
-            return this.rowPositionUtils.before(cellRange.startRow, cellRange.endRow) ?
-                cellRange.startRow : cellRange.endRow;
+            return _isRowBefore(cellRange.startRow, cellRange.endRow) ? cellRange.startRow : cellRange.endRow;
         }
-        const rowPinned = this.pinnedRowModel.getPinnedTopRowCount() > 0 ? 'top' : null;
+        const pinnedTopRowCount = (_b = (_a = this.beans.pinnedRowModel) === null || _a === void 0 ? void 0 : _a.getPinnedTopRowCount()) !== null && _b !== void 0 ? _b : 0;
+        const rowPinned = pinnedTopRowCount > 0 ? 'top' : null;
         return { rowIndex: 0, rowPinned };
     }
     getRangeEndRow(cellRange) {
+        var _a, _b;
         if (cellRange.startRow && cellRange.endRow) {
-            return this.rowPositionUtils.before(cellRange.startRow, cellRange.endRow) ?
-                cellRange.endRow : cellRange.startRow;
+            return _isRowBefore(cellRange.startRow, cellRange.endRow) ? cellRange.endRow : cellRange.startRow;
         }
-        const pinnedBottomRowCount = this.pinnedRowModel.getPinnedBottomRowCount();
+        const pinnedBottomRowCount = (_b = (_a = this.beans.pinnedRowModel) === null || _a === void 0 ? void 0 : _a.getPinnedBottomRowCount()) !== null && _b !== void 0 ? _b : 0;
         const pinnedBottom = pinnedBottomRowCount > 0;
         if (pinnedBottom) {
             return {
                 rowIndex: pinnedBottomRowCount - 1,
-                rowPinned: 'bottom'
+                rowPinned: 'bottom',
             };
         }
         return {
             rowIndex: this.rowModel.getRowCount() - 1,
-            rowPinned: null
+            rowPinned: null,
         };
     }
+    getRangeRowCount(cellRange) {
+        const beans = this.beans;
+        const start = this.getRangeStartRow(cellRange);
+        const end = this.getRangeEndRow(cellRange);
+        const startIndex = _getAbsoluteRowIndex(beans, start);
+        const endIndex = _getAbsoluteRowIndex(beans, end);
+        return endIndex - startIndex + 1;
+    }
     setRangeToCell(cell, appendRange = false) {
+        const { gos } = this;
+        const isRowNumbersEnabled = gos.get('rowNumbers');
+        const allColumnsRange = isRowNumberCol(cell.column);
+        if (isRowNumbersEnabled) {
+            this.setSelectionMode(allColumnsRange);
+        }
         const columns = this.calculateColumnsBetween(cell.column, cell.column);
         if (!columns) {
             return;
         }
-        this.removeAllCellRanges(true);
+        const suppressMultiRangeSelections = _getSuppressMultiRanges(this.gos);
+        if (suppressMultiRangeSelections || !appendRange || _missing(this.cellRanges)) {
+            this.removeAllCellRanges(true);
+        }
         const rowForCell = {
             rowIndex: cell.rowIndex,
-            rowPinned: cell.rowPinned
+            rowPinned: cell.rowPinned,
         };
-        let cellRange;
-        for (let i = 0; i < this.cellRanges.length; i++) {
-            const range = this.cellRanges[i];
-            const matches = (range.columns && range.columns.length === 1 && range.columns[0] === cell.column) &&
-                this.rowPositionUtils.sameRow(rowForCell, range.startRow) &&
-                this.rowPositionUtils.sameRow(rowForCell, range.endRow);
-            if (matches) {
-                cellRange = range;
+        const cellRange = {
+            startRow: rowForCell,
+            endRow: rowForCell,
+            columns,
+            startColumn: cell.column,
+        };
+        this.cellRanges.push(cellRange);
+        this.setNewestRangeStartCell(cell);
+        this.onDragStop();
+        this.dispatchChangedEvent(true, true);
+    }
+    getRangeLastColumn(cellRange) {
+        var _a;
+        const firstCol = cellRange.columns[0];
+        const lastCol = _last(cellRange.columns);
+        return (((_a = this.newestRangeStartCell) === null || _a === void 0 ? void 0 : _a.column) === firstCol ? lastCol : firstCol);
+    }
+    extendRangeRowCountBy(cellRange, targetCount) {
+        const { beans } = this;
+        const { startRow, endRow } = cellRange;
+        if (!startRow || !endRow) {
+            return;
+        }
+        let stepsMoved = 0;
+        let currentRow;
+        const isBottomUp = _isRowBefore(endRow, startRow);
+        if (isBottomUp) {
+            currentRow = startRow;
+        }
+        else {
+            currentRow = endRow;
+        }
+        const stepFn = targetCount > 0 ? _getRowBelow : _getRowAbove;
+        const stepCount = Math.abs(targetCount);
+        while (stepsMoved < stepCount) {
+            const nextRow = stepFn(beans, currentRow);
+            if (!nextRow) {
                 break;
             }
+            currentRow = nextRow;
+            stepsMoved++;
+        }
+        if (stepsMoved !== stepCount) {
+            return;
+        }
+        const cellPosition = Object.assign(Object.assign({}, currentRow), { column: this.getRangeLastColumn(cellRange) });
+        this.updateRangeRowBoundary({ cellRange, boundary: isBottomUp ? 'start' : 'end', cellPosition });
+    }
+    extendRangeColumnCountBy(cellRange, delta) {
+        const { columns, startColumn } = cellRange;
+        if (delta === 0) {
+            return;
+        }
+        const allColumns = this.getColumnsFromModel();
+        if (!allColumns) {
+            return;
+        }
+        const lastColumn = _last(columns);
+        const endColumn = startColumn === columns[0] ? lastColumn : columns[0];
+        if (!lastColumn || !endColumn) {
+            return;
         }
-        if (cellRange) {
-            const atEndOfList = _last(this.cellRanges) === cellRange;
-            if (!atEndOfList) {
-                _removeFromArray(this.cellRanges, cellRange);
-                this.cellRanges.push(cellRange);
+        let startIdx = allColumns.indexOf(startColumn);
+        const endIdx = allColumns.indexOf(endColumn);
+        const isRtlRange = endIdx < startIdx;
+        if (isRtlRange) {
+            startIdx = endIdx;
+        }
+        const currentLength = columns.length;
+        const targetLength = currentLength + delta;
+        if (targetLength <= 0) {
+            return;
+        }
+        const newColumns = [];
+        for (let i = startIdx; i < startIdx + targetLength; i++) {
+            const col = allColumns[i];
+            if (!col) {
+                break;
             }
+            newColumns.push(col);
         }
-        else {
-            cellRange = {
-                startRow: rowForCell,
-                endRow: rowForCell,
-                columns: columns,
-                startColumn: cell.column
-            };
-            this.cellRanges.push(cellRange);
+        if (newColumns.length === targetLength) {
+            if (isRtlRange) {
+                const newColumnToFocus = _last(newColumns);
+                cellRange.startColumn = newColumnToFocus;
+                this.focusCellOnNewColumn(cellRange, newColumnToFocus);
+            }
+            cellRange.columns = newColumns;
+            this.dispatchChangedEvent(true, true, cellRange.id);
         }
-        this.newestRangeStartCell = cell;
-        this.onDragStop();
-        this.dispatchChangedEvent(true, true, cellRange.id);
     }
     extendLatestRangeToCell(cellPosition) {
         if (this.isEmpty() || !this.newestRangeStartCell) {
             return;
         }
         const cellRange = _last(this.cellRanges);
-        this.updateRangeEnd(cellRange, cellPosition);
+        this.setSelectionMode(isRowNumberCol(cellPosition.column));
+        this.updateRangeRowBoundary({ cellRange, boundary: 'end', cellPosition });
     }
-    updateRangeEnd(cellRange, cellPosition, silent) {
-        silent = !!silent;
+    updateRangeRowBoundary(params) {
+        const { cellRange, boundary, cellPosition, silent = false } = params;
         const endColumn = cellPosition.column;
         const colsToAdd = this.calculateColumnsBetween(cellRange.startColumn, endColumn);
         if (!colsToAdd || this.isLastCellOfRange(cellRange, cellPosition)) {
             return;
         }
+        if (boundary === 'start') {
+            this.focusCellOnNewRow(cellRange, cellPosition);
+        }
         cellRange.columns = colsToAdd;
-        cellRange.endRow = { rowIndex: cellPosition.rowIndex, rowPinned: cellPosition.rowPinned };
+        cellRange[boundary === 'start' ? 'startRow' : 'endRow'] = {
+            rowIndex: cellPosition.rowIndex,
+            rowPinned: cellPosition.rowPinned,
+        };
         if (!silent) {
             this.dispatchChangedEvent(true, true, cellRange.id);
         }
     }
-    refreshRangeStart(cellRange) {
-        const { startColumn, columns } = cellRange;
-        const moveColInCellRange = (colToMove, moveToFront) => {
-            const otherCols = cellRange.columns.filter(col => col !== colToMove);
-            if (colToMove) {
-                cellRange.startColumn = colToMove;
-                cellRange.columns = moveToFront ? [colToMove, ...otherCols] : [...otherCols, colToMove];
-            }
-            else {
-                cellRange.columns = otherCols;
-            }
-        };
-        const { left, right } = this.getRangeEdgeColumns(cellRange);
-        const shouldMoveLeftCol = startColumn === columns[0] && startColumn !== left;
-        if (shouldMoveLeftCol) {
-            moveColInCellRange(left, true);
-            return;
-        }
-        const shouldMoveRightCol = startColumn === _last(columns) && startColumn === right;
-        if (shouldMoveRightCol) {
-            moveColInCellRange(right, false);
-            return;
-        }
-    }
     getRangeEdgeColumns(cellRange) {
-        const allColumns = this.visibleColsService.getAllCols();
+        const allColumns = this.visibleCols.allCols;
         const allIndices = cellRange.columns
-            .map(c => allColumns.indexOf(c))
-            .filter(i => i > -1)
+            .map((c) => allColumns.indexOf(c))
+            .filter((i) => i > -1)
             .sort((a, b) => a - b);
         return {
             left: allColumns[allIndices[0]],
-            right: allColumns[_last(allIndices)]
+            right: allColumns[_last(allIndices)],
         };
     }
-    extendLatestRangeInDirection(key) {
+    extendLatestRangeInDirection(event) {
         if (this.isEmpty() || !this.newestRangeStartCell) {
             return;
         }
+        const key = event.key;
+        const ctrlKey = event.ctrlKey || event.metaKey;
         const lastRange = _last(this.cellRanges);
         const startCell = this.newestRangeStartCell;
-        const firstCol = lastRange.columns[0];
-        const lastCol = _last(lastRange.columns);
         const endCellIndex = lastRange.endRow.rowIndex;
         const endCellFloating = lastRange.endRow.rowPinned;
-        const endCellColumn = startCell.column === firstCol ? lastCol : firstCol;
+        const endCellColumn = this.getRangeLastColumn(lastRange);
         const endCell = { column: endCellColumn, rowIndex: endCellIndex, rowPinned: endCellFloating };
-        const newEndCell = this.cellNavigationService.getNextCellToFocus(key, endCell);
+        const newEndCell = this.cellNavigation.getNextCellToFocus(key, endCell, ctrlKey);
         if (!newEndCell) {
             return;
         }
@@ -233,7 +386,7 @@ export class RangeSelector extends BeanStub {
             rowEndIndex: newEndCell.rowIndex,
             rowEndPinned: newEndCell.rowPinned,
             columnStart: startCell.column,
-            columnEnd: newEndCell.column
+            columnEnd: newEndCell.column,
         });
         return newEndCell;
     }
@@ -242,56 +395,110 @@ export class RangeSelector extends BeanStub {
         this.addCellRange(params);
     }
     setCellRanges(cellRanges) {
-        if (_shallowCompare(this.cellRanges, cellRanges)) {
+        if (_areEqual(this.cellRanges, cellRanges)) {
+            return;
+        }
+        if (!this.verifyCellRanges(this.gos)) {
             return;
         }
         this.removeAllCellRanges(true);
-        cellRanges.forEach(newRange => {
-            if (newRange.columns && newRange.startRow) {
-                this.newestRangeStartCell = {
-                    rowIndex: newRange.startRow.rowIndex,
-                    rowPinned: newRange.startRow.rowPinned,
-                    column: newRange.columns[0]
-                };
+        for (const cellRange of cellRanges) {
+            if (cellRange.columns && cellRange.startRow) {
+                const columns = this.getColumnsFromModel(cellRange.columns);
+                if (!columns || columns.length === 0) {
+                    continue;
+                }
+                cellRange.columns = columns;
+                const { startRow } = cellRange;
+                this.setNewestRangeStartCell({
+                    rowIndex: startRow.rowIndex,
+                    rowPinned: startRow.rowPinned,
+                    column: cellRange.columns[0],
+                });
             }
-            this.cellRanges.push(newRange);
-        });
+            this.cellRanges.push(cellRange);
+        }
         this.dispatchChangedEvent(false, true);
     }
-    createCellRangeFromCellRangeParams(params) {
-        let columns;
-        if (params.columns) {
-            columns = params.columns.map(c => this.columnModel.getColumnWithValidation(c)).filter(c => c);
+    clearCellRangeCellValues(params) {
+        const { beans, valueSvc, eventSvc } = this;
+        const { cellEventSource = 'rangeSvc', dispatchWrapperEvents, wrapperEventSource = 'deleteKey' } = params;
+        let { cellRanges } = params;
+        if (dispatchWrapperEvents) {
+            eventSvc.dispatchEvent({
+                type: 'cellSelectionDeleteStart',
+                source: wrapperEventSource,
+            });
+            eventSvc.dispatchEvent({
+                type: 'rangeDeleteStart',
+                source: wrapperEventSource,
+            });
         }
-        else {
-            const columnStart = this.columnModel.getColumnWithValidation(params.columnStart);
-            const columnEnd = this.columnModel.getColumnWithValidation(params.columnEnd);
-            if (!columnStart || !columnEnd) {
-                return;
-            }
-            columns = this.calculateColumnsBetween(columnStart, columnEnd);
+        if (!cellRanges) {
+            cellRanges = this.cellRanges;
         }
-        if (!columns) {
+        for (const cellRange of cellRanges) {
+            this.forEachRowInRange(cellRange, (rowPosition) => {
+                const rowNode = _getRowNode(beans, rowPosition);
+                if (!rowNode) {
+                    return;
+                }
+                for (let i = 0; i < cellRange.columns.length; i++) {
+                    const column = this.getColumnFromModel(cellRange.columns[i]);
+                    if (!(column === null || column === void 0 ? void 0 : column.isCellEditable(rowNode))) {
+                        continue;
+                    }
+                    const emptyValue = valueSvc.getDeleteValue(column, rowNode);
+                    rowNode.setDataValue(column, emptyValue, cellEventSource);
+                }
+            });
+        }
+        if (dispatchWrapperEvents) {
+            eventSvc.dispatchEvent({
+                type: 'cellSelectionDeleteEnd',
+                source: wrapperEventSource,
+            });
+            eventSvc.dispatchEvent({
+                type: 'rangeDeleteEnd',
+                source: wrapperEventSource,
+            });
+        }
+    }
+    createCellRangeFromCellRangeParams(params) {
+        return this.createPartialCellRangeFromRangeParams(params, false);
+    }
+    createPartialCellRangeFromRangeParams(params, allowEmptyColumns) {
+        var _a;
+        const { columns: paramColumns, columnStart, columnEnd, rowStartIndex, rowStartPinned, rowEndIndex, rowEndPinned, } = params;
+        const columnInfo = this.getColumnsFromParams(paramColumns, columnStart, columnEnd);
+        if (!columnInfo || (!allowEmptyColumns && columnInfo.columns.length === 0)) {
             return;
         }
-        const startRow = params.rowStartIndex != null ? {
-            rowIndex: params.rowStartIndex,
-            rowPinned: params.rowStartPinned
-        } : undefined;
-        const endRow = params.rowEndIndex != null ? {
-            rowIndex: params.rowEndIndex,
-            rowPinned: params.rowEndPinned
-        } : undefined;
+        const { columns, startsOnTheRight } = columnInfo;
+        const startRow = this.createRowPosition(rowStartIndex, rowStartPinned);
+        const endRow = this.createRowPosition(rowEndIndex, rowEndPinned);
         return {
-            startRow: startRow,
-            endRow: endRow,
-            columns: columns,
-            startColumn: columns[0]
+            startRow,
+            endRow,
+            columns,
+            startColumn: (_a = this.getColumnFromModel(columnStart)) !== null && _a !== void 0 ? _a : (startsOnTheRight ? _last(columns) : columns[0]),
         };
     }
     addCellRange(params) {
+        const gos = this.gos;
+        if (!this.verifyCellRanges(gos)) {
+            return;
+        }
+        this.setSelectionMode(false);
         const newRange = this.createCellRangeFromCellRangeParams(params);
         if (newRange) {
+            if (newRange.startRow) {
+                this.setNewestRangeStartCell({
+                    rowIndex: newRange.startRow.rowIndex,
+                    rowPinned: newRange.startRow.rowPinned,
+                    column: newRange.startColumn,
+                });
+            }
             this.cellRanges.push(newRange);
             this.dispatchChangedEvent(false, true, newRange.id);
         }
@@ -303,18 +510,52 @@ export class RangeSelector extends BeanStub {
         return this.cellRanges.length === 0;
     }
     isMoreThanOneCell() {
-        if (this.cellRanges.length === 0) {
+        const len = this.cellRanges.length;
+        if (len === 0) {
             return false;
         }
-        else if (this.cellRanges.length > 1) {
+        if (len > 1) {
             return true;
         }
         const range = this.cellRanges[0];
         const startRow = this.getRangeStartRow(range);
         const endRow = this.getRangeEndRow(range);
-        return startRow.rowPinned !== endRow.rowPinned ||
+        return (startRow.rowPinned !== endRow.rowPinned ||
             startRow.rowIndex !== endRow.rowIndex ||
-            range.columns.length !== 1;
+            range.columns.length !== 1);
+    }
+    areAllRangesAbleToMerge() {
+        const rowToColumnMap = new Map();
+        const len = this.cellRanges.length;
+        if (len <= 1) {
+            return true;
+        }
+        for (const range of this.cellRanges) {
+            this.forEachRowInRange(range, (row) => {
+                const rowName = `${row.rowPinned || 'normal'}_${row.rowIndex}`;
+                const columns = rowToColumnMap.get(rowName);
+                const currentRangeColIds = range.columns.map((col) => col.getId());
+                if (columns) {
+                    const filteredColumns = currentRangeColIds.filter((col) => columns.indexOf(col) === -1);
+                    columns.push(...filteredColumns);
+                }
+                else {
+                    rowToColumnMap.set(rowName, currentRangeColIds);
+                }
+            });
+        }
+        let columnsString;
+        for (const val of rowToColumnMap.values()) {
+            const currentValString = val.sort().join();
+            if (columnsString === undefined) {
+                columnsString = currentValString;
+                continue;
+            }
+            if (columnsString !== currentValString) {
+                return false;
+            }
+        }
+        return true;
     }
     removeAllCellRanges(silent) {
         if (this.isEmpty()) {
@@ -326,32 +567,20 @@ export class RangeSelector extends BeanStub {
             this.dispatchChangedEvent(false, true);
         }
     }
-    onBodyScroll() {
-        this.onDragging(this.lastMouseEvent);
-    }
     isCellInAnyRange(cell) {
         return this.getCellRangeCount(cell) > 0;
     }
     isCellInSpecificRange(cell, range) {
-        const columnInRange = range.columns !== null && _includes(range.columns, cell.column);
+        var _a;
+        const columnInRange = (_a = range.columns) === null || _a === void 0 ? void 0 : _a.includes(cell.column);
         const rowInRange = this.isRowInRange(cell.rowIndex, cell.rowPinned, range);
         return columnInRange && rowInRange;
     }
-    isLastCellOfRange(cellRange, cell) {
-        const { startRow, endRow } = cellRange;
-        const lastRow = this.rowPositionUtils.before(startRow, endRow) ? endRow : startRow;
-        const isLastRow = cell.rowIndex === lastRow.rowIndex && cell.rowPinned === lastRow.rowPinned;
-        const rangeFirstIndexColumn = cellRange.columns[0];
-        const rangeLastIndexColumn = _last(cellRange.columns);
-        const lastRangeColumn = cellRange.startColumn === rangeFirstIndexColumn ? rangeLastIndexColumn : rangeFirstIndexColumn;
-        const isLastColumn = cell.column === lastRangeColumn;
-        return isLastColumn && isLastRow;
-    }
     isBottomRightCell(cellRange, cell) {
-        const allColumns = this.visibleColsService.getAllCols();
-        const allPositions = cellRange.columns.map(c => allColumns.indexOf(c)).sort((a, b) => a - b);
+        const allColumns = this.visibleCols.allCols;
+        const allPositions = cellRange.columns.map((c) => allColumns.indexOf(c)).sort((a, b) => a - b);
         const { startRow, endRow } = cellRange;
-        const lastRow = this.rowPositionUtils.before(startRow, endRow) ? endRow : startRow;
+        const lastRow = _isRowBefore(startRow, endRow) ? endRow : startRow;
         const isRightColumn = allColumns.indexOf(cell.column) === _last(allPositions);
         const isLastRow = cell.rowIndex === lastRow.rowIndex && _makeNull(cell.rowPinned) === _makeNull(lastRow.rowPinned);
         return isRightColumn && isLastRow;
@@ -360,103 +589,214 @@ export class RangeSelector extends BeanStub {
         if (this.isEmpty()) {
             return 0;
         }
-        return this.cellRanges.filter(cellRange => this.isCellInSpecificRange(cell, cellRange)).length;
+        return this.cellRanges.filter((cellRange) => this.isCellInSpecificRange(cell, cellRange)).length;
     }
-    isRowInRange(rowIndex, floating, cellRange) {
+    isRowInRange(rowIndex, rowPinned, cellRange) {
         const firstRow = this.getRangeStartRow(cellRange);
         const lastRow = this.getRangeEndRow(cellRange);
-        const thisRow = { rowIndex: rowIndex, rowPinned: floating };
+        const thisRow = { rowIndex, rowPinned: rowPinned || null };
         const equalsFirstRow = thisRow.rowIndex === firstRow.rowIndex && thisRow.rowPinned == firstRow.rowPinned;
         const equalsLastRow = thisRow.rowIndex === lastRow.rowIndex && thisRow.rowPinned == lastRow.rowPinned;
         if (equalsFirstRow || equalsLastRow) {
             return true;
         }
-        const afterFirstRow = !this.rowPositionUtils.before(thisRow, firstRow);
-        const beforeLastRow = this.rowPositionUtils.before(thisRow, lastRow);
+        const afterFirstRow = !_isRowBefore(thisRow, firstRow);
+        const beforeLastRow = _isRowBefore(thisRow, lastRow);
         return afterFirstRow && beforeLastRow;
     }
-    getDraggingRange() {
-        return this.draggingRange;
-    }
-    onDragStart(mouseEvent) {
-        const { shiftKey } = mouseEvent;
-        const mouseCell = this.mouseEventService.getCellPositionForEvent(mouseEvent);
-        if (_missing(mouseCell)) {
+    intersectLastRange(fromMouseClick) {
+        if (fromMouseClick && this.dragging) {
             return;
         }
-        if (!shiftKey || _exists(_last(this.cellRanges).type)) {
-            this.removeAllCellRanges(true);
+        if (_getSuppressMultiRanges(this.gos)) {
+            return;
         }
-        this.dragging = true;
-        this.draggingCell = mouseCell;
-        this.lastMouseEvent = mouseEvent;
-        if (!shiftKey) {
-            this.newestRangeStartCell = mouseCell;
+        if (this.isEmpty()) {
+            return;
         }
-        if (this.cellRanges.length > 0) {
-            this.draggingRange = _last(this.cellRanges);
+        const lastRange = _last(this.cellRanges);
+        const intersectionStartRow = this.getRangeStartRow(lastRange);
+        const intersectionEndRow = this.getRangeEndRow(lastRange);
+        const newRanges = [];
+        for (const range of this.cellRanges.slice(0, -1)) {
+            const startRow = this.getRangeStartRow(range);
+            const endRow = this.getRangeEndRow(range);
+            const cols = range.columns;
+            const intersectCols = cols.filter((col) => lastRange.columns.indexOf(col) === -1);
+            if (intersectCols.length === cols.length) {
+                newRanges.push(range);
+                continue;
+            }
+            if (_isRowBefore(intersectionEndRow, startRow) || _isRowBefore(endRow, intersectionStartRow)) {
+                newRanges.push(range);
+                continue;
+            }
+            const rangeCountBefore = newRanges.length;
+            if (_isRowBefore(startRow, intersectionStartRow)) {
+                const top = {
+                    columns: [...cols],
+                    startColumn: lastRange.startColumn,
+                    startRow: Object.assign({}, startRow),
+                    endRow: _getRowAbove(this.beans, intersectionStartRow),
+                };
+                newRanges.push(top);
+            }
+            if (intersectCols.length > 0) {
+                const middle = {
+                    columns: intersectCols,
+                    startColumn: intersectCols.includes(lastRange.startColumn)
+                        ? lastRange.startColumn
+                        : intersectCols[0],
+                    startRow: this.rowMax([Object.assign({}, intersectionStartRow), Object.assign({}, startRow)]),
+                    endRow: this.rowMin([Object.assign({}, intersectionEndRow), Object.assign({}, endRow)]),
+                };
+                newRanges.push(middle);
+            }
+            if (_isRowBefore(intersectionEndRow, endRow)) {
+                newRanges.push({
+                    columns: [...cols],
+                    startColumn: lastRange.startColumn,
+                    startRow: _getRowBelow(this.beans, intersectionEndRow),
+                    endRow: Object.assign({}, endRow),
+                });
+            }
+            if (newRanges.length - rangeCountBefore === 1) {
+                newRanges[newRanges.length - 1].id = range.id;
+            }
         }
-        else {
-            const mouseRowPosition = {
-                rowIndex: mouseCell.rowIndex,
-                rowPinned: mouseCell.rowPinned
-            };
-            this.draggingRange = {
-                startRow: mouseRowPosition,
-                endRow: mouseRowPosition,
-                columns: [mouseCell.column],
-                startColumn: this.newestRangeStartCell.column
-            };
-            this.cellRanges.push(this.draggingRange);
+        this.cellRanges = newRanges;
+        if (fromMouseClick) {
+            this.dispatchChangedEvent(false, true);
         }
-        this.ctrlsService.getGridBodyCtrl().addScrollEventListener(this.bodyScrollListener);
-        this.dispatchChangedEvent(true, false, this.draggingRange.id);
     }
-    onDragging(mouseEvent) {
-        if (!this.dragging || !mouseEvent) {
+    createRangeHighlightFeature(compBean, column, headerComp) {
+    }
+    setSelectionMode(allColumns) {
+        this.selectionMode = SelectionMode.ALL_COLUMNS;
+    }
+    refreshRangeStart(cellRange) {
+        const { startColumn, columns } = cellRange;
+        const moveColInCellRange = (colToMove, moveToFront) => {
+            const otherCols = cellRange.columns.filter((col) => col !== colToMove);
+            if (colToMove) {
+                cellRange.startColumn = colToMove;
+                cellRange.columns = moveToFront ? [colToMove, ...otherCols] : [...otherCols, colToMove];
+            }
+            else {
+                cellRange.columns = otherCols;
+            }
+        };
+        const { left, right } = this.getRangeEdgeColumns(cellRange);
+        const shouldMoveLeftCol = startColumn === columns[0] && startColumn !== left;
+        if (shouldMoveLeftCol) {
+            moveColInCellRange(left, true);
             return;
         }
-        this.lastMouseEvent = mouseEvent;
-        const cellPosition = this.mouseEventService.getCellPositionForEvent(mouseEvent);
-        const isMouseAndStartInPinned = (position) => cellPosition && cellPosition.rowPinned === position && this.newestRangeStartCell.rowPinned === position;
-        const skipVerticalScroll = isMouseAndStartInPinned('top') || isMouseAndStartInPinned('bottom');
-        this.autoScrollService.check(mouseEvent, skipVerticalScroll);
-        if (!cellPosition ||
-            !this.draggingCell ||
-            this.cellPositionEquals(this.draggingCell, cellPosition)) {
-            return;
+        const shouldMoveRightCol = startColumn === _last(columns) && startColumn === right;
+        if (shouldMoveRightCol) {
+            moveColInCellRange(right, false);
         }
-        const columns = this.calculateColumnsBetween(this.newestRangeStartCell.column, cellPosition.column);
-        if (!columns) {
-            return;
+    }
+    setNewestRangeStartCell(position) {
+        this.newestRangeStartCell = position;
+    }
+    getColumnsFromParams(columns, columnA, columnB) {
+        const noColsInfo = !columns && !columnA && !columnB;
+        let processedColumns;
+        let startsOnTheRight = false;
+        if (noColsInfo || columns) {
+            processedColumns = this.getColumnsFromModel(noColsInfo ? undefined : columns);
         }
-        this.draggingCell = cellPosition;
-        this.draggingRange.endRow = {
-            rowIndex: cellPosition.rowIndex,
-            rowPinned: cellPosition.rowPinned
-        };
-        this.draggingRange.columns = columns;
-        this.dispatchChangedEvent(false, false, this.draggingRange.id);
-        this.focusCell(cellPosition);
+        else if (columnA && columnB) {
+            processedColumns = this.calculateColumnsBetween(columnA, columnB);
+            if (processedColumns === null || processedColumns === void 0 ? void 0 : processedColumns.length) {
+                startsOnTheRight = processedColumns[0] !== this.getColumnFromModel(columnA);
+            }
+        }
+        return processedColumns
+            ? {
+                columns: processedColumns,
+                startsOnTheRight,
+            }
+            : undefined;
+    }
+    createRowPosition(rowIndex, rowPinned) {
+        return rowIndex != null ? { rowIndex, rowPinned } : undefined;
     }
-    focusCell(cellPosition) {
-        const cellFocused = this.focusService.isCellFocused(cellPosition);
-        if (!cellFocused) {
-            this.focusService.setFocusedCell(cellPosition.rowIndex, cellPosition.column, cellPosition.rowPinned, true);
+    verifyCellRanges(gos) {
+        const invalid = _isUsingNewCellSelectionAPI(gos) && _getSuppressMultiRanges(gos) && this.cellRanges.length > 1;
+        if (invalid) {
+            _warn(93);
         }
+        return !invalid;
     }
-    onDragStop() {
-        if (!this.dragging) {
+    forEachRowInRange(cellRange, callback) {
+        const topRow = this.getRangeStartRow(cellRange);
+        const bottomRow = this.getRangeEndRow(cellRange);
+        let currentRow = topRow;
+        while (currentRow) {
+            callback(currentRow);
+            if (_isSameRow(currentRow, bottomRow)) {
+                break;
+            }
+            currentRow = _getRowBelow(this.beans, currentRow);
+        }
+    }
+    onBodyScroll() {
+        if (this.dragging && this.lastMouseEvent) {
+            this.onDragging(this.lastMouseEvent);
+        }
+    }
+    isLastCellOfRange(cellRange, cell) {
+        const { startRow, endRow } = cellRange;
+        const lastRow = _isRowBefore(startRow, endRow) ? endRow : startRow;
+        const isLastRow = cell.rowIndex === lastRow.rowIndex && cell.rowPinned === lastRow.rowPinned;
+        const rangeFirstIndexColumn = cellRange.columns[0];
+        const rangeLastIndexColumn = _last(cellRange.columns);
+        const lastRangeColumn = cellRange.startColumn === rangeFirstIndexColumn ? rangeLastIndexColumn : rangeFirstIndexColumn;
+        const isLastColumn = cell.column === lastRangeColumn;
+        return isLastColumn && isLastRow;
+    }
+    rowMax(rows) {
+        let max;
+        for (const row of rows) {
+            if (max === undefined || _isRowBefore(max, row)) {
+                max = row;
+            }
+        }
+        return max;
+    }
+    rowMin(rows) {
+        let min;
+        for (const row of rows) {
+            if (min === undefined || _isRowBefore(row, min)) {
+                min = row;
+            }
+        }
+        return min;
+    }
+    updateValuesOnMove(eventTarget) {
+        var _a;
+        const cellCtrl = _getCellCtrlForEventTarget(this.gos, eventTarget);
+        const cell = cellCtrl === null || cellCtrl === void 0 ? void 0 : cellCtrl.cellPosition;
+        this.cellHasChanged = false;
+        if (!cell || (this.lastCellHovered && _areCellsEqual(cell, this.lastCellHovered))) {
             return;
         }
-        const { id } = this.draggingRange;
-        this.autoScrollService.ensureCleared();
-        this.ctrlsService.getGridBodyCtrl().removeScrollEventListener(this.bodyScrollListener);
-        this.lastMouseEvent = null;
-        this.dragging = false;
-        this.draggingRange = undefined;
-        this.draggingCell = undefined;
-        this.dispatchChangedEvent(false, true, id);
+        const editing = (_a = this.beans.editSvc) === null || _a === void 0 ? void 0 : _a.isEditing(cellCtrl, {
+            withOpenEditor: true,
+        });
+        if (editing) {
+            this.dragSvc.cancelDrag(eventTarget);
+            return;
+        }
+        if (this.lastCellHovered) {
+            this.cellHasChanged = true;
+        }
+        this.lastCellHovered = cell;
+    }
+    shouldSkipCurrentColumn(currentColumn) {
+        return isRowNumberCol(currentColumn);
     }
     dispatchChangedEvent(started, finished, id) {
         this.cellRanges.map((cellRange) => {
@@ -464,11 +804,11 @@ export class RangeSelector extends BeanStub {
             const lastRow = this.getRangeEndRow(cellRange);
             const nodesToBeSelected = [];
             while (true) {
-                const finishedAllRows = _missing(currentRow) || !currentRow || this.rowPositionUtils.before(lastRow, currentRow);
+                const finishedAllRows = _missing(currentRow) || !currentRow || this.before(lastRow, currentRow);
                 if (finishedAllRows || !currentRow || !cellRange.columns) {
                     break;
                 }
-                const rowNode = this.rowPositionUtils.getRowNode(currentRow);
+                const rowNode = _getRowNode(this.beans, currentRow);
                 if (!rowNode) {
                     break;
                 }
@@ -476,7 +816,7 @@ export class RangeSelector extends BeanStub {
                     rowNode.setSelected(true);
                 }
                 nodesToBeSelected.push(rowNode.data);
-                currentRow = this.cellNavigationService.getRowBelow(currentRow);
+                currentRow = _getRowBelow(this.beans, currentRow);
             }
             this.gridApi.getSelectedNodes().forEach((node) => {
                 if (!nodesToBeSelected.some(nodeToBeSelected => node.data === nodeToBeSelected)) {
@@ -484,36 +824,53 @@ export class RangeSelector extends BeanStub {
                 }
             });
         });
-        const eventCellSelection = {
-            type: "cellSelectionChanged",
-            started: started,
-            finished: finished,
-            id: id,
-        };
-        this.eventService.dispatchEvent(eventCellSelection);
-        const eventRangeSelection = {
-            type: "rangeSelectionChanged",
-            started: started,
-            finished: finished,
-            id: id,
-        };
-        this.eventService.dispatchEvent(eventRangeSelection);
+        this.eventSvc.dispatchEvent({
+            type: 'cellSelectionChanged',
+            started,
+            finished,
+            id,
+        });
+        this.eventSvc.dispatchEvent({
+            type: 'rangeSelectionChanged',
+            started,
+            finished,
+            id,
+        });
     }
-    calculateColumnsBetween(columnFrom, columnTo) {
-        const allColumns = this.visibleColsService.getAllCols();
-        const isSameColumn = columnFrom === columnTo;
-        const fromIndex = allColumns.indexOf(columnFrom);
+    getColumnFromModel(col) {
+        return typeof col === 'string' ? this.colModel.getCol(col) : col;
+    }
+    getColumnsFromModel(cols) {
+        const { gos, visibleCols } = this;
+        const isRowHeaderActive = gos.get('rowNumbers');
+        cols = visibleCols.allCols;
+        const columns = [];
+        for (const col of cols) {
+            const column = this.getColumnFromModel(col);
+            if (!column || (isRowHeaderActive && this.shouldSkipCurrentColumn(column))) {
+                continue;
+            }
+            columns.push(column);
+        }
+        return columns.length ? columns : undefined;
+    }
+    calculateColumnsBetween(columnA, columnB) {
+        const allColumns = this.visibleCols.allCols;
+        const fromColumn = this.getColumnFromModel(columnA);
+        const toColumn = this.getColumnFromModel(columnB);
+        const isSameColumn = fromColumn === toColumn;
+        const fromIndex = allColumns.indexOf(fromColumn);
         if (fromIndex < 0) {
-            console.warn(`ag-Grid: column ${columnFrom.getId()} is not visible`);
-            return undefined;
+            _warn(178, { colId: fromColumn.getId() });
+            return;
         }
-        const toIndex = isSameColumn ? fromIndex : allColumns.indexOf(columnTo);
+        const toIndex = isSameColumn ? fromIndex : allColumns.indexOf(toColumn);
         if (toIndex < 0) {
-            console.warn(`ag-Grid: column ${columnTo.getId()} is not visible`);
-            return undefined;
+            _warn(178, { colId: toColumn.getId() });
+            return;
         }
         if (isSameColumn) {
-            return [columnFrom];
+            return this.getColumnsFromModel([fromColumn]);
         }
         const firstIndex = Math.min(fromIndex, toIndex);
         const lastIndex = firstIndex === fromIndex ? toIndex : fromIndex;
@@ -521,7 +878,52 @@ export class RangeSelector extends BeanStub {
         for (let i = firstIndex; i <= lastIndex; i++) {
             columns.push(allColumns[i]);
         }
-        return columns;
+        return this.getColumnsFromModel(columns);
+    }
+    focusCellOnNewColumn(currentRange, column) {
+        const { focusSvc } = this.beans;
+        const focusedCell = focusSvc.getFocusedCell();
+        if (!focusedCell) {
+            return;
+        }
+        if (this.isCellInSpecificRange(focusedCell, currentRange)) {
+            focusSvc.setFocusedCell(Object.assign(Object.assign({}, focusedCell), { column, forceBrowserFocus: true, preventScrollOnBrowserFocus: true }));
+        }
+    }
+    focusCellOnNewRow(currentRange, row) {
+        const { focusSvc } = this.beans;
+        const focusedCell = focusSvc.getFocusedCell();
+        if (!focusedCell) {
+            return;
+        }
+        if (this.isCellInSpecificRange(focusedCell, currentRange)) {
+            focusSvc.setFocusedCell(Object.assign(Object.assign({}, row), { column: focusedCell.column, forceBrowserFocus: true, preventScrollOnBrowserFocus: true }));
+        }
+    }
+    before(rowA, rowB) {
+        switch (rowA.rowPinned) {
+            case 'top':
+                if (rowB.rowPinned !== 'top') {
+                    return true;
+                }
+                break;
+            case 'bottom':
+                if (rowB.rowPinned !== 'bottom') {
+                    return false;
+                }
+                break;
+            default:
+                if (_exists(rowB.rowPinned)) {
+                    return rowB.rowPinned !== 'top';
+                }
+                break;
+        }
+        return rowA.rowIndex < rowB.rowIndex;
+    }
+    createDragListenerFeature(eContainer) {
+        return new DragListenerFeature(eContainer);
+    }
+    createCellRangeFeature(beans, ctrl) {
     }
 }
 //# sourceMappingURL=rangeSelector.js.map