ag-grid-community 34.0.0 → 34.0.2

package/dist/ag-grid-community.js

@@ -7953,8 +7953,13 @@ function _addColumnDefaultAndTypes(beans, colDef, colId, isAutoCol) {
     if (columnType) {
         assignColumnTypes(beans, columnType, res);
     }
+    const cellDataType = res.cellDataType;
     // merge properties from column definitions
     (0, object_1._mergeDeep)(res, colDef, false, true);
+    if (cellDataType !== undefined) {
+        // `cellDataType: true` in provided def will overwrite inferred result type otherwise
+        res.cellDataType = cellDataType;
+    }
     const autoGroupColDef = gos.get('autoGroupColumnDef');
     const isSortingCoupled = (0, gridOptionsUtils_1._isColumnsSortingCoupledToGroup)(gos);
     if (colDef.rowGroup && autoGroupColDef && isSortingCoupled) {
@@ -10836,7 +10841,7 @@ class DataTypeService extends beanStub_1.BeanStub {
     }
     postProcess(colDef) {
         const cellDataType = colDef.cellDataType;
-        if (!cellDataType) {
+        if (!cellDataType || typeof cellDataType !== 'string') {
             return;
         }
         const { dataTypeDefinitions, beans, formatValueFuncs } = this;
@@ -16358,6 +16363,14 @@ function startEditingCell(beans, params) {
         rowPinned: rowPinned || null,
         column,
     };
+    const rowNode = (0, positionUtils_1._getRowNode)(beans, cellPosition);
+    if (!rowNode) {
+        (0, logging_1._warn)(290, { rowIndex, rowPinned });
+        return;
+    }
+    if (!column.isCellEditable(rowNode)) {
+        return;
+    }
     const notPinned = rowPinned == null;
     if (notPinned) {
         (0, scrollApi_1.ensureIndexVisible)(beans, rowIndex);
@@ -16476,6 +16489,9 @@ class EditModelService extends beanStub_1.BeanStub {
         return data;
     }
     getEdit(position) {
+        return this._getEdit(position);
+    }
+    _getEdit(position) {
         if (this.suspendEdits) {
             return undefined;
         }
@@ -16507,13 +16523,21 @@ class EditModelService extends beanStub_1.BeanStub {
     }
     setEdit(position, edit) {
         (this.edits.size === 0 || !this.edits.has(position.rowNode)) && this.edits.set(position.rowNode, new Map());
-        this.getEditRow(position.rowNode).set(position.column, edit);
+        const currentEdit = Object.assign({}, this._getEdit(position));
+        Object.keys(edit).forEach((key) => {
+            const value = edit[key];
+            // don't copy unset keys
+            if (value !== undefined) {
+                currentEdit[key] = value;
+            }
+        });
+        this.getEditRow(position.rowNode).set(position.column, currentEdit);
     }
     clearEditValue(position) {
         const { rowNode, column } = position;
         if (rowNode) {
             if (column) {
-                const edit = this.getEdit(position);
+                const edit = this._getEdit(position);
                 if (edit) {
                     edit.newValue = edit.oldValue;
                     edit.state = 'changed';
@@ -16552,7 +16576,7 @@ class EditModelService extends beanStub_1.BeanStub {
         return this.getEdit(position)?.state;
     }
     getEditPositions(editMap) {
-        if (this.suspendEdits || this.edits.size === 0) {
+        if (this.suspendEdits || (editMap ?? this.edits).size === 0) {
             return [];
         }
         const positions = [];
@@ -16882,6 +16906,8 @@ const rowEditStyleFeature_1 = __webpack_require__(13536);
 const controllers_1 = __webpack_require__(1081);
 const editors_1 = __webpack_require__(78994);
 const refresh_1 = __webpack_require__(11539);
+// these are event sources for setDataValue that will not cause the editors to close
+const KEEP_EDITOR_SOURCES = new Set(['undo', 'redo']);
 // stop editing sources that we treat as UI-originated so we follow standard processing.
 const SOURCE_TRANSFORM = {
     paste: 'ui',
@@ -16936,7 +16962,6 @@ class EditService extends beanStub_1.BeanStub {
             rowGroupOpened: handler,
             pinnedRowsChanged: handler,
             displayedRowsChanged: handler,
-            rowDataUpdated: stopInvalidEdits,
             sortChanged: stopInvalidEdits,
             filterChanged: stopInvalidEdits,
             cellFocused: this.onCellFocused.bind(this),
@@ -17043,10 +17068,10 @@ class EditService extends beanStub_1.BeanStub {
         const willStop = !cancel && !!this.shouldStopEditing(position, event, source);
         const willCancel = cancel && !!this.shouldCancelEditing(position, event, source);
         if (willStop || willCancel) {
-            (0, editors_1._syncFromEditors)(beans);
+            (0, editors_1._syncFromEditors)(beans, { event });
             const freshEdits = model.getEditMap();
             this.processEdits(freshEdits, cancel);
-            this.strategy?.stop(cancel);
+            this.strategy?.stop(cancel, event);
             this.bulkRefresh(undefined, edits);
             edits = freshEdits;
             res || (res = willStop);
@@ -17060,20 +17085,25 @@ class EditService extends beanStub_1.BeanStub {
             const isEscape = key === keyCode_1.KeyCode.ESCAPE;
             if (isEnter || isEscape) {
                 if (isEnter) {
-                    (0, editors_1._syncFromEditors)(beans);
+                    (0, editors_1._syncFromEditors)(beans, { event });
                 }
                 else if (isEscape) {
                     // only if ESC is pressed while in the editor for this cell
                     this.revertSingleCellEdit(cellCtrl, false);
                 }
-                (0, editors_1._destroyEditors)(beans, model.getEditPositions());
+                if (this.isBatchEditing()) {
+                    this.strategy?.cleanupEditors();
+                }
+                else {
+                    (0, editors_1._destroyEditors)(beans, model.getEditPositions(), { event });
+                }
                 event.preventDefault();
                 this.bulkRefresh(position, edits, { suppressFlash: true });
                 edits = model.getEditMap();
             }
         }
         else {
-            (0, editors_1._syncFromEditors)(beans);
+            (0, editors_1._syncFromEditors)(beans, { event });
             edits = model.getEditMap();
         }
         if (res && position) {
@@ -17112,6 +17142,7 @@ class EditService extends beanStub_1.BeanStub {
         const { beans } = this;
         const hasValidationErrors = this.model.getCellValidationModel().getCellValidationMap().size > 0 ||
             this.model.getRowValidationModel().getRowValidationMap().size > 0;
+        const editsToDelete = [];
         for (const rowNode of rowNodes) {
             const editRow = edits.get(rowNode);
             for (const column of editRow.keys()) {
@@ -17119,22 +17150,38 @@ class EditService extends beanStub_1.BeanStub {
                 const position = { rowNode, column };
                 const cellCtrl = (0, controllers_1._getCellCtrl)(beans, position);
                 const valueChanged = (0, editors_1._valuesDiffer)(editValue);
-                if (!cancel && valueChanged && !hasValidationErrors) {
-                    // we suppressRefreshCell because the call to rowNode.setDataValue() results in change detection
-                    // getting triggered, which results in all cells getting refreshed. we do not want this refresh
-                    // to happen on this call as we want to call it explicitly below. otherwise refresh gets called twice.
-                    // if we only did this refresh (and not the one below) then the cell would flash and not be forced.
-                    if (cellCtrl) {
-                        cellCtrl.suppressRefreshCell = true;
-                    }
-                    rowNode.setDataValue(column, editValue.newValue, 'commit');
-                    if (cellCtrl) {
-                        cellCtrl.suppressRefreshCell = false;
+                const isCancelAfterEnd = cellCtrl?.comp?.getCellEditor()?.isCancelAfterEnd?.();
+                if (!cancel && !isCancelAfterEnd && valueChanged && !hasValidationErrors) {
+                    const success = this.setNodeDataValue(rowNode, column, editValue.newValue);
+                    if (!success) {
+                        editsToDelete.push(position);
                     }
-                    cellCtrl?.refreshCell(FORCE_REFRESH);
                 }
+                cellCtrl?.refreshCell(FORCE_REFRESH);
             }
         }
+        editsToDelete.forEach((position) => {
+            this.model.clearEditValue(position);
+        });
+    }
+    setNodeDataValue(rowNode, column, newValue, refreshCell) {
+        const { beans } = this;
+        const cellCtrl = (0, controllers_1._getCellCtrl)(beans, { rowNode, column });
+        // we suppressRefreshCell because the call to rowNode.setDataValue() results in change detection
+        // getting triggered, which results in all cells getting refreshed. we do not want this refresh
+        // to happen on this call as we want to call it explicitly below. otherwise refresh gets called twice.
+        // if we only did this refresh (and not the one below) then the cell would flash and not be forced.
+        if (cellCtrl) {
+            cellCtrl.suppressRefreshCell = true;
+        }
+        const success = rowNode.setDataValue(column, newValue, 'commit');
+        if (cellCtrl) {
+            cellCtrl.suppressRefreshCell = false;
+        }
+        if (refreshCell) {
+            cellCtrl?.refreshCell(FORCE_REFRESH);
+        }
+        return success;
     }
     setEditMap(edits, params) {
         this.strategy ?? (this.strategy = this.createStrategy());
@@ -17258,8 +17305,8 @@ class EditService extends beanStub_1.BeanStub {
             return;
         }
         this.model.clearEditValue(cellPosition);
-        (0, editors_1._destroyEditors)(this.beans, [cellPosition]);
-        (0, editors_1._setupEditor)(this.beans, cellPosition);
+        (0, editors_1._destroyEditors)(this.beans, [cellPosition], { silent: true });
+        (0, editors_1._setupEditor)(this.beans, cellPosition, { silent: true });
         (0, editors_1._populateModelValidationErrors)(this.beans);
         cellCtrl?.refreshCell(FORCE_REFRESH);
         // refresh the styles directly rather than through refreshRow as that causes the group cell renderer to
@@ -17351,6 +17398,12 @@ class EditService extends beanStub_1.BeanStub {
         const { beans } = this;
         this.strategy ?? (this.strategy = this.createStrategy());
         const source = this.isBatchEditing() ? 'ui' : 'api';
+        if (!eventSource || KEEP_EDITOR_SOURCES.has(eventSource)) {
+            // editApi or undoRedoApi apply change without involving the editor
+            (0, editors_1._syncFromEditor)(beans, position, newValue, eventSource);
+            // a truthy return here indicates the operation succeeded, and if invoked from rowNode.setDataValue, will not result in a cell value change event
+            return this.setNodeDataValue(position.rowNode, position.column, newValue, false);
+        }
         const existing = this.model.getEdit(position);
         if (existing) {
             if (existing.newValue === newValue) {
@@ -17535,6 +17588,9 @@ class EditService extends beanStub_1.BeanStub {
         const label = translate('ariaPendingChange', 'Pending Change');
         this.beans.ariaAnnounce?.announceValue(label, 'pendingChange');
     }
+    allowedFocusTargetOnValidation(cellPosition) {
+        return (0, controllers_1._getCellCtrl)(this.beans, cellPosition);
+    }
 }
 exports.EditService = EditService;
 
@@ -17568,6 +17624,7 @@ class BaseEditStrategy extends beanStub_1.BeanStub {
         let cellCtrl;
         const previous = event['previousParams'];
         const { editSvc, beans } = this;
+        const sourceEvent = event.type === 'cellFocused' ? event.sourceEvent : null;
         if (previous) {
             cellCtrl = (0, controllers_1._getCellCtrl)(beans, previous);
         }
@@ -17575,9 +17632,6 @@ class BaseEditStrategy extends beanStub_1.BeanStub {
         const isFocusCleared = event.type === 'cellFocusCleared';
         // check if any editors open
         if (editSvc.isEditing(undefined, { withOpenEditor: true })) {
-            if (cellCtrl && !isFocusCleared && editSvc.checkNavWithValidation(cellCtrl, event) === 'block-stop') {
-                return;
-            }
             // if focus is clearing, we should stop editing
             // or cancel the editing if `block` and `hasErrors`
             const { column, rowIndex, rowPinned } = event;
@@ -17586,12 +17640,19 @@ class BaseEditStrategy extends beanStub_1.BeanStub {
                 rowNode: (0, positionUtils_1._getRowNode)(beans, { rowIndex: rowIndex, rowPinned }),
             };
             const isBlock = gos.get('invalidEditValueMode') === 'block';
-            const hasError = isBlock && !!editModelSvc?.getCellValidationModel().hasCellValidation(cellPositionFromEvent);
+            if (isBlock) {
+                // if we are blocking on invalid edits, focus changes don't stop current editing
+                return;
+            }
+            const shouldRevert = !isBlock;
+            const hasError = !!editModelSvc?.getCellValidationModel().hasCellValidation(cellPositionFromEvent);
+            const shouldCancel = shouldRevert && hasError;
             // if we don't have a previous cell, we don't need to force stopEditing
             const result = previous || isFocusCleared
                 ? editSvc.stopEditing(undefined, {
-                    cancel: hasError,
-                    source: isFocusCleared ? 'api' : undefined,
+                    cancel: shouldCancel,
+                    source: isFocusCleared && shouldRevert ? 'api' : undefined,
+                    event: sourceEvent,
                 })
                 : true;
             // editSvc didn't handle the stopEditing, we need to do more ourselves
@@ -17611,7 +17672,7 @@ class BaseEditStrategy extends beanStub_1.BeanStub {
     isCellEditable({ rowNode, column }, _source = 'ui') {
         return column.isColumnFunc(rowNode, column.getColDef().editable);
     }
-    stop(cancel) {
+    stop(cancel, event) {
         const editingCells = this.model.getEditPositions();
         const results = { all: [], pass: [], fail: [] };
         editingCells.forEach((cell) => {
@@ -17634,7 +17695,7 @@ class BaseEditStrategy extends beanStub_1.BeanStub {
         const actions = this.processValidationResults(results);
         if (actions.destroy.length > 0) {
             actions.destroy.forEach((cell) => {
-                (0, editors_1._destroyEditor)(this.beans, cell);
+                (0, editors_1._destroyEditor)(this.beans, cell, { event });
                 this.model.stop(cell);
             });
         }
@@ -17833,6 +17894,7 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
     constructor() {
         super(...arguments);
         this.beanName = 'fullRow';
+        this.startedRows = [];
     }
     isCellEditable(position, source = 'ui') {
         const editable = super.isCellEditable(position, source);
@@ -17875,9 +17937,8 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
         if (this.rowNode !== rowNode) {
             super.cleanupEditors(position);
         }
-        if (!this.model.hasEdits({ rowNode })) {
-            this.dispatchRowEvent({ rowNode }, 'rowEditingStarted');
-        }
+        this.dispatchRowEvent({ rowNode }, 'rowEditingStarted');
+        this.startedRows.push(rowNode);
         const columns = this.beans.visibleCols.allCols;
         const cells = [];
         columns.forEach((column) => {
@@ -17911,31 +17972,34 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             keep: [],
         };
     }
-    stop(cancel) {
+    stop(cancel, event) {
         const { rowNode } = this;
         if (rowNode && !this.model.hasRowEdits(rowNode)) {
             return false;
         }
-        const rowEdits = this.model.getEditRow(rowNode);
-        let hadRowEdits = false;
-        for (const [, edit] of rowEdits) {
-            if ((0, editors_1._valuesDiffer)(edit)) {
-                hadRowEdits = true;
-                break;
-            }
+        const changedRows = [];
+        if (!cancel) {
+            this.model.getEditMap().forEach((rowEdits, rowNode) => {
+                if (!rowEdits || rowEdits.size === 0) {
+                    return;
+                }
+                for (const edit of rowEdits.values()) {
+                    if ((0, editors_1._valuesDiffer)(edit)) {
+                        changedRows.push(rowNode);
+                        // early return, we only need to know if there are any edits
+                        break;
+                    }
+                }
+            });
         }
         // rerun validation, new values might have triggered row validations
         (0, editors_1._populateModelValidationErrors)(this.beans);
         if (!cancel && this.editSvc?.checkNavWithValidation({ rowNode }) === 'block-stop') {
             return false;
         }
-        super.stop(cancel);
-        if (rowNode) {
-            if (hadRowEdits) {
-                this.dispatchRowEvent({ rowNode }, 'rowValueChanged');
-            }
-            this.dispatchRowEvent({ rowNode }, 'rowEditingStopped');
-        }
+        super.stop(cancel, event);
+        changedRows.forEach((rowNode) => this.dispatchRowEvent({ rowNode }, 'rowValueChanged'));
+        this.cleanupEditors({ rowNode }, true);
         this.rowNode = undefined;
         return true;
     }
@@ -17945,20 +18009,20 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
         if (prev?.rowIndex === rowIndex || event.sourceEvent instanceof KeyboardEvent) {
             return;
         }
-        if (this.model.getRowValidationModel().getRowValidationMap().size > 0) {
+        const prevCell = (0, controllers_1._getCellCtrl)(this.beans, prev);
+        const isBlock = this.gos.get('invalidEditValueMode') === 'block';
+        if (isBlock &&
+            prevCell &&
+            (this.model.getCellValidationModel().getCellValidation(prevCell) ||
+                this.model.getRowValidationModel().getRowValidation(prevCell))) {
             return;
         }
         super.onCellFocusChanged(event);
-        const previous = event['previousParams'];
-        if (previous) {
-            (0, controllers_1._getRowCtrl)(this.beans, previous)?.refreshRow({ suppressFlash: true, force: true });
-        }
     }
-    cleanupEditors({ rowNode } = {}, includeEditing) {
-        super.cleanupEditors({ rowNode }, includeEditing);
-        if (rowNode) {
-            this.dispatchRowEvent({ rowNode: this.rowNode }, 'rowEditingStopped');
-        }
+    cleanupEditors(position = {}, includeEditing) {
+        super.cleanupEditors(position, includeEditing);
+        this.startedRows.forEach((rowNode) => this.dispatchRowEvent({ rowNode }, 'rowEditingStopped'));
+        this.startedRows.length = 0;
     }
     // returns null if no navigation should be performed
     moveToNextEditingCell(prevCell, backwards, event, source = 'ui') {
@@ -17989,38 +18053,19 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             return null;
         }
         if (nextCell == null) {
-            return preventNavigation;
+            return false;
         }
         const nextPos = nextCell.cellPosition;
         const prevEditable = prevCell.isCellEditable();
         const nextEditable = nextCell.isCellEditable();
         const rowsMatch = nextPos && prevPos.rowIndex === nextPos.rowIndex && prevPos.rowPinned === nextPos.rowPinned;
-        if (!rowsMatch) {
-            // run validation to gather row-level validation errors
-            (0, editors_1._populateModelValidationErrors)(this.beans);
-            if (this.model.getRowValidationModel().getRowValidationMap().size > 0) {
-                // if there was a previous row validation error, we need to check if that's still the case
-                if (this.editSvc.checkNavWithValidation(prevCell, event) === 'block-stop') {
-                    return true;
-                }
-            }
-            else {
-                const rowPreventNavigation = this.editSvc.checkNavWithValidation(prevCell, event) === 'block-stop';
-                if (rowPreventNavigation) {
-                    return true;
-                }
-            }
-            if (preventNavigation && this.model.getRowValidationModel().getRowValidation(prevCell)) {
-                return true;
-            }
-        }
         if (prevEditable) {
             this.setFocusOutOnEditor(prevCell);
         }
         if (nextEditable && !preventNavigation) {
             if (!nextCell.comp?.getCellEditor()) {
                 // editor missing because it was outside the viewport during creating phase, attempt to create it now
-                (0, editors_1._setupEditor)(this.beans, nextCell, undefined, event, true);
+                (0, editors_1._setupEditor)(this.beans, nextCell, { event, cellStartedEdit: true });
             }
             this.setFocusInOnEditor(nextCell);
             nextCell.focusCell(false, event);
@@ -18029,7 +18074,7 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             nextCell.focusCell(true, event);
         }
         if (!rowsMatch && !preventNavigation) {
-            super.cleanupEditors(nextCell, true);
+            this.cleanupEditors(nextCell, true);
             this.editSvc.startEditing(nextCell, { startedEdit: true, event, source, ignoreEventKey: true });
         }
         prevCell.rowCtrl?.refreshRow({ suppressFlash: true, force: true });
@@ -18038,6 +18083,7 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
     destroy() {
         super.destroy();
         this.rowNode = undefined;
+        this.startedRows.length = 0;
     }
 }
 exports.FullRowEditStrategy = FullRowEditStrategy;
@@ -18086,8 +18132,8 @@ class SingleCellEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
     dispatchRowEvent(_position, _type) {
         // NOP - single cell edit strategy does not dispatch row events
     }
-    stop(cancel) {
-        super.stop(cancel);
+    stop(cancel, event) {
+        super.stop(cancel, event);
         this.rowNode = undefined;
         this.column = undefined;
         return true;
@@ -18125,7 +18171,7 @@ class SingleCellEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             // undesirable so we suspend the model while we find the next cell.
             this.model.suspend(true);
         }
-        else {
+        if (!preventNavigation) {
             // before we stop editing, we need to focus the cell element
             // so the grid doesn't detect that focus has left the grid
             prevCell.eGui.focus();
@@ -18156,7 +18202,7 @@ class SingleCellEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             return null;
         }
         if (nextCell == null) {
-            return preventNavigation;
+            return false;
         }
         const nextPos = nextCell.cellPosition;
         const prevEditable = prevCell.isCellEditable();
@@ -18165,23 +18211,14 @@ class SingleCellEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
         if (!rowsMatch) {
             // run validation to gather row-level validation errors
             (0, editors_1._populateModelValidationErrors)(this.beans);
-            if (this.model.getRowValidationModel().getRowValidationMap().size > 0) {
-                // if there was a previous row validation error, we need to check if that's still the case
-                if (this.editSvc.checkNavWithValidation(prevCell, event) === 'block-stop') {
-                    return true;
-                }
-            }
-            else {
+            if ((this.model.getRowValidationModel().getRowValidationMap().size ?? 0) === 0) {
                 const rowPreventNavigation = this.editSvc.checkNavWithValidation(prevCell, event) === 'block-stop';
                 if (rowPreventNavigation) {
                     return true;
                 }
             }
-            if (preventNavigation && this.model.getRowValidationModel().getRowValidation(prevCell)) {
-                return true;
-            }
         }
-        if (prevEditable) {
+        if (prevEditable && !preventNavigation) {
             this.setFocusOutOnEditor(prevCell);
         }
         if (!rowsMatch && !preventNavigation) {
@@ -18193,14 +18230,11 @@ class SingleCellEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
             nextCell.focusCell(false, event);
             if (!nextCell.comp?.getCellEditor()) {
                 // editor missing because it was outside the viewport during creating phase, attempt to create it now
-                (0, editors_1._setupEditor)(this.beans, nextCell, undefined, event, true);
+                (0, editors_1._setupEditor)(this.beans, nextCell, { event, cellStartedEdit: true });
             }
             this.setFocusInOnEditor(nextCell);
         }
         else {
-            if (preventNavigation && this.model.getCellValidationModel().getCellValidation(prevCell)) {
-                return true;
-            }
             nextCell.focusCell(true, event);
         }
         prevCell.rowCtrl?.refreshRow({ suppressFlash: true, force: true });
@@ -18394,7 +18428,14 @@ function _getRowCtrl(beans, inputs = {}) {
     }
     const { rowModel, rowRenderer } = beans;
     let { rowNode } = inputs;
-    rowNode ?? (rowNode = rowId ? (0, positionUtils_1._getRowById)(beans, rowId, rowPinned) : rowModel.getRow(rowIndex));
+    if (!rowNode) {
+        if (rowId) {
+            rowNode = (0, positionUtils_1._getRowById)(beans, rowId, rowPinned);
+        }
+        else if (rowIndex != null) {
+            rowNode = rowModel.getRow(rowIndex);
+        }
+    }
     return rowRenderer.getRowCtrls(rowNode ? [rowNode] : [])?.[0];
 }
 exports._getRowCtrl = _getRowCtrl;
@@ -18513,7 +18554,7 @@ const getCellEditorInstances = (beans, params = {}) => getCellEditorInstanceMap(
 exports.getCellEditorInstances = getCellEditorInstances;
 function _setupEditors(beans, editingCells, position, key, event, cellStartedEdit) {
     if (editingCells.length === 0 && position?.rowNode && position?.column) {
-        _setupEditor(beans, position, key, event, cellStartedEdit);
+        _setupEditor(beans, position, { key, event, cellStartedEdit });
     }
     const { valueSvc, editSvc, editModelSvc } = beans;
     const { rowNode, column } = position ?? {};
@@ -18535,7 +18576,11 @@ function _setupEditors(beans, editingCells, position, key, event, cellStartedEdi
             continue;
         }
         const shouldStartEditing = cellStartedEdit && rowNode === curCellCtrl.rowNode && curCellCtrl.column === column;
-        _setupEditor(beans, { rowNode: rowNode, column: curCellCtrl.column }, shouldStartEditing ? key : null, shouldStartEditing ? event : null, shouldStartEditing);
+        _setupEditor(beans, { rowNode: rowNode, column: curCellCtrl.column }, {
+            key: shouldStartEditing ? key : null,
+            event: shouldStartEditing ? event : null,
+            cellStartedEdit: shouldStartEditing,
+        });
     }
     return;
 }
@@ -18547,17 +18592,18 @@ function _valuesDiffer({ newValue, oldValue }) {
     return newValue !== oldValue;
 }
 exports._valuesDiffer = _valuesDiffer;
-function _setupEditor(beans, position, key, event, cellStartedEdit) {
+function _setupEditor(beans, position, params) {
+    const { key, event, cellStartedEdit, silent } = params ?? {};
     const cellCtrl = (0, controllers_1._getCellCtrl)(beans, position);
     const editorComp = cellCtrl?.comp?.getCellEditor();
     const editorParams = _createEditorParams(beans, position, key, cellStartedEdit);
-    const oldValue = beans.valueSvc.getValue(position.column, position.rowNode, undefined, 'api');
+    const previousEdit = beans.editModelSvc?.getEdit(position);
     // if key is a single character, then we treat it as user input
     let newValue = key?.length === 1 ? key : editorParams.value;
     if (newValue === undefined) {
-        newValue = oldValue;
+        newValue = previousEdit?.oldValue;
     }
-    beans.editModelSvc?.setEdit(position, { newValue: newValue ?? exports.UNEDITED, oldValue, state: 'editing' });
+    beans.editModelSvc?.setEdit(position, { newValue: newValue ?? exports.UNEDITED, state: 'editing' });
     if (editorComp) {
         // don't reinitialise, just refresh if possible
         editorComp.refresh?.(editorParams);
@@ -18575,7 +18621,9 @@ function _setupEditor(beans, position, key, event, cellStartedEdit) {
         cellCtrl.editCompDetails = compDetails;
         cellCtrl.comp?.setEditDetails(compDetails, popup, popupLocation, beans.gos.get('reactiveCustomComponents'));
         cellCtrl?.rowCtrl?.refreshRow({ suppressFlash: true });
-        beans.editSvc?.dispatchCellEvent(position, null, 'cellEditingStarted');
+        if (!silent) {
+            beans.editSvc?.dispatchCellEvent(position, event, 'cellEditingStarted');
+        }
     }
     return;
 }
@@ -18589,10 +18637,6 @@ function _valueFromEditor(cancel, cellComp) {
     if (!cellEditor) {
         return noValueResult;
     }
-    const userWantsToCancel = cellEditor.isCancelAfterEnd?.();
-    if (userWantsToCancel) {
-        return noValueResult;
-    }
     const validationErrors = cellEditor.getValidationErrors?.();
     if ((validationErrors?.length ?? 0) > 0) {
         return noValueResult;
@@ -18673,7 +18717,7 @@ function checkAndPreventDefault(params, event) {
     }
     return params;
 }
-function _syncFromEditors(beans) {
+function _syncFromEditors(beans, params) {
     beans.editModelSvc?.getEditPositions().forEach((cellId) => {
         const cellCtrl = (0, controllers_1._getCellCtrl)(beans, cellId);
         if (!cellCtrl) {
@@ -18683,12 +18727,12 @@ function _syncFromEditors(beans) {
         if (!newValueExists) {
             return;
         }
-        _syncFromEditor(beans, cellId, newValue);
+        _syncFromEditor(beans, cellId, newValue, undefined, params);
     });
 }
 exports._syncFromEditors = _syncFromEditors;
-function _syncFromEditor(beans, position, newValue, source) {
-    const { editModelSvc, valueSvc, eventSvc } = beans;
+function _syncFromEditor(beans, position, newValue, _source, params) {
+    const { editModelSvc, valueSvc } = beans;
     if (!editModelSvc) {
         return;
     }
@@ -18696,10 +18740,9 @@ function _syncFromEditor(beans, position, newValue, source) {
     if (!(rowNode && column)) {
         return;
     }
-    const oldValue = valueSvc.getValue(column, rowNode, undefined, 'api');
+    const oldValue = editModelSvc.getEdit(position)?.oldValue ?? valueSvc.getValue(column, rowNode, undefined, 'api');
     const cellCtrl = (0, controllers_1._getCellCtrl)(beans, position);
     const hasEditor = !!cellCtrl?.comp?.getCellEditor();
-    const prevEditValue = editModelSvc?.getEdit(position)?.newValue;
     // Only handle undefined, null is used to indicate a cleared cell value
     if (newValue === undefined) {
         newValue = exports.UNEDITED;
@@ -18708,40 +18751,35 @@ function _syncFromEditor(beans, position, newValue, source) {
     editModelSvc.setEdit(position, { newValue, oldValue, state: hasEditor ? 'editing' : 'changed' });
     // re-read the value once it's been through all the formatting and parsing
     const { value } = valueSvc.getValueForDisplay(column, rowNode, true);
-    editModelSvc.getEdit(position).newValue = value;
-    if (prevEditValue === newValue || hasEditor) {
+    newValue = value;
+    // persist newly formatted value
+    editModelSvc.setEdit(position, { newValue });
+    if (newValue === oldValue || hasEditor) {
         // If the value hasn't changed or the editor is currently open, we don't need to dispatch an event
         return;
     }
-    const { rowIndex, rowPinned, data } = rowNode;
-    eventSvc.dispatchEvent({
-        type: 'cellEditValuesChanged',
-        value: newValue,
-        colDef: column.getColDef(),
-        newValue,
-        oldValue,
-        source,
-        column,
-        rowIndex,
-        rowPinned,
-        data,
-        node: rowNode,
+    const edit = editModelSvc.getEdit(position);
+    beans.editSvc?.dispatchCellEvent(position, params?.event, 'cellValueChanged', {
+        valueChanged: edit && _valuesDiffer(edit),
+        newValue: edit?.newValue,
+        oldValue: edit?.oldValue,
     });
 }
 exports._syncFromEditor = _syncFromEditor;
-function _destroyEditors(beans, edits) {
+function _destroyEditors(beans, edits, params) {
     if (!edits) {
         edits = beans.editModelSvc?.getEditPositions();
     }
-    edits.forEach((cellPosition) => _destroyEditor(beans, cellPosition));
+    edits.forEach((cellPosition) => _destroyEditor(beans, cellPosition, params));
 }
 exports._destroyEditors = _destroyEditors;
-function _destroyEditor(beans, position) {
+function _destroyEditor(beans, position, params) {
+    const { editSvc, editModelSvc } = beans;
     const { rowNode, column } = position;
     const cellCtrl = (0, controllers_1._getCellCtrl)(beans, position);
     if (!cellCtrl) {
-        if (beans.editModelSvc?.hasEdits(position) && rowNode && column) {
-            beans.editModelSvc?.setState(position, 'changed');
+        if (editModelSvc?.hasEdits(position) && rowNode && column) {
+            editModelSvc?.setState(position, 'changed');
         }
         return;
     }
@@ -18751,23 +18789,28 @@ function _destroyEditor(beans, position) {
         return;
     }
     const errorMessages = comp?.getCellEditor()?.getValidationErrors?.();
-    const cellValidationModel = beans.editModelSvc?.getCellValidationModel();
+    const cellValidationModel = editModelSvc?.getCellValidationModel();
     if (errorMessages?.length) {
         cellValidationModel?.setCellValidation(position, { errorMessages });
     }
     else {
         cellValidationModel?.clearCellValidation(position);
     }
-    comp?.setEditDetails(); // passing nothing stops editing
-    if (beans.editModelSvc?.hasEdits(position) && rowNode && column) {
-        beans.editModelSvc?.setState(position, 'changed');
+    const wasEditing = editModelSvc?.getEdit(position)?.state === 'editing';
+    if (editModelSvc?.hasEdits(position) && rowNode && column) {
+        editModelSvc?.setState(position, 'changed');
     }
+    comp?.setEditDetails(); // passing nothing stops editing
     comp?.refreshEditStyles(false, false);
     cellCtrl?.refreshCell({ force: true, suppressFlash: true });
-    const edit = beans.editModelSvc?.getEdit(position);
-    beans.editSvc?.dispatchCellEvent(position, null, 'cellEditingStopped', {
-        valueChanged: edit && _valuesDiffer(edit),
-    });
+    const edit = editModelSvc?.getEdit(position);
+    if (wasEditing && edit?.state === 'changed' && !params?.silent) {
+        editSvc?.dispatchCellEvent(position, params?.event, 'cellEditingStopped', {
+            valueChanged: edit && _valuesDiffer(edit),
+            newValue: edit?.newValue,
+            oldValue: edit?.oldValue,
+        });
+    }
 }
 exports._destroyEditor = _destroyEditor;
 function _populateModelValidationErrors(beans) {
@@ -20364,7 +20407,7 @@ class RowNode {
         if (!column) {
             return false;
         }
-        const oldValue = valueSvc.getValueForDisplay(column, this).value;
+        const oldValue = valueSvc.getValueForDisplay(column, this, undefined, undefined, 'api').value;
         if (gos.get('readOnlyEdit')) {
             const { beans: { eventSvc }, data, rowIndex, rowPinned, } = this;
             eventSvc.dispatchEvent({
@@ -21284,9 +21327,10 @@ class BaseGridSerializingSession {
         return value ?? '';
     }
     extractRowCellValue(column, currentColumnIndex, accumulatedRowIndex, type, node) {
+        const isFullWidthGroup = currentColumnIndex === 0 && (0, gridOptionsUtils_1._isFullWidthGroupRow)(this.gos, node, this.colModel.isPivotMode());
         if (this.processRowGroupCallback &&
             (this.gos.get('treeData') || node.group) &&
-            column.isRowGroupDisplayed(node.rowGroupColumn?.getColId() ?? '')) {
+            (column.isRowGroupDisplayed(node.rowGroupColumn?.getColId() ?? '') || isFullWidthGroup)) {
             return { value: this.processRowGroupCallback((0, gridOptionsUtils_1._addGridCommonParams)(this.gos, { column, node })) ?? '' };
         }
         if (this.processCellCallback) {
@@ -21305,7 +21349,6 @@ class BaseGridSerializingSession {
         const isTreeData = this.gos.get('treeData');
         const valueService = this.valueSvc;
         const isGrandTotalRow = node.level === -1 && node.footer;
-        const isFullWidthGroup = currentColumnIndex === 0 && (0, gridOptionsUtils_1._isFullWidthGroupRow)(this.gos, node, this.colModel.isPivotMode());
         const isMultiAutoCol = column.colDef.showRowGroup === true && (node.group || isTreeData);
         // when using single auto group column or group row, create arrow separated string of group vals
         if (!isGrandTotalRow && (isFullWidthGroup || isMultiAutoCol)) {
@@ -27687,8 +27730,10 @@ class TextFilterHandler extends simpleFilterHandler_1.SimpleFilterHandler {
     }
     updateParams(params) {
         super.updateParams(params);
-        this.matcher = params.textMatcher ?? defaultMatcher;
-        this.formatter = params.textFormatter ?? (params.caseSensitive ? defaultFormatter : defaultLowercaseFormatter);
+        const filterParams = params.filterParams;
+        this.matcher = filterParams.textMatcher ?? defaultMatcher;
+        this.formatter =
+            filterParams.textFormatter ?? (filterParams.caseSensitive ? defaultFormatter : defaultLowercaseFormatter);
     }
     evaluateNullValue(filterType) {
         const filterTypesAllowNulls = ['notEqual', 'notContains', 'blank'];
@@ -29958,7 +30003,16 @@ class GridBodyScrollFeature extends beanStub_1.BeanStub {
     // adding and removing the grid from the DOM both resets the scroll position and
     // triggers a resize event, so notify listeners if the scroll position has changed
     checkScrollLeft() {
-        if (this.scrollLeft !== this.centerRowsCtrl.getCenterViewportScrollLeft()) {
+        const scrollLeft = this.scrollLeft;
+        let hasHorizontalScrollersOutOfSync = false;
+        for (const source of HORIZONTAL_SOURCES) {
+            const viewport = this.getViewportForSource(source);
+            if (viewport.scrollLeft !== scrollLeft) {
+                hasHorizontalScrollersOutOfSync = true;
+                break;
+            }
+        }
+        if (hasHorizontalScrollersOutOfSync) {
             this.onHScroll(VIEWPORT);
         }
     }
@@ -45011,7 +45065,7 @@ class CellCtrl extends beanStub_1.BeanStub {
     }
     onPopupEditorClosed() {
         const { editSvc } = this.beans;
-        if (!editSvc?.isEditing(this)) {
+        if (!editSvc?.isEditing(this, { withOpenEditor: true })) {
             return;
         }
         // note: this happens because of a click outside of the grid or if the popupEditor
@@ -45792,6 +45846,15 @@ class CellKeyboardListenerFeature extends beanStub_1.BeanStub {
     }
     onF2KeyDown(event) {
         const { cellCtrl, beans: { editSvc }, } = this;
+        const editing = editSvc?.isEditing();
+        if (editing) {
+            // re-run ALL validations, F2 is used to initiate a new edit. If we have one already in progress,
+            // we want to ensure it's valid before initiating a new edit cycle
+            (0, editors_1._populateModelValidationErrors)(this.beans);
+            if (editSvc?.checkNavWithValidation(undefined, event) === 'block-stop') {
+                return;
+            }
+        }
         editSvc?.startEditing(cellCtrl, { startedEdit: true, event });
     }
     onEscapeKeyDown(event) {
@@ -61277,6 +61340,7 @@ exports.AG_GRID_ERRORS = {
     287: () => '`api.doFilterAction()` requires `enableFilterHandlers = true',
     288: () => '`api.getColumnFilterModel(key, true)` requires `enableFilterHandlers = true',
     289: ({ rowModelType }) => `Row Model '${rowModelType}' is not supported with Batch Editing`,
+    290: ({ rowIndex, rowPinned }) => `Row with index '${rowIndex}' and pinned state '${rowPinned}' not found`,
 };
 function getError(errorId, args) {
     const msgOrFunc = exports.AG_GRID_ERRORS[errorId];
@@ -63781,7 +63845,7 @@ exports.VanillaFrameworkOverrides = VanillaFrameworkOverrides;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.VERSION = void 0;
 // DO NOT UPDATE MANUALLY: Generated from script during build time
-exports.VERSION = '34.0.0';
+exports.VERSION = '34.0.2';
 
 
 /***/ }),