@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.1

package/src/agGrid/AgGridColumnAdapter.js

@@ -1,22 +1,24 @@
-import { ModuleNames, } from '@ag-grid-community/core';
 import merge from 'lodash/merge';
 import { FilterWrapperFactory } from './FilterWrapper';
 import { FloatingFilterWrapperFactory } from './FloatingFilterWrapper';
 import { convertAdaptableStyleToCSS, getVariableColor, normalizeStyleForAgGrid, } from '../Utilities/Helpers/StyleHelper';
 import StringExtensions from '../Utilities/Extensions/StringExtensions';
-import { createBaseContext } from '../Utilities/ObjectFactory';
+import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../PredefinedConfig/Common/AdaptableColumn';
 import tinycolor from 'tinycolor2';
 import UIHelper from '../View/UIHelper';
-import { getPercentBarRendererForColumn } from './PercentBarRenderer';
-import { getBadgeRendererForColumn } from './BadgeRenderer';
+import { getPercentBarRendererForColumn } from './cellRenderers/PercentBarRenderer';
+import { getBadgeRendererForColumn } from './cellRenderers/BadgeRenderer';
 import Helper from '../Utilities/Helpers/Helper';
 import { AdaptableNumberEditor, AdaptableReactNumberEditor } from './editors/AdaptableNumberEditor';
 import { AdaptableDateEditor, AdaptableReactDateEditor } from './editors/AdaptableDateEditor';
-export function getEditorsForColumnTypes(variant) {
-    return {
-        abColDefNumber: variant === 'react' ? AdaptableReactNumberEditor : AdaptableNumberEditor,
-        abColDefDate: variant === 'react' ? AdaptableReactDateEditor : AdaptableDateEditor,
-    };
+import { AgGridExportAdapter } from './AgGridExportAdapter';
+export function getEditorForColumnDataType(columnDataType, variant) {
+    if (columnDataType === 'number') {
+        return variant === 'react' ? AdaptableReactNumberEditor : AdaptableNumberEditor;
+    }
+    if (columnDataType === 'date' || columnDataType === 'dateString') {
+        return variant === 'react' ? AdaptableReactDateEditor : AdaptableDateEditor;
+    }
 }
 export class AgGridColumnAdapter {
     constructor(adaptableInstance) {
@@ -38,10 +40,9 @@ export class AgGridColumnAdapter {
         return this.adaptableInstance.adaptableOptions;
     }
     get agGridApi() {
-        return this.adaptableInstance.agGridAdapter.getAgGridApi();
+        return this.adaptableApi.agGridApi;
     }
     setColDefProperty(col, propertyName, propertyGetter) {
-        var _a;
         const colId = col.getColId();
         const colDef = col.getColDef();
         const colSetupInfo = {
@@ -61,15 +62,15 @@ export class AgGridColumnAdapter {
         if (adaptableValue != null) {
             this.colDefPropertyCache.set(adaptableKey, adaptableValue);
         }
-        let theValue = adaptableValue !== null && adaptableValue !== void 0 ? adaptableValue : userValue;
+        let theValue = adaptableValue ?? userValue;
         this.adaptableInstance.forPlugins((plugin) => {
             if (plugin.interceptSetupColumnProperty) {
                 theValue = plugin.interceptSetupColumnProperty(colSetupInfo, propertyName, theValue, this.adaptableApi);
             }
         });
         if (propertyName === 'aggFunc') {
-            if (colDef[propertyName] !== (theValue !== null && theValue !== void 0 ? theValue : null)) {
-                (_a = this.agGridApi) === null || _a === void 0 ? void 0 : _a.setColumnAggFunc(colId, theValue !== null && theValue !== void 0 ? theValue : null);
+            if (colDef[propertyName] !== (theValue ?? null)) {
+                this.agGridApi?.setColumnAggFunc(colId, theValue ?? null);
             }
         }
         if (theValue === undefined && colDef[propertyName] === undefined) {
@@ -82,13 +83,37 @@ export class AgGridColumnAdapter {
         const userKey = `user.${columnId}.${propertyName}`;
         return this.colDefPropertyCache.get(userKey);
     }
+    shouldSkipColumn(colId) {
+        /**
+         * This skips columns like `ag-Grid-SelectionColumn` and possibly other columns
+         * that ag grid will implement in the future
+         *
+         * BUT DOES NOT SKIP GROUP COLUMNS!!!
+         */
+        return colId.startsWith('ag-Grid-') && !this.adaptableApi.columnApi.isAutoRowGroupColumn(colId);
+    }
     setupColumns() {
-        const cols = this.agGridApi.getColumns();
+        const pivotMode = this.agGridApi.isPivotMode();
+        let cols = pivotMode
+            ? // for pivot mode, we take only the initial columns
+                this.agGridApi.getColumns()
+            : // but for non-pivot mode, we ask for all columns
+                // which also includes those that are generated for row grouping
+                this.agGridApi.getAllGridColumns();
+        if (pivotMode) {
+            const pivotResultColumns = this.agGridApi.getPivotResultColumns() || [];
+            if (pivotResultColumns.length) {
+                cols = [...cols, ...pivotResultColumns];
+            }
+        }
         // this needs to be here, before the other setup below
         // so the setup methods below reference the correct columns in adaptable store
         cols.forEach((col) => {
             const colDef = col.getColDef();
             const colId = col.getColId();
+            if (this.shouldSkipColumn(colId)) {
+                return;
+            }
             const abColumn = this.adaptableApi.columnApi.getColumnWithColumnId(colId);
             const colSetupInfo = {
                 col,
@@ -111,6 +136,7 @@ export class AgGridColumnAdapter {
             this.setupColumnHeader(colSetupInfo);
             this.setupColumnQuickFilerText(colSetupInfo);
             this.setupColumnAllowedAggFuncs(colSetupInfo);
+            this.setupColumnType(colSetupInfo);
             // this is just to make sure that AG Grid does NOT infer the cellDataType
             // https://github.com/AdaptableTools/adaptable/issues/2230 should render it obsolete
             this.setupColumnCellDataType(colSetupInfo);
@@ -129,11 +155,14 @@ export class AgGridColumnAdapter {
             const hasQuickSearchStyleClassName = StringExtensions.IsNotNullOrEmpty(quickSearchStyleClassName);
             const cellClass = (params) => {
                 const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, abColumn.columnId);
+                if (!gridCell.column) {
+                    return null;
+                }
                 // if a Visual Data export is in progress, we are interested only in the Excel Style Class
                 if (this.adaptableApi.exportApi.internalApi.isVisualDataExportInProgress()) {
                     const userDefinedCellClass = typeof userCellClass === 'function' ? userCellClass(params) : userCellClass;
-                    const cellClassKey = this.getExcelClassNameForCell(colId, gridCell.primaryKeyValue, userDefinedCellClass);
-                    return this.adaptableApi.exportApi.internalApi.getExcelStyleIdForCellClassKey(cellClassKey);
+                    const cellClassKey = AgGridExportAdapter.getExcelClassNameForCell(colId, gridCell.primaryKeyValue, userDefinedCellClass);
+                    return this.adaptableInstance.agGridExportAdapter.getExcelStyleIdForCellClassKey(cellClassKey);
                 }
                 const isQuickSearchActive = hasQuickSearchStyleClassName && this.isQuickSearchActive(gridCell, params);
                 const editableClassName = this.getEditableCellClass(gridCell, params);
@@ -173,48 +202,67 @@ export class AgGridColumnAdapter {
             const quickSearchStyle = this.getQuickSearchCellStyle();
             const hasQuickSearchStyle = quickSearchStyle != undefined;
             const cellStyle = (params) => {
-                const gridCell = this.adaptableInstance.getGridCellFromRowNode(params.node, abColumn.columnId);
+                const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, abColumn.columnId);
+                if (!gridCell || !gridCell.column) {
+                    return {};
+                }
                 const isQuickSearchActive = hasQuickSearchStyle && this.isQuickSearchActive(gridCell, params);
                 const userDefined = typeof userCellStyle === 'function' ? userCellStyle(params) : userCellStyle;
-                const result = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, userDefined), this.getReadOnlyCellStyle(gridCell, params)), this.getEditableCellStyle(gridCell, params)), this.getEditedCellStyle(gridCell, params)), this.getFormatColumnAndStyledColumnCellStyle(gridCell, params)), (isQuickSearchActive ? quickSearchStyle : {})), this.getAlertCellStyle(gridCell, params)), this.getFlashingCellStyle(gridCell, params)), this.getCellHighlightStyle(gridCell, params));
+                const result = {
+                    ...userDefined,
+                    ...this.getReadOnlyCellStyle(gridCell, params),
+                    ...this.getEditableCellStyle(gridCell, params),
+                    ...this.getEditedCellStyle(gridCell, params),
+                    ...this.getFormatColumnAndStyledColumnCellStyle(gridCell, params),
+                    ...(isQuickSearchActive ? quickSearchStyle : {}),
+                    ...this.getAlertCellStyle(gridCell, params),
+                    ...this.getFlashingCellStyle(gridCell, params),
+                    ...this.getCellHighlightStyle(gridCell, params),
+                };
                 return normalizeStyleForAgGrid(result);
             };
             return cellStyle;
         });
     }
-    setupColumnCellEditor({ colId, col }) {
-        const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(colId);
-        const editLookUpItem = this.adaptableApi.userInterfaceApi.getEditLookUpItemForColumn(adaptableColumn);
-        const hasRichSelectCellEditor = this.adaptableInstance.agGridAdapter.isModulePresent(ModuleNames.RichSelectModule);
+    setupColumnCellEditor({ colId, col, colDef, abColumn }) {
+        const shouldShowSelectCellEditor = this.adaptableApi.userInterfaceApi.internalApi.shouldShowSelectCellEditor(abColumn);
+        const hasRichSelectCellEditor = this.adaptableInstance.agGridAdapter.isAgGridModuleRegistered('RichSelect');
         this.setColDefProperty(col, 'cellEditor', () => {
-            if (editLookUpItem) {
+            if (shouldShowSelectCellEditor) {
                 return hasRichSelectCellEditor ? 'agRichSelectCellEditor' : 'agSelectCellEditor';
             }
             else {
-                const colDef = col.getColDef();
                 if (colDef.cellEditor) {
                     return colDef.cellEditor;
                 }
-                const columnTypeToCellEditor = getEditorsForColumnTypes(this.getVariant());
-                return (adaptableColumn.columnTypes || []).reduce((cellEditor, colType) => {
-                    var _a;
-                    return (_a = columnTypeToCellEditor[colType]) !== null && _a !== void 0 ? _a : cellEditor;
-                }, undefined);
+                const cellDataTypeEditor = getEditorForColumnDataType(abColumn.dataType, this.getVariant());
+                return cellDataTypeEditor;
             }
         });
         this.setColDefProperty(col, 'cellEditorPopup', () => {
             // as specified in https://www.ag-grid.com/react-data-grid/provided-cell-editors/#rich-select-cell-editor
             // agRichSelectCellEditor should always set cellEditorPopup=true. Otherwise the editor will be clipped to the cell contents
-            if (editLookUpItem && hasRichSelectCellEditor) {
+            if (shouldShowSelectCellEditor && hasRichSelectCellEditor) {
                 return true;
             }
         });
         this.setColDefProperty(col, 'cellEditorParams', (params) => {
-            if (editLookUpItem) {
+            if (shouldShowSelectCellEditor) {
                 return (params) => {
-                    const gridCell = this.adaptableInstance.getGridCellFromRowNode(params === null || params === void 0 ? void 0 : params.node, colId);
+                    const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params?.node, colId);
+                    const options = this.adaptableApi.gridApi.internalApi.getDistinctEditDisplayValuesForColumn({
+                        columnId: colId,
+                        gridCell,
+                        currentSearchValue: '',
+                    });
+                    const valueToLabelMap = new Map();
+                    const values = options.then((options) => options.map((option) => {
+                        valueToLabelMap.set(option.value, option.label);
+                        return option.value;
+                    }));
                     return {
-                        values: this.adaptableApi.userInterfaceApi.getEditLookUpValuesForEditLookUpItem(editLookUpItem, gridCell),
+                        values,
+                        formatValue: (value) => valueToLabelMap.get(value) ?? value,
                     };
                 };
             }
@@ -239,8 +287,11 @@ export class AgGridColumnAdapter {
             const styledColumn = this.adaptableApi.styledColumnApi.getStyledColumnForColumnId(abColumn.columnId);
             if (styledColumn && !styledColumn.IsSuspended) {
                 if (styledColumn.SparkLineStyle) {
-                    const sparklineOptions = merge({}, userDefined === null || userDefined === void 0 ? void 0 : userDefined.sparklineOptions, styledColumn.SparkLineStyle.options);
-                    return Object.assign(Object.assign({}, userDefined), { sparklineOptions });
+                    const sparklineOptions = merge({}, userDefined?.sparklineOptions, styledColumn.SparkLineStyle.options);
+                    return {
+                        ...userDefined,
+                        sparklineOptions,
+                    };
                 }
             }
         });
@@ -254,7 +305,7 @@ export class AgGridColumnAdapter {
                 styledColumn.PercentBarStyle &&
                 styledColumn.PercentBarStyle.ToolTipText) {
                 hasTooptip = true;
-                if (styledColumn === null || styledColumn === void 0 ? void 0 : styledColumn.PercentBarStyle) {
+                if (styledColumn?.PercentBarStyle) {
                     return (params) => {
                         const min = this.adaptableApi.styledColumnApi.internalApi.getNumericStyleMinValue(styledColumn, abColumn, params.node, params.value);
                         const max = this.adaptableApi.styledColumnApi.internalApi.getNumericStyleMaxValue(styledColumn, abColumn, params.node, params.value);
@@ -280,12 +331,12 @@ export class AgGridColumnAdapter {
                 return userGetQuickFilterText;
             }
             return (params) => {
-                const visibleCoulmnsMap = this.adaptableApi.layoutApi.getCurrentVisibleColumnIdsMap();
+                const visibleCoulmnsMap = this.adaptableApi.layoutApi.getCurrentVisibleColumnIdsMapForTableLayout();
                 const isVisible = visibleCoulmnsMap[abColumn.columnId];
                 if (!isVisible) {
                     return '';
                 }
-                return this.adaptableInstance.getDisplayValueFromRowNode(params.node, abColumn.columnId);
+                return this.adaptableApi.gridApi.getDisplayValueFromRowNode(params.node, abColumn.columnId);
             };
         });
     }
@@ -294,23 +345,47 @@ export class AgGridColumnAdapter {
             return abColumn.availableAggregationFunctions;
         });
     }
+    setupColumnType(columnSetupInfo) {
+        const { col, colId } = columnSetupInfo;
+        // AG Grid introduced since v30.x an inferred cellDataType
+        // the problem is that it breaks the default value formatter and/or editor (especially for Date columns)
+        this.setColDefProperty(col, 'type', (original_columnType) => {
+            const originalTypes = original_columnType == undefined
+                ? []
+                : Array.isArray(original_columnType)
+                    ? original_columnType
+                    : [original_columnType];
+            const columnTypes = new Set(originalTypes);
+            if (this.adaptableApi.columnApi.isCalculatedColumn(colId)) {
+                columnTypes.add(CALCULATED_COLUMN_TYPE);
+            }
+            if (this.adaptableApi.columnApi.isFreeTextColumn(colId)) {
+                columnTypes.add(FREE_TEXT_COLUMN_TYPE);
+            }
+            if (this.adaptableApi.columnApi.isActionColumn(colId)) {
+                columnTypes.add(ACTION_COLUMN_TYPE);
+            }
+            if (this.adaptableApi.columnApi.isFdc3Column(colId)) {
+                columnTypes.add(FDC3_COLUMN_TYPE);
+            }
+            return Array.from(columnTypes);
+        });
+    }
     setupColumnCellDataType(columnSetupInfo) {
         const { col } = columnSetupInfo;
         // AG Grid introduced since v30.x an inferred cellDataType
         // the problem is that it breaks the default value formatter and/or editor (especially for Date columns)
-        this.setColDefProperty(col, 'cellDataType', () => {
-            return false;
+        this.setColDefProperty(col, 'cellDataType', (original_cellDataType) => {
+            return original_cellDataType ?? true;
         });
     }
     setupColumnHeader({ col, abColumn }) {
-        var _a, _b;
-        const previousColumnHeader = (_a = col === null || col === void 0 ? void 0 : col.getColDef()) === null || _a === void 0 ? void 0 : _a.headerName;
+        const previousColumnHeader = col?.getColDef()?.headerName;
         this.setColDefProperty(col, 'headerName', (userHeaderName) => {
-            var _a;
             // set the default to the AG Grid provided values
             // from https://github.com/ag-grid/ag-grid/blob/v26.1.0/community-modules/core/src/ts/columns/columnModel.ts#L2515
-            let resultHeaderName = userHeaderName !== null && userHeaderName !== void 0 ? userHeaderName : StringExtensions.CamelCaseToHumanText(col.getColDef().field);
-            const layoutCustomHeader = (_a = this.adaptableApi.layoutApi.getCurrentLayout().ColumnHeadersMap) === null || _a === void 0 ? void 0 : _a[col.getColId()];
+            let resultHeaderName = userHeaderName ?? StringExtensions.CamelCaseToHumanText(col.getColDef().field);
+            const layoutCustomHeader = this.adaptableApi.layoutApi.getCurrentLayout().ColumnHeaders?.[col.getColId()];
             if (layoutCustomHeader) {
                 resultHeaderName = layoutCustomHeader;
             }
@@ -319,7 +394,7 @@ export class AgGridColumnAdapter {
             //  abColumn.friendlyName = resultHeaderName;
             return resultHeaderName;
         });
-        const newColumnHeader = (_b = col === null || col === void 0 ? void 0 : col.getColDef()) === null || _b === void 0 ? void 0 : _b.headerName;
+        const newColumnHeader = col?.getColDef()?.headerName;
         return previousColumnHeader !== newColumnHeader;
     }
     setupColumnFilter({ col, colDef }) {
@@ -327,7 +402,7 @@ export class AgGridColumnAdapter {
             if (!colDef.filter) {
                 return;
             }
-            if (!this.adaptableOptions.columnFilterOptions.useAdaptableColumnFiltering) {
+            if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
                 return;
             }
             this.agGridApi.destroyFilter(col);
@@ -335,10 +410,10 @@ export class AgGridColumnAdapter {
         });
     }
     setupColumnFloatingFilterTemporarily(initialGridOptions) {
-        var _a;
-        (_a = initialGridOptions.columnDefs) === null || _a === void 0 ? void 0 : _a.filter((colDef) => !this.isColGroupDef(colDef)).map((colDef) => {
-            var _a;
-            const isFloatingFilterEnabled = ((_a = initialGridOptions.defaultColDef) === null || _a === void 0 ? void 0 : _a.floatingFilter) || colDef.floatingFilter;
+        initialGridOptions.columnDefs
+            ?.filter((colDef) => !this.isColGroupDef(colDef))
+            .map((colDef) => {
+            const isFloatingFilterEnabled = initialGridOptions.defaultColDef?.floatingFilter || colDef.floatingFilter;
             if (isFloatingFilterEnabled) {
                 colDef.floatingFilterComponent = FloatingFilterWrapperFactory(this.adaptableInstance);
             }
@@ -346,8 +421,8 @@ export class AgGridColumnAdapter {
     }
     setupColumnFloatingFilter({ col, colDef }) {
         const isFloatingFilterDisabled = !colDef.floatingFilter ||
-            !this.adaptableOptions.columnFilterOptions.useAdaptableColumnFiltering;
-        this.adaptableOptions.columnFilterOptions.quickFilterOptions.showQuickFilter;
+            !this.adaptableOptions.filterOptions.useAdaptableFiltering ||
+            !this.adaptableOptions.filterOptions.columnFilterOptions.showQuickFilter;
         this.setColDefProperty(col, 'floatingFilterComponent', () => {
             if (isFloatingFilterDisabled) {
                 return;
@@ -371,48 +446,47 @@ export class AgGridColumnAdapter {
                 return;
             }
             return (params) => {
-                var _a, _b, _c, _d, _e, _f;
                 const { node, value } = params;
                 const mostRelevantFormatColumn = this.adaptableApi.formatColumnApi.internalApi.getMostRelevantFormatColumnForColumn(activeFormatColumnsWithDisplayFormat, abColumn, { node, value });
                 if (!mostRelevantFormatColumn) {
                     // ALL FormatColumns are conditional and NONE of them are relevant for this row
                     return value;
                 }
-                const options = mostRelevantFormatColumn.DisplayFormat.Options;
+                const formatterOptions = mostRelevantFormatColumn.DisplayFormat.Options;
                 if (mostRelevantFormatColumn.DisplayFormat.Formatter === 'NumberFormatter') {
                     // change the Number format - if the scope allows it
                     if (this.adaptableApi.columnScopeApi.isColumnInNumericScope(abColumn, mostRelevantFormatColumn.Scope)) {
                         let cellValue = params.value;
-                        if (typeof ((_a = params.value) === null || _a === void 0 ? void 0 : _a.toNumber) === 'function' &&
-                            typeof ((_b = params.value) === null || _b === void 0 ? void 0 : _b.toString) === 'function') {
+                        if (typeof params.value?.toNumber === 'function' &&
+                            typeof params.value?.toString === 'function') {
                             // aggregation values are wrapped in an AG Grid specific object
                             cellValue = params.value.toNumber();
                         }
-                        return this.adaptableApi.formatColumnApi.internalApi.getNumberFormattedValue(cellValue, params.node, abColumn, options);
+                        return this.adaptableApi.formatColumnApi.internalApi.getNumberFormattedValue(cellValue, params.node, abColumn, formatterOptions);
                     }
                 }
                 if (mostRelevantFormatColumn.DisplayFormat.Formatter === 'DateFormatter') {
                     // change the Date format - if the scope allows it
                     if (this.adaptableApi.columnScopeApi.isColumnInDateScope(abColumn, mostRelevantFormatColumn.Scope)) {
                         let cellValue = params.value;
-                        if (typeof ((_c = params.value) === null || _c === void 0 ? void 0 : _c.toNumber) === 'function' &&
-                            typeof ((_d = params.value) === null || _d === void 0 ? void 0 : _d.toString) === 'function') {
+                        if (typeof params.value?.toNumber === 'function' &&
+                            typeof params.value?.toString === 'function') {
                             // aggregation values are wrapped in an AG Grid specific object
                             cellValue = params.value.toString();
                         }
-                        return this.adaptableApi.formatColumnApi.internalApi.getDateFormattedValue(cellValue, params.node, abColumn, options);
+                        return this.adaptableApi.formatColumnApi.internalApi.getDateFormattedValue(cellValue, params.node, abColumn, formatterOptions);
                     }
                 }
                 if (mostRelevantFormatColumn.DisplayFormat.Formatter === 'StringFormatter') {
                     // change the String format - if the scope allows it
                     if (this.adaptableApi.columnScopeApi.isColumnInStringsScope(abColumn, mostRelevantFormatColumn.Scope)) {
                         let cellValue = params.value;
-                        if (typeof ((_e = params.value) === null || _e === void 0 ? void 0 : _e.toNumber) === 'function' &&
-                            typeof ((_f = params.value) === null || _f === void 0 ? void 0 : _f.toString) === 'function') {
+                        if (typeof params.value?.toNumber === 'function' &&
+                            typeof params.value?.toString === 'function') {
                             // aggregation values are wrapped in an AG Grid specific object
                             cellValue = params.value.toString();
                         }
-                        return this.adaptableApi.formatColumnApi.internalApi.getStringFormattedValue(cellValue, params.node, abColumn, options);
+                        return this.adaptableApi.formatColumnApi.internalApi.getStringFormattedValue(cellValue, params.node, abColumn, formatterOptions);
                     }
                 }
                 // should NEVER arrive at this line, but just to be sure
@@ -434,7 +508,7 @@ export class AgGridColumnAdapter {
                 };
                 // 1. evaluate EditOptions.isCellEditable if provided
                 if (this.adaptableApi.gridApi.internalApi.hasCellEditableAccordingToEditOptions()) {
-                    const gridCell = this.adaptableInstance.getGridCellFromRowNode(params.node, params.column.getColId());
+                    const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, params.column.getColId());
                     const editOptionsEditability = this.adaptableApi.gridApi.internalApi.isCellEditableAccordingToEditOptions(gridCell, getOriginalColDefEditable());
                     if (editOptionsEditability) {
                         return editOptionsEditability;
@@ -448,18 +522,16 @@ export class AgGridColumnAdapter {
     }
     setupColumnValueSetter({ col, colId, abColumn }) {
         this.setColDefProperty(col, 'valueSetter', (userValueSetter) => {
-            var _a;
             const preventEditAlertsForColumn = this.adaptableApi.alertApi.internalApi
                 .getAlertDefinitionsWithPreventEdit()
                 .filter((alertDefinition) => {
                 return this.adaptableApi.columnScopeApi.isColumnInScope(abColumn, alertDefinition.Scope);
             });
-            const noValidations = !preventEditAlertsForColumn.length && !((_a = this.adaptableOptions.editOptions) === null || _a === void 0 ? void 0 : _a.validateOnServer);
+            const noValidations = !preventEditAlertsForColumn.length && !this.adaptableOptions.editOptions?.validateOnServer;
             if (noValidations) {
                 return;
             }
             const valueSetter = (params) => {
-                var _a;
                 const field = params.column.getColDef().field;
                 if (noValidations) {
                     //TODO also consider the case when userValueSetter is a string
@@ -475,11 +547,11 @@ export class AgGridColumnAdapter {
                     }
                     return true;
                 }
-                const cellDataChangedInfo = this.adaptableApi.internalApi.buildDataChangedInfo({
+                const cellDataChangedInfo = this.adaptableApi.internalApi.buildCellDataChangedInfo({
                     oldValue: params.oldValue,
                     newValue: params.newValue,
                     column: this.adaptableApi.columnApi.getColumnWithColumnId(params.column.getColId()),
-                    primaryKeyValue: this.adaptableInstance.getPrimaryKeyValueFromRowNode(params.node, params.api),
+                    primaryKeyValue: this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(params.node),
                     rowNode: params.node,
                     trigger: 'edit',
                 });
@@ -490,15 +562,22 @@ export class AgGridColumnAdapter {
                  * Validate on the future row, with the new value.
                  * structuredClone fails, it contains functions.
                  */
-                const newRow = Object.assign(Object.assign({}, params.node), { data: Object.assign({}, params.node.data) });
+                const newRow = { ...params.node, data: { ...params.node.data } };
                 newRow.data[field] = params.newValue;
-                const cellDataChangeInfoForSyncValidation = Object.assign(Object.assign({}, cellDataChangedInfo), { rowNode: newRow });
-                if (!this.adaptableInstance.ValidationService.performValidation(cellDataChangeInfoForSyncValidation)) {
+                const cellDataChangeInfoForSyncValidation = {
+                    ...cellDataChangedInfo,
+                    rowNode: newRow,
+                };
+                if (!this.adaptableApi.internalApi
+                    .getValidationService()
+                    .performValidation(cellDataChangeInfoForSyncValidation)) {
                     return false;
                 }
                 const onServerValidationCompleted = () => { };
-                if ((_a = this.adaptableOptions.editOptions) === null || _a === void 0 ? void 0 : _a.validateOnServer) {
-                    this.adaptableInstance.ValidationService.performServerValidation(cellDataChangedInfo, {
+                if (this.adaptableOptions.editOptions?.validateOnServer) {
+                    this.adaptableApi.internalApi
+                        .getValidationService()
+                        .performServerValidation(cellDataChangedInfo, {
                         onServerValidationCompleted,
                     })();
                 }
@@ -528,56 +607,46 @@ export class AgGridColumnAdapter {
         this.setColDefProperty(col, 'comparator', comparatorGetter('comparator'));
         this.setColDefProperty(col, 'pivotComparator', comparatorGetter('pivotComparator'));
     }
-    getExcelClassNameForCell(colId, primaryKeyValue, userDefinedCellClass) {
-        let excelClassName = `--excel-cell-${colId}-${primaryKeyValue}`;
-        if (excelClassName.indexOf(' ') > 0) {
-            excelClassName = excelClassName.replace(/\s/g, '_');
-        }
-        return userDefinedCellClass != null
-            ? `${excelClassName}-${Array.isArray(userDefinedCellClass)
-                ? userDefinedCellClass.join('-')
-                : userDefinedCellClass}`
-            : excelClassName;
-    }
     isQuickSearchActive(gridCell, params) {
-        let quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
+        const quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
         if (StringExtensions.IsNullOrEmpty(quickSearchValue)) {
             return false;
         }
-        if (gridCell.column.isExcludedFromQuickSearch) {
-            return false;
-        }
-        if (!params.node) {
+        if (!gridCell.rowNode) {
             return false;
         }
-        if (!gridCell.isPivotCell &&
-            !this.adaptableApi.optionsApi.getQuickSearchOptions().runQuickSearchOnRowGroups &&
-            params.node.group) {
-            return false;
-        }
-        if (!this.adaptableApi.optionsApi.getQuickSearchOptions().runQuickSearchOnPivotColumns &&
-            gridCell.isPivotCell) {
-            return false;
-        }
-        if (this.adaptableApi.optionsApi.getQuickSearchOptions().runQuickSearchOnPivotColumns &&
-            gridCell.isPivotCell) {
-            gridCell.displayValue = params.value;
+        let quickSearchContext;
+        const isCellSearchable = this.adaptableOptions.quickSearchOptions.isCellSearchable;
+        if (isCellSearchable) {
+            quickSearchContext = {
+                ...this.adaptableApi.internalApi.buildBaseContext(),
+                gridCell,
+                quickSearchValue,
+            };
+            if (!isCellSearchable(quickSearchContext)) {
+                return false;
+            }
         }
-        const ignoreCase = !this.adaptableOptions.quickSearchOptions.runQuickSearchWithCaseSensitivity;
-        const displayValue = ignoreCase
-            ? String(gridCell.displayValue).toLocaleLowerCase()
-            : String(gridCell.displayValue);
-        const i = ignoreCase ? String(quickSearchValue).toLocaleLowerCase() : String(quickSearchValue);
-        const applyQuickSearchFunction = this.adaptableOptions.quickSearchOptions.runBespokeQuickSearch;
-        if (applyQuickSearchFunction) {
-            const quickSearchContext = Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { gridCell, quickSearchValue: quickSearchValue });
-            return applyQuickSearchFunction(quickSearchContext);
+        const runCustomQuickSearch = this.adaptableOptions.quickSearchOptions.runCustomQuickSearch;
+        if (runCustomQuickSearch) {
+            if (!quickSearchContext) {
+                quickSearchContext = {
+                    ...this.adaptableApi.internalApi.buildBaseContext(),
+                    gridCell,
+                    quickSearchValue,
+                };
+            }
+            return runCustomQuickSearch(quickSearchContext);
         }
-        return displayValue.indexOf(i) !== -1;
+        const isCaseSensitive = this.adaptableOptions.quickSearchOptions.isQuickSearchCaseSensitive;
+        const cellDisplayValue = String(gridCell.displayValue);
+        const displayValue = isCaseSensitive ? cellDisplayValue : cellDisplayValue.toLocaleLowerCase();
+        const searchText = isCaseSensitive ? quickSearchValue : quickSearchValue.toLocaleLowerCase();
+        return displayValue.indexOf(searchText) !== -1;
     }
     getEditableCellClass(gridCell, params) {
         const editableCellStyle = this.adaptableApi.userInterfaceApi.getEditableCellStyle();
-        if (!(editableCellStyle === null || editableCellStyle === void 0 ? void 0 : editableCellStyle.ClassName)) {
+        if (!editableCellStyle?.ClassName) {
             return null;
         }
         const isCellEditable = this.adaptableApi.gridApi.isCellEditable(gridCell);
@@ -585,7 +654,7 @@ export class AgGridColumnAdapter {
     }
     getReadonlyCellClass(gridCell, params) {
         const readonlyCellStyle = this.adaptableApi.userInterfaceApi.getReadOnlyCellStyle();
-        if (!(readonlyCellStyle === null || readonlyCellStyle === void 0 ? void 0 : readonlyCellStyle.ClassName)) {
+        if (!readonlyCellStyle?.ClassName) {
             return null;
         }
         const isCellReadonly = !this.adaptableApi.gridApi.isCellEditable(gridCell);
@@ -593,33 +662,31 @@ export class AgGridColumnAdapter {
     }
     getEditedCellClass(gridCell, params) {
         const editedCellStyle = this.adaptableApi.userInterfaceApi.getEditedCellStyle();
-        if (!(editedCellStyle === null || editedCellStyle === void 0 ? void 0 : editedCellStyle.ClassName)) {
+        if (!editedCellStyle?.ClassName) {
             return null;
         }
         const isCellEdited = this.adaptableApi.gridApi.isCellEdited(gridCell);
         return isCellEdited ? editedCellStyle.ClassName : null;
     }
     getAlertCellClass(gridCell, params) {
-        var _a, _b;
         const alert = this.adaptableApi.alertApi.internalApi.getAdaptableAlertWithHighlightCell(gridCell.column.columnId, params.node);
-        const highlightCell = (_b = (_a = alert === null || alert === void 0 ? void 0 : alert.alertDefinition) === null || _a === void 0 ? void 0 : _a.AlertProperties) === null || _b === void 0 ? void 0 : _b.HighlightCell;
-        return typeof highlightCell === 'object' && (highlightCell === null || highlightCell === void 0 ? void 0 : highlightCell.ClassName)
-            ? highlightCell === null || highlightCell === void 0 ? void 0 : highlightCell.ClassName
+        const highlightCell = alert?.alertDefinition?.AlertProperties?.HighlightCell;
+        return typeof highlightCell === 'object' && highlightCell?.ClassName
+            ? highlightCell?.ClassName
             : null;
     }
     getFlashingCellClass(gridcell, params) {
-        var _a, _b, _c;
         const primaryKey = params.node.aggData ? params.node.id : gridcell.primaryKeyValue;
         const flashingCell = this.adaptableApi.flashingCellApi.internalApi.getAdaptableFlashingCellFor(primaryKey, gridcell.column.columnId);
         if (!flashingCell) {
             return;
         }
         return flashingCell.direction === 'up'
-            ? (_a = flashingCell.flashingCellDefinition.UpChangeStyle) === null || _a === void 0 ? void 0 : _a.ClassName
+            ? flashingCell.flashingCellDefinition.UpChangeStyle?.ClassName
             : flashingCell.direction === 'down'
-                ? (_b = flashingCell.flashingCellDefinition.DownChangeStyle) === null || _b === void 0 ? void 0 : _b.ClassName
+                ? flashingCell.flashingCellDefinition.DownChangeStyle?.ClassName
                 : flashingCell.direction === 'neutral'
-                    ? (_c = flashingCell.flashingCellDefinition.NeutralChangeStyle) === null || _c === void 0 ? void 0 : _c.ClassName
+                    ? flashingCell.flashingCellDefinition.NeutralChangeStyle?.ClassName
                     : undefined;
     }
     getNoteCellClassName(gridCell, params) {
@@ -643,14 +710,14 @@ export class AgGridColumnAdapter {
         if (!this.adaptableApi.internalApi.getModuleService().isModuleAvailable('Comment')) {
             return;
         }
-        if (!this.adaptableApi.commentApi.internalApi.areCommentsSupported()) {
+        if (!this.adaptableApi.commentApi.internalApi.areCommentsSupportedInLayout()) {
             return;
         }
         const position = {
             PrimaryKeyValue: gridCell.primaryKeyValue,
             ColumnId: gridCell.column.columnId,
         };
-        const cellComments = this.adaptableApi.commentApi.getCommentThread(position);
+        const cellComments = this.adaptableApi.commentApi.getCommentThreadForCell(position);
         if (!cellComments) {
             return undefined;
         }
@@ -659,10 +726,9 @@ export class AgGridColumnAdapter {
     getFormatColumnCellClass(formatColumns, abColumn, params) {
         const classNames = formatColumns
             .map((formatColumn) => {
-            var _a, _b;
-            if (((_a = formatColumn.Style) === null || _a === void 0 ? void 0 : _a.ClassName) &&
+            if (formatColumn.Style?.ClassName &&
                 this.adaptableApi.formatColumnApi.internalApi.formatColumnShouldRender(formatColumn, abColumn, params.node, params.value)) {
-                return (_b = formatColumn.Style) === null || _b === void 0 ? void 0 : _b.ClassName;
+                return formatColumn.Style?.ClassName;
             }
         })
             .filter((x) => !!x);
@@ -718,7 +784,7 @@ export class AgGridColumnAdapter {
     getFormatColumnAndStyledColumnCellStyle(gridCell, params) {
         let styledColumn = this.adaptableApi.styledColumnApi.getStyledColumnForColumnId(gridCell.column.columnId);
         let styledColumnStyle = {};
-        if (styledColumn && !(styledColumn === null || styledColumn === void 0 ? void 0 : styledColumn.IsSuspended)) {
+        if (styledColumn && !styledColumn?.IsSuspended) {
             const styledCellStyle = this.getStyledColumnStyle(styledColumn, gridCell.column, params);
             // for percentbar we want to merge
             if (styledColumn.PercentBarStyle || styledColumn.BadgeStyle || styledColumn.GradientStyle) {
@@ -731,12 +797,14 @@ export class AgGridColumnAdapter {
         }
         const activeFormatColumnsWithStyle = this.adaptableApi.formatColumnApi.internalApi.getFormatColumnsWithStyleForColumn(gridCell.column);
         // background color of styledColumn.GradientStyle has precedence and wins over FormatColumn
-        return Object.assign(Object.assign({}, this.getFormatColumnCellStyle(gridCell.column, activeFormatColumnsWithStyle, params)), styledColumnStyle);
+        return {
+            ...this.getFormatColumnCellStyle(gridCell.column, activeFormatColumnsWithStyle, params),
+            ...styledColumnStyle,
+        };
     }
     getStyledColumnStyle(styledColumn, abColumn, params) {
-        var _a;
         let style = {};
-        const gradientStyle = styledColumn === null || styledColumn === void 0 ? void 0 : styledColumn.GradientStyle;
+        const gradientStyle = styledColumn?.GradientStyle;
         if (params.value === undefined) {
             return;
         }
@@ -758,8 +826,8 @@ export class AgGridColumnAdapter {
             // }
         }
         if (styledColumn.BadgeStyle &&
-            !((_a = styledColumn.BadgeStyle.RowScope) === null || _a === void 0 ? void 0 : _a.ExcludeSummaryRows) &&
-            this.adaptableApi.gridApi.isSummaryNode(params === null || params === void 0 ? void 0 : params.node)) {
+            !styledColumn.BadgeStyle.RowScope?.ExcludeSummaryRows &&
+            this.adaptableApi.gridApi.isSummaryNode(params?.node)) {
             return style;
         }
         if (gradientStyle) {
@@ -823,7 +891,7 @@ export class AgGridColumnAdapter {
                         break;
                 }
             }
-            return Object.assign(Object.assign({}, style), formatColumnStyle);
+            return { ...style, ...formatColumnStyle };
         }, {});
     }
     getAlertCellStyle(gridCell, params) {
@@ -839,22 +907,21 @@ export class AgGridColumnAdapter {
         }
     }
     getFlashingCellStyle(gridCell, params) {
-        var _a;
         const primaryKey = params.node.aggData ? params.node.id : gridCell.primaryKeyValue;
         const flashingCell = this.adaptableApi.flashingCellApi.internalApi.getAdaptableFlashingCellFor(primaryKey, gridCell.column.columnId);
         if (!flashingCell) {
             return {};
         }
-        return convertAdaptableStyleToCSS((_a = (flashingCell.direction === 'up'
+        return convertAdaptableStyleToCSS((flashingCell.direction === 'up'
             ? flashingCell.flashingCellDefinition.UpChangeStyle
             : flashingCell.direction === 'down'
                 ? flashingCell.flashingCellDefinition.DownChangeStyle
-                : flashingCell.flashingCellDefinition.NeutralChangeStyle)) !== null && _a !== void 0 ? _a : {});
+                : flashingCell.flashingCellDefinition.NeutralChangeStyle) ?? {});
     }
     getCellHighlightStyle(gridCell, params) {
         const cellHightlight = this.adaptableApi.internalApi
-            .getSystemState()
-            .HighlightedCells.find((cellHighlightInfo) => {
+            .getInternalState()
+            .CellHighlightInfo.find((cellHighlightInfo) => {
             return (gridCell.column.columnId === cellHighlightInfo.columnId &&
                 cellHighlightInfo.primaryKeyValue === gridCell.primaryKeyValue);
         });