@adaptabletools/adaptable 11.1.1-canary.0 → 11.1.1

package/src/agGrid/ActionColumnRenderer.js

@@ -1,85 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionColumnRenderer = exports.CustomTooltip = void 0;
+exports.ActionColumnRenderer = void 0;
 const tslib_1 = require("tslib");
 const SimpleButton_1 = tslib_1.__importDefault(require("../components/SimpleButton"));
 const react_dom_1 = require("react-dom");
 const React = tslib_1.__importStar(require("react"));
-class CustomTooltip {
-    init(params) {
-        this.eGui = document.createElement('div');
-        this.eGui.classList.add('custom-tooltip');
-        let { field, lastValidation, validationFailedMsg } = params.value;
-        this.eGui.innerHTML = `
-        <div class="validation-msg">
-          FIELD-${field.toUpperCase()} - invalid value:
-          "<span class="invalid-value"> ${lastValidation} </span>",
-          ${validationFailedMsg}
-        </div>
-    `;
-    }
-    getGui() {
-        return this.eGui;
-    }
-}
-exports.CustomTooltip = CustomTooltip;
+const uuid_1 = require("../components/utils/uuid");
 class ActionColumnRenderer {
     // gets called once before the renderer is used
     init(params) {
         var _a;
         const adaptable = params.api.__adaptable;
-        let actionCol = (_a = adaptable.api.userInterfaceApi
+        const actionCol = (_a = adaptable.api.userInterfaceApi
             .getAllActionColumn()) === null || _a === void 0 ? void 0 : _a.find((ac) => ac.columnId == params.colDef.colId);
-        if (actionCol) {
+        if (actionCol && actionCol.actionColumnButton) {
+            let actionButtons = Array.isArray(actionCol.actionColumnButton)
+                ? actionCol.actionColumnButton
+                : [actionCol.actionColumnButton];
+            if (!actionButtons.length) {
+                return;
+            }
+            // actionButtons don't have IDs, so we need to generate them to be used later as a react component key
+            actionButtons = actionButtons.map((actionButton) => (Object.assign(Object.assign({}, actionButton), { Uuid: uuid_1.createUuid() })));
             // create the cell
             this.eGui = document.createElement('div');
             this.eGui.className = 'ab-ActionColumn';
-            let pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node);
-            let button = actionCol.actionColumnButton;
-            let context = {
-                actionColumn: actionCol,
-                primaryKeyValue: pkValue,
-                rowNode: params.node,
-                adaptableApi: adaptable.api,
-            };
             // if its a group node then only show if set to do so
             if (adaptable.api.gridApi.isGroupRowNode(params.node) && !actionCol.includeGroupedRows) {
                 this.eGui.innerHTML = '';
                 return;
             }
-            if (button.hidden && button.hidden(button, context)) {
-                this.eGui.innerHTML = '';
-                return;
-            }
-            const disabled = button.disabled && button.disabled(button, context);
-            const renderButton = (adaptableApi, context) => {
-                var _a, _b;
-                const defaultIconProps = {
-                    style: {
-                        height: 15,
-                        width: 15,
-                    },
-                };
-                const iconProps = button.icon && Object.assign({}, defaultIconProps, button.icon);
-                let buttonStyle = adaptableApi.internalApi.getStyleForButton(button, context);
-                let buttonLabel = adaptableApi.internalApi.getLabelForButton(button, context);
-                let buttonTooltip = adaptableApi.internalApi.getTooltipForButton(button, context);
-                const handleClick = () => {
-                    button.onClick(button, context);
-                    // Timeout to let any updates to be done before re-rendering the component
-                    setTimeout(() => {
-                        // when called again it triggers a re-render
-                        // https:reactjs.org/docs/react-dom.html#render
-                        doRender();
-                    }, 16);
-                };
-                return (React.createElement(SimpleButton_1.default, { key: button.Uuid, variant: (_a = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.variant) !== null && _a !== void 0 ? _a : 'text', disabled: disabled, tooltip: buttonTooltip, tone: (_b = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone) !== null && _b !== void 0 ? _b : 'none', onClick: handleClick, className: buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className, accessLevel: 'Full' },
-                    button.icon ? React.createElement("img", Object.assign({}, iconProps)) : null,
-                    buttonLabel));
+            const pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node);
+            const buttonContext = {
+                actionColumn: actionCol,
+                primaryKeyValue: pkValue,
+                rowNode: params.node,
+                adaptableApi: adaptable.api,
+            };
+            const renderActionButtons = (buttons, adaptableApi, context) => {
+                return (React.createElement(React.Fragment, null, buttons.map((button) => {
+                    var _a, _b;
+                    if (button.hidden && button.hidden(button, context)) {
+                        return;
+                    }
+                    const defaultIconProps = {
+                        style: {
+                            height: 15,
+                            width: 15,
+                        },
+                    };
+                    const iconProps = button.icon && Object.assign({}, defaultIconProps, button.icon);
+                    const buttonStyle = adaptableApi.internalApi.getStyleForButton(button, context);
+                    const buttonLabel = adaptableApi.internalApi.getLabelForButton(button, context);
+                    const buttonTooltip = adaptableApi.internalApi.getTooltipForButton(button, context);
+                    const handleClick = () => {
+                        button.onClick(button, context);
+                        // Timeout to let any updates to be done before re-rendering the component
+                        setTimeout(() => {
+                            // when called again it triggers a re-render
+                            // https:reactjs.org/docs/react-dom.html#render
+                            doRender();
+                        }, 16);
+                    };
+                    const disabled = button.disabled && button.disabled(button, context);
+                    return (React.createElement(SimpleButton_1.default, { key: button.Uuid, variant: (_a = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.variant) !== null && _a !== void 0 ? _a : 'text', disabled: disabled, tooltip: buttonTooltip, tone: (_b = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone) !== null && _b !== void 0 ? _b : 'none', onClick: handleClick, className: buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className, accessLevel: 'Full' },
+                        button.icon ? React.createElement("img", Object.assign({}, iconProps)) : null,
+                        buttonLabel));
+                })));
             };
             const eGui = this.eGui;
             function doRender() {
-                react_dom_1.render(renderButton(adaptable.api, context), eGui);
+                react_dom_1.render(renderActionButtons(actionButtons, adaptable.api, buttonContext), eGui);
             }
             this.render = doRender;
             doRender();

package/src/agGrid/Adaptable.d.ts

@@ -7,7 +7,7 @@ import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
 import { ColumnSort } from '../PredefinedConfig/Common/ColumnSort';
-import { DataChangedInfo } from '../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { ReportData } from '../PredefinedConfig/ExportState';
@@ -74,6 +74,7 @@ export declare class Adaptable implements IAdaptable {
     private _id;
     private currentColumnDefs?;
     private rowListeners;
+    private isCheckedColumnDataType;
     _on: (eventName: string, callback: EmitterCallback) => (() => void);
     _onIncludeFired: (eventName: string, callback: EmitterCallback) => (() => void);
     _emit: (eventName: string, data?: any) => Promise<any>;
@@ -149,7 +150,7 @@ export declare class Adaptable implements IAdaptable {
     private updateLayoutFromGrid;
     setSelectedCells(): SelectedCellInfo | undefined;
     setSelectedRows(): SelectedRowInfo | undefined;
-    setValue(dataChangedInfo: DataChangedInfo): void;
+    setValue(cellDataChangedInfo: CellDataChangedInfo): void;
     cancelEdit(): void;
     isCellEditable(rowNode: RowNode, column: Column): boolean;
     getDistinctValuesForColumn(column: AdaptableColumn, visibleRowsOnly: boolean, skipRowNode?: RowNode, permittedValues?: any[]): GridCell[];

package/src/agGrid/Adaptable.js

@@ -100,6 +100,7 @@ class Adaptable {
     constructor() {
         this.colDefPropertyCache = new Map();
         this.gridOptionsPropertyCache = new Map();
+        this.isCheckedColumnDataType = false;
         // only for our private / internal events used within Adaptable
         // public events are emitted through the EventApi
         this._on = (eventName, callback) => {
@@ -201,7 +202,6 @@ class Adaptable {
         this.getGroupAndColumnDefs = () => {
             const colDefs = [].concat(this.currentColumnDefs || this.gridOptions.columnDefs);
             return colDefs;
-            // return this.gridOptions.columnApi.getAllColumns().map((c) => c.getColDef());
         };
         this.getColumnDefsWithCorrectVisibility = () => {
             const visibleColIds = this.api.layoutApi.getCurrentVisibleColumnIdsMap();
@@ -1483,25 +1483,27 @@ class Adaptable {
         this.agGridHelper.fireSelectionChangedEvent();
         return selectedRowInfo;
     }
-    setValue(dataChangedInfo) {
+    setValue(cellDataChangedInfo) {
         // note: because we use RowNode.setDataValue() this will cause Validation to fire
         // see https://www.ag-grid.com/javascript-data-grid/change-detection/#triggering-value-change-detection
         let newValue;
-        let dataType = dataChangedInfo.column.dataType;
+        let dataType = cellDataChangedInfo.column.dataType;
         newValue =
-            dataType == Enums_1.DataType.Number ? Number(dataChangedInfo.newValue) : dataChangedInfo.newValue;
+            dataType == Enums_1.DataType.Number
+                ? Number(cellDataChangedInfo.newValue)
+                : cellDataChangedInfo.newValue;
         if (dataType == undefined) {
             return; // no point continuing as probably a wrong  column
         }
-        if (dataChangedInfo.rowNode) {
-            dataChangedInfo.rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
+        if (cellDataChangedInfo.rowNode) {
+            cellDataChangedInfo.rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
         }
         else {
             if (this.useRowNodeLookUp) {
-                const rowNode = this.gridOptions.api.getRowNode(dataChangedInfo.primaryKeyValue);
+                const rowNode = this.gridOptions.api.getRowNode(cellDataChangedInfo.primaryKeyValue);
                 if (rowNode != null) {
-                    rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
-                    dataChangedInfo.rowNode = rowNode;
+                    rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
+                    cellDataChangedInfo.rowNode = rowNode;
                 }
             }
             else {
@@ -1509,9 +1511,9 @@ class Adaptable {
                 // prefer not to use this method but if we do then at least we can prevent further lookups once we find
                 this.gridOptions.api.getModel().forEachNode((rowNode) => {
                     if (!isUpdated) {
-                        if (dataChangedInfo.primaryKeyValue == this.getPrimaryKeyValueFromRowNode(rowNode)) {
-                            rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
-                            dataChangedInfo.rowNode = rowNode;
+                        if (cellDataChangedInfo.primaryKeyValue == this.getPrimaryKeyValueFromRowNode(rowNode)) {
+                            rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
+                            cellDataChangedInfo.rowNode = rowNode;
                             isUpdated = true;
                         }
                     }
@@ -2061,20 +2063,54 @@ class Adaptable {
         });
     }
     updateColDefsForSpecialColumns() {
+        const allColDefs = this.getGroupAndColumnDefs();
         const specialColDefs = this.getColDefsForSpecialColumns();
-        const isUserColDef = (colDef) => {
+        const isSpecialColDef = (colDef) => {
             const { type } = colDef;
             if (type === GeneralConstants_1.AB_SPECIAL_COLUMN || (Array.isArray(type) && type.includes(GeneralConstants_1.AB_SPECIAL_COLUMN))) {
-                return false;
+                return true;
             }
-            return true;
+            return false;
+        };
+        const isColGroupDef = (columnDefinition) => {
+            // @ts-ignore
+            return columnDefinition['children'] != null;
+        };
+        const processedSpecialColDefIds = [];
+        const mapColDefs = (colDefs) => {
+            return colDefs.map((colDef) => {
+                if (isColGroupDef(colDef)) {
+                    // if it's a group column, recursively map its children
+                    colDef.children = mapColDefs(colDef.children);
+                    return colDef;
+                }
+                else {
+                    if (!isSpecialColDef(colDef)) {
+                        // if it's not a special column, return it as is
+                        return colDef;
+                    }
+                    const newlyCreatedSpecialColDef = specialColDefs.find((specialColDef) => specialColDef.colId === colDef.colId);
+                    if (newlyCreatedSpecialColDef) {
+                        // if it's a special column and we have a special col def for it, return the special col def
+                        processedSpecialColDefIds.push(colDef.colId);
+                        return newlyCreatedSpecialColDef;
+                    }
+                    else {
+                        // otherwise, return the original col def
+                        return colDef;
+                    }
+                }
+            });
         };
-        // const userColDefs = this.gridOptions.columnApi
-        //   .getAllColumns()
-        // .map((col) => col.getColDef())
-        const userColDefs = this.getGroupAndColumnDefs().filter(isUserColDef);
-        const allDefs = [...userColDefs, ...specialColDefs];
-        this.safeSetColDefs(allDefs);
+        const resultColDefs = mapColDefs(allColDefs);
+        // check if there are any special colDefs that were not processed
+        // in that case, add them to the end of the colDefs
+        specialColDefs.forEach((specialColDef) => {
+            if (!processedSpecialColDefIds.includes(specialColDef.colId)) {
+                resultColDefs.push(specialColDef);
+            }
+        });
+        this.safeSetColDefs(resultColDefs);
         this.setLayout();
     }
     cleanupFloatingFilters_WORKAROUND() {
@@ -3091,7 +3127,7 @@ class Adaptable {
                     }
                     return true;
                 }
-                const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+                const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                     oldValue: params.oldValue,
                     newValue: params.newValue,
                     column: this.api.columnApi.getColumnFromId(params.column.getColId()),
@@ -3099,15 +3135,15 @@ class Adaptable {
                     rowNode: params.node,
                     trigger: 'edit',
                 });
-                if (dataChangedInfo.oldValue === dataChangedInfo.newValue) {
+                if (cellDataChangedInfo.oldValue === cellDataChangedInfo.newValue) {
                     return true;
                 }
-                if (!this.ValidationService.performValidation(dataChangedInfo)) {
+                if (!this.ValidationService.performValidation(cellDataChangedInfo)) {
                     return false;
                 }
                 const onServerValidationCompleted = () => { };
                 if ((_a = this.adaptableOptions.editOptions) === null || _a === void 0 ? void 0 : _a.validateOnServer) {
-                    this.ValidationService.performServerValidation(dataChangedInfo, {
+                    this.ValidationService.performServerValidation(cellDataChangedInfo, {
                         onServerValidationCompleted,
                     })();
                 }
@@ -3176,13 +3212,13 @@ class Adaptable {
             return;
         }
         // rowNode = this.getRowNodeForPrimaryKey(primaryKeyValue);
-        let dataChangedInfos = [];
+        let cellDataChangedInfos = [];
         Object.keys(oldData).forEach((key) => {
             if (this.api.columnApi.doesColumnExist(key)) {
                 const oldValue = oldData[key];
                 const newValue = newData[key];
                 if (oldValue != newValue) {
-                    const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+                    const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                         oldValue: oldValue,
                         newValue: newValue,
                         column: this.api.columnApi.getColumnFromId(key),
@@ -3190,14 +3226,14 @@ class Adaptable {
                         rowNode: rowNode,
                         trigger: 'tick',
                     });
-                    if (this.isUndoChange(dataChangedInfo)) {
-                        dataChangedInfo.trigger = 'undo';
+                    if (this.isUndoChange(cellDataChangedInfo)) {
+                        cellDataChangedInfo.trigger = 'undo';
                     }
-                    dataChangedInfos.push(dataChangedInfo);
+                    cellDataChangedInfos.push(cellDataChangedInfo);
                 }
             }
         });
-        this.performPostEditChecks(dataChangedInfos);
+        this.performPostEditChecks(cellDataChangedInfos);
     }
     onCellDataChanged({ rowNode, oldValue, newValue, colId, }) {
         if (oldValue == newValue) {
@@ -3208,7 +3244,7 @@ class Adaptable {
             return;
         }
         if (this.isGroupRowNode(rowNode)) {
-            const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+            const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                 oldValue: oldValue,
                 newValue: newValue,
                 column: abColumn,
@@ -3220,14 +3256,14 @@ class Adaptable {
                 rowNode: rowNode,
                 trigger: 'aggChange',
             });
-            this.DataService.CreateDataChangedEvent(dataChangedInfo);
+            this.DataService.CreateDataChangedEvent(cellDataChangedInfo);
             return;
         }
         const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(rowNode);
         if (!primaryKeyValue) {
             return;
         }
-        const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+        const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
             oldValue: oldValue,
             newValue: newValue,
             column: abColumn,
@@ -3235,10 +3271,10 @@ class Adaptable {
             rowNode: rowNode,
             trigger: 'edit',
         });
-        if (this.isUndoChange(dataChangedInfo)) {
-            dataChangedInfo.trigger = 'undo';
+        if (this.isUndoChange(cellDataChangedInfo)) {
+            cellDataChangedInfo.trigger = 'undo';
         }
-        this.performPostEditChecks([dataChangedInfo]);
+        this.performPostEditChecks([cellDataChangedInfo]);
     }
     isUndoChange(dataChange) {
         // check if this is not a reverted change
@@ -3248,20 +3284,20 @@ class Adaptable {
     /**
      * There are a few things that we need to do AFTER we edit a cell and it makes sense to put them in one place
      */
-    performPostEditChecks(dataChangedInfos) {
-        const firstInfo = dataChangedInfos[0];
+    performPostEditChecks(cellDataChangedInfos) {
+        const firstInfo = cellDataChangedInfos[0];
         if (!firstInfo || !firstInfo.rowNode) {
             return;
         }
-        dataChangedInfos.forEach((dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'undo') {
-                LoggingHelper_1.LogAdaptableInfo(`Undo data change: PK(${dataChangedInfo.primaryKeyValue}) Col(${dataChangedInfo.column}) RevertedValue(${dataChangedInfo.oldValue}) OriginalValue(${dataChangedInfo.newValue})`);
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+            if (cellDataChangedInfo.trigger === 'undo') {
+                LoggingHelper_1.LogAdaptableInfo(`Undo data change: PK(${cellDataChangedInfo.primaryKeyValue}) Col(${cellDataChangedInfo.column}) RevertedValue(${cellDataChangedInfo.oldValue}) OriginalValue(${cellDataChangedInfo.newValue})`);
             }
-            if (dataChangedInfo.trigger === 'edit' || dataChangedInfo.trigger === 'undo') {
-                this.checkChangedCellCurrentlySelected(dataChangedInfo);
-                this.api.freeTextColumnApi.checkFreeTextColumnForDataChange(dataChangedInfo);
+            if (cellDataChangedInfo.trigger === 'edit' || cellDataChangedInfo.trigger === 'undo') {
+                this.checkChangedCellCurrentlySelected(cellDataChangedInfo);
+                this.api.freeTextColumnApi.checkFreeTextColumnForDataChange(cellDataChangedInfo);
             }
-            this.DataService.CreateDataChangedEvent(dataChangedInfo);
+            this.DataService.CreateDataChangedEvent(cellDataChangedInfo);
         });
         // if node is visible then check if need to refresh other columns / whole row if the updating column is:
         // 1. referenced in Conditional Styles that have Expressions (refreshing whole row if Scope is All)
@@ -3271,12 +3307,12 @@ class Adaptable {
                 wholeRow: false,
                 columnIds: new Set(),
             };
-            this.getExpressionStylesChanges(dataChangedScope, dataChangedInfos);
+            this.getExpressionStylesChanges(dataChangedScope, cellDataChangedInfos);
             if (dataChangedScope.wholeRow) {
                 this.redrawRow(firstInfo.rowNode);
             }
             else {
-                this.getFormatColumnComparisonChanges(dataChangedScope, dataChangedInfos);
+                this.getFormatColumnComparisonChanges(dataChangedScope, cellDataChangedInfos);
                 if (dataChangedScope.columnIds.size > 0) {
                     this.refreshCells([firstInfo.rowNode], Array.from(dataChangedScope.columnIds.values()), true);
                 }
@@ -3284,17 +3320,17 @@ class Adaptable {
         }
         firstInfo.trigger == 'tick' ? this.filterOnTickingDataChange() : this.filterOnEditDataChange();
     }
-    getExpressionStylesChanges(dataChangedScope, dataChangedInfos) {
+    getExpressionStylesChanges(dataChangedScope, cellDataChangedInfos) {
         const stylesWithExpression = this.api.conditionalStyleApi.getConditionalStylesWithExpression();
         if (ArrayExtensions_1.ArrayExtensions.IsNullOrEmpty(stylesWithExpression)) {
             return;
         }
-        dataChangedInfos.forEach((dataChangedInfo) => {
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
             if (!dataChangedScope.wholeRow) {
                 stylesWithExpression.forEach((conditionalStyle) => {
                     if (!dataChangedScope.wholeRow) {
                         const columnIds = this.api.queryLanguageApi.getColumnsFromExpression(conditionalStyle.Rule.BooleanExpression);
-                        if (columnIds.includes(dataChangedInfo.column.columnId)) {
+                        if (columnIds.includes(cellDataChangedInfo.column.columnId)) {
                             if (this.api.scopeApi.scopeIsAll(conditionalStyle.Scope)) {
                                 dataChangedScope.wholeRow = true;
                                 return;
@@ -3313,14 +3349,14 @@ class Adaptable {
             }
         });
     }
-    getFormatColumnComparisonChanges(dataChangedScope, dataChangedInfos) {
+    getFormatColumnComparisonChanges(dataChangedScope, cellDataChangedInfos) {
         this.api.formatColumnApi.getAllFormatColumn().forEach((fc) => {
             let columnComparision = this.api.formatColumnApi.getColumnComparisonForFormatColumn(fc);
             if (columnComparision) {
                 let affectedColumnIds = this.api.formatColumnApi.getColumnIdsFromColumnComparison(columnComparision);
                 if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(affectedColumnIds)) {
-                    dataChangedInfos.forEach((dataChangedInfo) => {
-                        if (affectedColumnIds.includes(dataChangedInfo.column.columnId)) {
+                    cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+                        if (affectedColumnIds.includes(cellDataChangedInfo.column.columnId)) {
                             this.api.scopeApi
                                 .getColumnsForScope(fc.Scope)
                                 .map((c) => c.columnId)
@@ -3333,18 +3369,18 @@ class Adaptable {
             }
         });
     }
-    checkChangedCellCurrentlySelected(dataChangedInfo) {
+    checkChangedCellCurrentlySelected(cellDataChangedInfo) {
         let selectedCellInfo = this.api.gridApi.getSelectedCellInfo();
         if (selectedCellInfo && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(selectedCellInfo.gridCells)) {
-            let matchingCell = selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == dataChangedInfo.primaryKeyValue &&
-                gc.column == dataChangedInfo.column);
+            let matchingCell = selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == cellDataChangedInfo.primaryKeyValue &&
+                gc.column == cellDataChangedInfo.column);
             if (matchingCell) {
                 this.setSelectedCells();
             }
         }
         let selectedRowInfo = this.api.gridApi.getSelectedRowInfo();
         if (selectedRowInfo && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(selectedRowInfo.gridRows)) {
-            let matchingRow = selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == dataChangedInfo.primaryKeyValue);
+            let matchingRow = selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == cellDataChangedInfo.primaryKeyValue);
             if (matchingRow) {
                 this.setSelectedRows();
             }
@@ -3673,7 +3709,7 @@ class Adaptable {
     updateColumnDataTypeIfRowDataIsEmpty() {
         var _a, _b;
         // gridOptions?.rowData is not updated when setting data via the api
-        if (!((_b = (_a = this.gridOptions) === null || _a === void 0 ? void 0 : _a.rowData) === null || _b === void 0 ? void 0 : _b.length)) {
+        if (!this.isCheckedColumnDataType && !((_b = (_a = this.gridOptions) === null || _a === void 0 ? void 0 : _a.rowData) === null || _b === void 0 ? void 0 : _b.length)) {
             // the columns dataType is based on the rawData, when type is not set on the column
             // when data is loaded async, the dataType initially is dataType=unknown
             // to fix this, we need to update the columnDefs when we data is loaded
@@ -3681,6 +3717,8 @@ class Adaptable {
             // this influences the floating filter
             // need to trigger header redraw, if not, the columnDef update is not picked-up
             this.redrawHeader();
+            // ensures the check is performed only once
+            this.isCheckedColumnDataType = true;
         }
     }
     runAdaptableComparerFunction(columnId, columnValues) {

package/src/agGrid/editors/AdaptableNumberEditor/index.d.ts

@@ -50,6 +50,8 @@ export declare class AdaptableNumberEditor implements ICellEditorComp {
     afterGuiAttached(): void;
     destroy(): void;
     private onValueChange;
+    private getStartValue;
     private shouldClearExistingValue;
+    private isValidChar;
 }
 export {};

package/src/agGrid/editors/AdaptableNumberEditor/index.js

@@ -40,7 +40,7 @@ class AdaptableNumberEditor {
         };
     }
     init(params) {
-        this.value = this.shouldClearExistingValue(params) ? '' : params.value;
+        this.value = this.getStartValue(params);
         this.params = params;
         this.columnId = params.column.getColId();
         const { valueParser } = params.column.getColDef();
@@ -72,7 +72,7 @@ class AdaptableNumberEditor {
     afterGuiAttached() {
         var _a, _b;
         const adaptable = this.params.api.__adaptable;
-        const defaultValue = this.shouldClearExistingValue(this.params) ? '' : this.params.value;
+        const defaultValue = this.value;
         const editorElement = (React.createElement(InternalAdaptableNumberEditor_1.InternalAdaptableNumberEditor, { defaultValue: defaultValue, showClearButton: (_a = this.params.showClearButton) !== null && _a !== void 0 ? _a : true, emptyValue: (_b = this.params.emptyValue) !== null && _b !== void 0 ? _b : '', onValueChange: this.onValueChange, ref: (editor) => {
                 this.editor = editor;
                 editor === null || editor === void 0 ? void 0 : editor.focus();
@@ -92,8 +92,22 @@ class AdaptableNumberEditor {
     destroy() {
         react_dom_1.unmountComponentAtNode(this.el);
     }
+    getStartValue(params) {
+        if (this.shouldClearExistingValue(params)) {
+            return '';
+        }
+        if (params.charPress && this.isValidChar(params.charPress)) {
+            return params.charPress;
+        }
+        return params.value;
+    }
     shouldClearExistingValue(params) {
         return params.eventKey === all_modules_1.KeyCode.BACKSPACE || params.eventKey === all_modules_1.KeyCode.DELETE;
     }
+    isValidChar(char) {
+        // allow only digits
+        return ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes(char);
+        // we do NOT allow key shortcuts for starting non-digits (minus sign, decimal separators) as the input[number] handling is very buggy and we would open a can of worms
+    }
 }
 exports.AdaptableNumberEditor = AdaptableNumberEditor;

package/src/metamodel/adaptable.metamodel.d.ts

@@ -1000,6 +1000,40 @@ export declare const ADAPTABLE_METAMODEL: {
             isOptional: boolean;
         })[];
     };
+    CellDataChangedInfo: {
+        name: string;
+        kind: string;
+        description: string;
+        properties: ({
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            reference?: undefined;
+            isOptional?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            reference: string;
+            isOptional?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            isOptional: boolean;
+            reference?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            isOptional: boolean;
+            reference: string;
+        })[];
+    };
     CellHighlightInfo: {
         name: string;
         kind: string;
@@ -1595,40 +1629,6 @@ export declare const ADAPTABLE_METAMODEL: {
             uiLabel: string;
         }[];
     };
-    DataChangedInfo: {
-        name: string;
-        kind: string;
-        description: string;
-        properties: ({
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            reference?: undefined;
-            isOptional?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            reference: string;
-            isOptional?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            isOptional: boolean;
-            reference?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            isOptional: boolean;
-            reference: string;
-        })[];
-    };
     DataChangeHistoryApi: {
         name: string;
         kind: string;