@adaptabletools/adaptable 23.0.4 → 23.0.5-canary.0

package/src/agGrid/AdaptableAgGrid.js

@@ -24,7 +24,6 @@ import { expandCellDataChangedInfosWithCalculatedColumns } from '../Utilities/Se
 import { QueryLanguageService } from '../Utilities/Services/QueryLanguageService';
 import { AlertService } from '../Utilities/Services/AlertService';
 import { TeamSharingService } from '../Utilities/Services/TeamSharingService';
-import { MetamodelService } from '../Utilities/Services/MetamodelService';
 import { LicenseService } from '../Utilities/Services/LicenseService';
 import { ALL_TOOL_PANELS } from '../AdaptableState/Common/Types';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -114,12 +113,10 @@ const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEven
 LocalEventService_Prototype.dispatchEvent = function (event) {
     const agGridApi = event.api;
     if (agGridApi?.isDestroyed()) {
-        // do nothing if AG Grid was destroyed in the meantime
         return;
     }
     LocalEventService_dispatchEvent.apply(this, arguments);
     if (event.type === 'cellChanged' || event.type === 'dataChanged') {
-        // @ts-ignore
         const eventRowNode = event.node;
         if (!eventRowNode) {
             AdaptableLogger.consoleErrorBase(`No RowNode found in passed event, this should never happen!`, event);
@@ -132,21 +129,14 @@ LocalEventService_Prototype.dispatchEvent = function (event) {
             }
             return rowNodeApi;
         };
-        // we don't know from which instance of aggrid this is coming,
-        // as this fn is shared by all instances
         if (eventRowNode) {
             AdaptableAgGrid.forEachAdaptable((adaptable) => {
                 if (extractGridApiFromRowNode(eventRowNode) !== adaptable.agGridAdapter?.getAgGridApi(true)) {
-                    // the event is coming from another aggrid instance
-                    // so IGNORE IT
                     return;
                 }
                 if (adaptable.isDestroyed) {
-                    // do nothing if adaptable is destroyed (this is a rare case and happens when Adaptable is quickly destroyed and recreated)
                     return;
                 }
-                // we're on the correct instance, so do this
-                //@ts-ignore
                 const fn = adaptable.rowListeners ? adaptable.rowListeners[event.type] : null;
                 if (fn) {
                     fn(event);
@@ -163,9 +153,6 @@ export class AdaptableAgGrid {
     lifecycleState;
     variant;
     emitter;
-    /**
-     * Runtime flags
-     */
     hasAutogeneratedPrimaryKey;
     hasAdaptableToolPanel;
     initWithLazyData;
@@ -192,7 +179,6 @@ export class AdaptableAgGrid {
     QueryLanguageService;
     AlertService;
     TeamSharingService;
-    MetamodelService;
     RowFormService;
     Fdc3Service;
     AnnotationsService;
@@ -219,13 +205,9 @@ export class AdaptableAgGrid {
     renderReactRoot = (node, container) => defaultRenderReactRoot(node, container);
     unmountReactRoot;
     unmountLoadingScreen;
-    /**
-     * Temporary, these are MIGRATION technical debts, and should be removed as soon as possible
-     */
     adaptableStatusPanelKeys = [];
     adaptableStatusPanelDefs = [];
     hasAdaptableStatusBar;
-    // see #no_additional_react_root
     _PRIVATE_adaptableJSXElement;
     _prevLayout;
     __prevLayoutForRefresh;
@@ -265,8 +247,6 @@ export class AdaptableAgGrid {
     get isDestroyed() {
         return this.lifecycleState === 'preDestroyed';
     }
-    // only for our private / internal events used within Adaptable
-    // public events are emitted through the EventApi
     _emit = (eventName, data) => {
         if (this.emitter) {
             return this.emitter.emit(eventName, data);
@@ -289,10 +269,6 @@ export class AdaptableAgGrid {
         }
         return this.emitter.onIncludeFired(eventName, callback);
     };
-    /**
-     * Internal initializer for Adaptable, directly called by the React and Angular Adaptable wrappers
-     * @private
-     */
     static async _initInternal(config) {
         let promise = null;
         if (Array.isArray(config.adaptableOptions.plugins)) {
@@ -308,11 +284,7 @@ export class AdaptableAgGrid {
                         })
                         : plugin.beforeInit(config.adaptableOptions, agGridOptions);
             }
-            // if gridOptions changed, we need to update the runtimeConfig
             if (agGridOptions.gridOptions !== config.gridOptions) {
-                // This allows plugins to modify
-                // FIXME AFL MIG: clarify if this is still needed (for NoCode Plugin?)
-                // it looks like a code smell, ideally we should get rid of it
                 config.gridOptions = agGridOptions.gridOptions;
             }
         }
@@ -343,7 +315,6 @@ export class AdaptableAgGrid {
         }
     }
     async _initAdaptableAgGrid(config) {
-        // Phase 1: Preprocess Adaptable Options
         this._isDetailGrid = config.isDetailGrid === true;
         this._isDetailGridForIndex = config.isDetailGridForRowIndex;
         this.lifecycleState = 'preprocessOptions';
@@ -366,11 +337,6 @@ export class AdaptableAgGrid {
         const { showLoadingScreen, loadingScreenDelay, loadingScreenText, loadingScreenTitle } = this.adaptableOptions.userInterfaceOptions.loadingScreenOptions;
         if (showLoadingScreen) {
             this.logger.info('Showing loading screen');
-            // it's important to use ensureLoadingScreenPortalElement
-            // and not ensurePortalElement, because multiple adaptable instances share the same portal element
-            // so when displaying the second one, the react root associated to the portal element
-            // seems to be somewhat shared via the html element, so the portal element of the first one is destroyed
-            // resulting in the settings popup not being displayed anymore
             const portalElement = ensureLoadingScreenPortalElement();
             if (portalElement) {
                 this.unmountLoadingScreen = this.renderReactRoot(createElement(AdaptableLoadingScreen, {
@@ -399,16 +365,10 @@ export class AdaptableAgGrid {
         await this.adaptableStore.loadStore({
             adaptable: this,
             adaptableStateKey: this.adaptableOptions.adaptableStateKey,
-            /**
-             * This method is called after the store is loaded;
-             * it allows to modify the state before it is used by the application
-             * e.g. migrating deprecated state, etc.
-             */
             postLoadHook: (state) => {
                 if (this.adaptableOptions.stateOptions.autoMigrateState) {
                     this.api.logError;
                     const config = {
-                        // version 16 actually includes all versions up until 16
                         fromVersion: 16,
                         logger: this.logger,
                     };
@@ -420,24 +380,15 @@ export class AdaptableAgGrid {
         });
         perfLoadStore.end();
         loadStoreMarker.end();
-        // just in case Adaptable was destroyed while loading the store (which is an async operation)
         if (this.isDestroyed) {
             this.midwayDestroy();
             return Promise.reject('Adaptable was destroyed while loading the store.');
-            // FIXME AFL MIG: is this enough?! talk with the team
         }
         this.forPlugins((plugin) => plugin.afterInitialStateLoaded(this));
-        // do this now so it sets module entitlements
         this.api.entitlementApi.internalApi.setModulesEntitlements();
-        /**
-         * At this point it's mandatory to have the ALL the Adaptable blocks initialized:
-         * Store, APIs, Services, Modules
-         */
         this.lifecycleState = 'setupAgGrid';
         const gridOptions = config.gridOptions;
-        // Needed here because special column defs are required for deriving the adaptable column state
         let columnDefs = this.agGridAdapter.getColumnDefinitionsInclSpecialColumns(gridOptions.columnDefs || []);
-        // see #map_dateString_to_date
         this.agGridAdapter.patchColDefs(columnDefs, (colDef) => {
             if (colDef.cellDataType === 'dateString') {
                 this.logger.consoleError(`Column "${colDef.colId}" uses cellDataType="dateString" which is no longer supported. It has been replaced with cellDataType="date". Please update your column definition.`);
@@ -460,7 +411,6 @@ export class AdaptableAgGrid {
                 gridOptions.pivotDefaultExpanded = layoutModel.PivotExpandLevel;
             }
             gridOptions.groupDisplayType = rowGroupDisplayTypeToGridOption(layoutModel.RowGroupDisplayType);
-            // fixes issue #3053
             gridOptions.suppressAggFuncInHeader = !!layoutModel.SuppressAggFuncInHeader;
             if (!isPivotLayoutModel(layoutModel) &&
                 LayoutManager.shouldUnlockSelectionColumnPosition(layoutModel)) {
@@ -488,12 +438,6 @@ export class AdaptableAgGrid {
             initialRowSelection,
         });
         this.silentUpdateCurrentLayoutModel(layoutModel);
-        // this shouldn't be needed
-        // but AG Grid has a bug, and in pivot layout,
-        // even if we provide an initial AG Grid state with
-        // the aggregations in the correct order,
-        // they will end up in the wrong order
-        // so we need to force the layout to be applied again
         if (isPivotLayoutModel(layoutModel)) {
             this.layoutManager.setLayout(layoutModel, {
                 force: true,
@@ -510,7 +454,6 @@ export class AdaptableAgGrid {
         this.unmountLoadingScreen?.();
         perfInitAgGrid.end();
         initAgGridMarker.end();
-        // we need to intercept several AG Grid Api methods and trigger Adaptable state changes
         this.agGridAdapter.setAgGridApi(agGridApi);
         this.agGridAdapter.monkeyPatchingGridOptionsUpdates();
         this.agGridAdapter.monkeyPatchingAggColumnFilters();
@@ -519,29 +462,16 @@ export class AdaptableAgGrid {
         this.api.entitlementApi.internalApi.setModulesAgGridDepsInfos();
         this.ModuleService.logMissingAgGridDepsInfos();
         this.logger.info('Registered AG Grid modules (including dependents):', this.agGridModulesAdapter.getAgGridRegisteredModuleNames().sort());
-        /**
-         * At this point AG Grid is initialized!
-         */
         this.deriveAdaptableColumnStateFromAgGrid();
         this.agGridColumnAdapter.setupColumns();
-        // we need this because we need the internal Column state to be ready before doing any extra business logic
         this.lifecycleState = 'available';
         this.api.themeApi.applyCurrentTheme();
         this.validatePrimaryKey();
         this.checkShouldClearExistingFiltersOrSearches();
-        // initial filter model
         const filteringApplied = this.applyFiltering();
-        // We may need to re-apply sort if there are ColumnSorts for columns with CustomSort defined
-        // This is required because AG Grid wasn't aware of the CustomSort when applying sorting initially
-        // this is not required when filtering was applied because filtering also triggers a sort refresh internally
         if (!filteringApplied) {
             this.refreshInitialSortIfNeeded();
         }
-        // apply quick search if there is one
-        // yes, we could have put this on the gridOptions.findSearchValue
-        // but we need to wait for setupColumns to run first so as to correctly
-        // determine on which columns the quick search should be applied or not
-        // and also to setup the quick search style
         const quickSearchState = this.api.stateApi.getQuickSearchState();
         if (quickSearchState.QuickSearchText) {
             this.setAgGridFindSearchValue(quickSearchState.QuickSearchText);
@@ -566,13 +496,6 @@ export class AdaptableAgGrid {
         if (adaptableContainerElem != null) {
             adaptableContainerElem.innerHTML = '';
             if (this.variant === 'react') {
-                /**
-                 * #no_additional_react_root
-                 * This is only used for the React variant
-                 * Where we don't want to create a new React render tree here
-                 * by rendering it as a React root, but instead we want to
-                 * render it as is in the React tree of our AdaptableReact component
-                 */
                 this._PRIVATE_adaptableJSXElement = AdaptableApp({ Adaptable: this });
             }
             else {
@@ -582,11 +505,6 @@ export class AdaptableAgGrid {
         this.lifecycleState = 'ready';
         this.forPlugins((plugin) => plugin.onAdaptableReady(this, this.adaptableOptions));
         setTimeout(() => {
-            // without the setTimeout, calling autoSizeAllColumns immediately in the onAdaptableReady
-            // does not work. (I prefer setTimeout to rAF, as raf is not running when you switch tabs)
-            //
-            // it also makes it possible to listen to CALCULATED_COLUMN_READY, DASHBOARD_READY, etc.
-            // in onAdaptableReady - without this those event listeners are not triggered
             this.api?.eventApi?.emit('AdaptableReady', {
                 adaptableApi: this.api,
                 agGridApi: this.agGridAdapter.getAgGridApi(),
@@ -609,19 +527,13 @@ export class AdaptableAgGrid {
     }
     normaliseLayoutState(state, gridOptions) {
         const layoutState = state.Layout;
-        // ensure that at least one Layout has been provided
         if (!layoutState || !layoutState.Layouts?.length) {
             this.logger.consoleError('No Layouts defined in InitialState.Layout.Layouts[]. At least one Layout is required.');
         }
-        // ensure CurrentLayout is valid
         if (!layoutState.CurrentLayout ||
             !layoutState.Layouts.find((l) => l.Name === layoutState.CurrentLayout)) {
             layoutState.CurrentLayout = layoutState.Layouts?.[0]?.Name;
         }
-        /**
-         * Viewport mode does not support a few AG Grid features which are contained in a Layout
-         * Accordingly we remove this when using this Row Model
-         */
         if (gridOptions.rowModelType === 'viewport') {
             if (state.Layout.Layouts) {
                 state.Layout.Layouts = state.Layout.Layouts.filter((layout) => {
@@ -642,16 +554,7 @@ export class AdaptableAgGrid {
             const normalizeOptions = {
                 isTree: !!gridOptions.treeData,
             };
-            // it's very important that we do this here
-            // as the layout may not be fully specified in the initialState
-            // eg: might not include the generated row group columns in the column order
-            // but the normalization does this for us
             state.Layout.Layouts = state.Layout.Layouts.map((layout) => normalizeLayout(layout, normalizeOptions));
-            //now let's normalize the In/NotIn predicate for the group column
-            // the inputs in this predicate should be an array of arrays
-            // but for ease of use (and also for similarity with the In predicate for
-            // other columns) we allow the inputs to be an array of strings
-            // and change them to an array of arrays
             state.Layout.Layouts = state.Layout.Layouts.map((layout) => {
                 if (Array.isArray(layout.ColumnFilters)) {
                     layout.ColumnFilters = layout.ColumnFilters.map((columnFilter) => {
@@ -684,7 +587,6 @@ export class AdaptableAgGrid {
         if (state?.ToolPanel?.ToolPanels) {
             return state;
         }
-        // no Initial Adaptable State provided, we will display all the panels collapsed (custom & module)
         const defaultToolPanels = [];
         this.adaptableOptions.toolPanelOptions?.customToolPanels?.forEach((customToolPanel) => defaultToolPanels.push({ Name: customToolPanel.name }));
         ALL_TOOL_PANELS.forEach((moduleToolPanel) => defaultToolPanels.push({ Name: moduleToolPanel }));
@@ -711,20 +613,13 @@ export class AdaptableAgGrid {
     getDefaultColumnWidthForCol(columnId) {
         return this.layoutManager.getDefaultColumnWidthForCol(columnId);
     }
-    /**
-     * Returns TRUE if filtering was applied, FALSE otherwise
-     * This is important in the INIT phase because applying filtering will automatically refresh AG Grids columnState,
-     * implicitly refreshing the sorting state too (hence we don't need to apply sorting separately)
-     */
     applyFiltering(config) {
         let filteringApplied = false;
-        // default updateColumnFilterModel to TRUE, if not provided
         const updateColumnFilterModel = config?.updateColumnFilterModel ?? true;
         const agGridApi = this.agGridAdapter.getAgGridApi();
         if (updateColumnFilterModel) {
             const columnFilters = this.api.filterApi.columnFilterApi
                 .getActiveColumnFilters()
-                // we need this additional filter because 'getActiveColumnFilters' checks only for suspended while 'isColumnFilterActive' also checkss for COMPLETE filters
                 .filter((columnFilter) => this.api.filterApi.columnFilterApi.isColumnFilterActive(columnFilter));
             const filterModel = {};
             columnFilters.forEach((columnFilter) => {
@@ -733,10 +628,8 @@ export class AdaptableAgGrid {
             agGridApi.setFilterModel(filterModel);
             filteringApplied = Object.keys(filterModel).length > 0;
         }
-        // FIXME AFL FILTER why is this needed???
         this.refreshSelectedCellsState();
         this.refreshSelectedRowsState();
-        // agGridApi.setFilterModel() already triggered onFilterChanged(), so we skip it if updateColumnFilterModel is TRUE
         if (!filteringApplied) {
             agGridApi.onFilterChanged();
             filteringApplied = true;
@@ -744,10 +637,6 @@ export class AdaptableAgGrid {
         this._emit('AdapTableFiltersApplied');
         return filteringApplied;
     }
-    /**
-     * Checks if the current layout has ColumnSorts for columns that have CustomSort defined
-     * (either via initialState CustomSorts or via customSortComparers option) and refreshes the sort if needed.
-     */
     refreshInitialSortIfNeeded() {
         const currentLayout = this.api.layoutApi.getCurrentLayout();
         const columnSorts = currentLayout?.ColumnSorts;
@@ -755,12 +644,10 @@ export class AdaptableAgGrid {
             return;
         }
         const hasCustomSortForSortedColumn = columnSorts.some((columnSort) => {
-            // Check if there's a CustomSort defined in state for this column
             const customSort = this.api.customSortApi.getCustomSortForColumn(columnSort.ColumnId);
             if (customSort && !customSort.IsSuspended) {
                 return true;
             }
-            // Check if there's a customSortComparer defined in options for this column
             if (this.api.customSortApi.internalApi.columnHasCustomSortComparer(columnSort.ColumnId)) {
                 return true;
             }
@@ -779,7 +666,6 @@ export class AdaptableAgGrid {
     }
     showAdaptableToolPanel() {
         if (!this.hasAdaptableToolPanel) {
-            // don't re-add the ToolPanel if it's hidden by entitlement
             if (this.api.entitlementApi.isModuleHiddenEntitlement('ToolPanel')) {
                 return;
             }
@@ -796,7 +682,6 @@ export class AdaptableAgGrid {
     }
     hideAdaptableToolPanel() {
         if (this.hasAdaptableToolPanel) {
-            // close the tool panel if it's currently open
             this.api.toolPanelApi.closeAdapTableToolPanel();
             const currentSideBar = this.agGridAdapter.getGridOption('sideBar');
             if (currentSideBar?.toolPanels) {
@@ -829,7 +714,6 @@ export class AdaptableAgGrid {
         if (!this.hasAdaptableStatusBar && this.adaptableStatusPanelDefs.length > 0) {
             const currentStatusBar = this.agGridAdapter.getGridOption('statusBar');
             if (currentStatusBar) {
-                // filter out any Adaptable panels that may already exist to avoid duplicates
                 const existingNonAdaptablePanels = (currentStatusBar.statusPanels ?? []).filter((panel) => !this.adaptableStatusPanelKeys.includes(panel.key));
                 const updatedStatusBar = {
                     ...currentStatusBar,
@@ -865,9 +749,6 @@ export class AdaptableAgGrid {
         return adaptableOptions;
     }
     setInitialGridOptions(gridOptions, variant) {
-        /**
-         * set Adaptable instance on the AG Grid context
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'context', (original_context) => {
             const userContext = original_context || {};
             return {
@@ -876,9 +757,6 @@ export class AdaptableAgGrid {
                 adaptableApi: this.api,
             };
         });
-        /**
-         * `gridId`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'gridId', (original_gridId) => {
             let agGridId = original_gridId || this.adaptableOptions.adaptableId;
             if (this._isDetailGridForIndex != null) {
@@ -887,15 +765,11 @@ export class AdaptableAgGrid {
             this.agGridAdapter.setAgGridId(agGridId);
             return agGridId;
         });
-        /**
-         * `defaultColDef`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'defaultColDef', (original_defaultColDef) => {
             if (original_defaultColDef?.headerValueGetter) {
                 this.logger.warn('defaultColDef.headerValueGetter overrides the Adaptable header mechanism. Consider using ColumnOptions.columnHeader instead.');
                 return original_defaultColDef;
             }
-            // #customize_header
             const defaultColDef = { ...original_defaultColDef };
             defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
                 const columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(params);
@@ -904,9 +778,6 @@ export class AdaptableAgGrid {
             });
             return defaultColDef;
         });
-        /**
-         * `defaultColGroupDef`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'defaultColGroupDef', (original_defaultColGroupDef) => {
             if (original_defaultColGroupDef?.headerValueGetter) {
                 this.logger.warn('defaultColGroupDef.headerValueGetter overrides the Adaptable header mechanism. Consider using ColumnOptions.tableColumnHeader instead.');
@@ -918,17 +789,12 @@ export class AdaptableAgGrid {
             });
             return defaultColGroupDef;
         });
-        /**
-         * `autoGroupColumnDef`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'autoGroupColumnDef', (original_autoGroupColumnDef) => {
-            // #autoGroupColumnDef
             const useAdaptableFilter = this.adaptableOptions.filterOptions.useAdaptableFiltering;
             if (!useAdaptableFilter) {
                 return original_autoGroupColumnDef;
             }
             if (original_autoGroupColumnDef?.filter === false) {
-                // if user disables filter on autoGroupColumnDef, we respect that
                 this.logger.info('autoGroupColumnDef.filter is disabled via user configuration.');
                 return original_autoGroupColumnDef;
             }
@@ -937,18 +803,12 @@ export class AdaptableAgGrid {
                 return original_autoGroupColumnDef;
             }
             const autoGroupColumnDef = { ...original_autoGroupColumnDef };
-            // this is required to make sure that AG Grid doesn't disable the filter
-            // !! DO NOT REMOVE THIS !!
-            // see https://github.com/ag-grid/ag-grid/blob/6f43ff257c2e285068eb425b655e58d6eeb89816/packages/ag-grid-enterprise/src/rowHierarchy/autoColService.ts#L225
             autoGroupColumnDef.filterValueGetter = (params) => {
                 this.logger.consoleWarn('Unexpected invocation of autoGroupColumnDef.filterValueGetter. This is not expected under normal operation. Please contact support.', params);
                 return '';
             };
-            // !! it is important that we always return the same component / handler instances
-            // otherwise AG Grid will re-create the filter instance on each filterModel change
             const autoGroupFilterComponent = AgGridFilterAdapterFactory(this);
             const autoGroupFilterHandlerGenerator = () => new AdaptableFilterHandler(this.api);
-            // Use a getter to dynamically return different filter values based on Layout.RowGroupDisplayType
             Object.defineProperty(autoGroupColumnDef, 'filter', {
                 get: () => {
                     if (this.isDestroyed) {
@@ -981,7 +841,6 @@ export class AdaptableAgGrid {
                         if (rowGroupDisplayType === 'single') {
                             return true;
                         }
-                        // this is required because of AG Grid bug, see https://github.com/AdaptableTools/adaptable/issues/3212
                         if (rowGroupDisplayType === 'multi') {
                             const groupedColumnFilterConfig = this.api.layoutApi.internalApi.areAllGroupedColumnsFilterable();
                             if (groupedColumnFilterConfig.floatingFilter) {
@@ -993,10 +852,7 @@ export class AdaptableAgGrid {
                     enumerable: true,
                     configurable: true,
                 });
-                // !! it is important that we always return the same component / handler instances
-                // otherwise AG Grid will re-create the filter instance on each filterModel change
                 const autoGroupFloatingFilterComponent = AgGridFloatingFilterAdapterFactory(this);
-                // Use a getter to dynamically return different floatingFilterComponent values based on Layout.RowGroupDisplayType
                 Object.defineProperty(autoGroupColumnDef, 'floatingFilterComponent', {
                     get: () => {
                         if (this.isDestroyed) {
@@ -1014,31 +870,20 @@ export class AdaptableAgGrid {
             }
             return autoGroupColumnDef;
         });
-        /**
-         * `theme`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'theme', (original_theme) => {
             this.agGridThemeAdapter.setAgGridThemeMode(original_theme === 'legacy' ? 'legacy' : 'themingApi');
             return original_theme;
         });
-        /**
-         *  `getRowId`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getRowId', (original_getRowId) => {
             if (original_getRowId) {
                 return original_getRowId;
             }
             const primaryKey = this.adaptableOptions.primaryKey;
             if (StringExtensions.IsNullOrEmpty(primaryKey)) {
-                // if no valid PK then do nothing
                 return original_getRowId;
             }
             if (this.hasAutogeneratedPrimaryKey) {
                 return (params) => {
-                    // if the PK value is autogenerated, we need to make sure that the rowData has a valid PK value
-                    // this should be taken care of in the Adaptable.[loadDataSource/setDataSource/updateRows]() methods, but the users will always make silly decisions
-                    // so just to be safe we'll check here and add a PK value is missing
-                    // thus adding a side-effect in a getter, but what can we do against it?! :)
                     if (Helper.objectNotExists(params.data[primaryKey])) {
                         params.data[primaryKey] = createUuid();
                     }
@@ -1046,7 +891,6 @@ export class AdaptableAgGrid {
                 };
             }
             return (params) => {
-                // might be a summary row
                 if (params.data?.[ROW_SUMMARY_ROW_ID] != undefined) {
                     return params.data[ROW_SUMMARY_ROW_ID];
                 }
@@ -1069,7 +913,6 @@ export class AdaptableAgGrid {
                         ? `${primaryKeyValue}`
                         : params.data[primaryKey];
                 }
-                // fallback
                 const parentKeys = params.parentKeys ?? [];
                 const values = Object.values(params.data);
                 if (values.length) {
@@ -1078,10 +921,6 @@ export class AdaptableAgGrid {
                 }
             };
         });
-        // this is necessary here for the initialisation of the LayoutManager
-        /**
-         * `grandTotalRow`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'grandTotalRow', (original_grandTotalRow) => {
             const currentLayout = this.api.layoutApi.getCurrentLayout();
             if (!currentLayout) {
@@ -1093,10 +932,6 @@ export class AdaptableAgGrid {
                     ? undefined
                     : currentLayout.GrandTotalRow;
         });
-        // this is necessary here for the initialisation of the LayoutManager
-        /**
-         * `suppressAggFuncInHeader`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'suppressAggFuncInHeader', (original_suppressAggFuncInHeader) => {
             const currentLayout = this.api.layoutApi.getCurrentLayout();
             if (!currentLayout) {
@@ -1104,9 +939,6 @@ export class AdaptableAgGrid {
             }
             return currentLayout.SuppressAggFuncInHeader;
         });
-        /**
-         * `aggFuncs`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'aggFuncs', (original_aggFuncs) => {
             const aggregationFunctions = original_aggFuncs || {};
             aggregationFunctions[ONLY_AGG_FN_NAME] = (params) => {
@@ -1125,17 +957,11 @@ export class AdaptableAgGrid {
             };
             return aggregationFunctions;
         });
-        /**
-         * `allowContextMenuWithControlKey`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'allowContextMenuWithControlKey', (original_allowContextMenuWithControlKey) => {
             return original_allowContextMenuWithControlKey === undefined
                 ? true
                 : original_allowContextMenuWithControlKey;
         });
-        /**
-         * `enableFilterHandlers`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'enableFilterHandlers', (original_enableFilterHandlers) => {
             const useAdaptableFiltering = this.api.optionsApi.getFilterOptions().useAdaptableFiltering;
             if (useAdaptableFiltering) {
@@ -1143,9 +969,6 @@ export class AdaptableAgGrid {
             }
             return original_enableFilterHandlers;
         });
-        /**
-         * `suppressSetFilterByDefault`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'suppressSetFilterByDefault', (original_suppressSetFilterByDefault) => {
             const useAdaptableFiltering = this.api.optionsApi.getFilterOptions().useAdaptableFiltering;
             if (useAdaptableFiltering) {
@@ -1153,9 +976,6 @@ export class AdaptableAgGrid {
             }
             return original_suppressSetFilterByDefault;
         });
-        /**
-         * `isExternalFilterPresent`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'isExternalFilterPresent', (original_isExternalFilterPresent) => {
             return (params) => {
                 if (!this.isAvailable) {
@@ -1163,13 +983,9 @@ export class AdaptableAgGrid {
                 }
                 const isGridFilterActive = StringExtensions.IsNotNullOrEmpty(this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression());
                 return (isGridFilterActive ||
-                    // it means that userPropertyValue will be called so we re-init that collection
                     (original_isExternalFilterPresent ? original_isExternalFilterPresent(params) : false));
             };
         });
-        /**
-         * `doesExternalFilterPass`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'doesExternalFilterPass', (original_doesExternalFilterPass) => {
             return (node) => {
                 if (!this.isAvailable) {
@@ -1178,31 +994,22 @@ export class AdaptableAgGrid {
                 if (this.isGroupRowNode(node)) {
                     if (this.api.gridApi.isTreeDataGrid()) {
                         if (node.data == undefined) {
-                            // Filler Groups are not filterable
-                            // see https://www.ag-grid.com/javascript-data-grid/tree-data-paths/#filler-groups
                             return false;
                         }
                     }
                     else {
-                        // for non-Tree Data Grids, we don't filter Group Rows
-                        // not sure if that's 100% correct, but we did it like this in the past
-                        // so we keep it like this for now until bugs are reported
                         return true;
                     }
                 }
-                // first assess if the Row is filterable - if not, then return true so it always appears in Grid
                 const isRowFilterable = this.api.gridApi.internalApi.isRowFilterable(node);
                 if (!isRowFilterable) {
                     return true;
                 }
-                // next we assess a Grid Filter (if its running locally)
                 const currentGridFilterExpression = this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
                 if (StringExtensions.IsNotNullOrEmpty(currentGridFilterExpression)) {
                     const evaluateGridFilterOnClient = this.api.expressionApi.internalApi.evaluateExpressionInAdaptableQL('GridFilter', undefined, currentGridFilterExpression);
                     if (evaluateGridFilterOnClient) {
                         const isCurrentGridFilterValid = this.api.expressionApi.isValidBooleanExpression(currentGridFilterExpression, GridFilterModuleId, `Invalid Grid Filter '${currentGridFilterExpression}'`);
-                        // Not sure about this - what should we do with an invalid Grid Filter?
-                        // Here we essentially clear the Grid for invalid Grid Filter by returning false for each row
                         if (!isCurrentGridFilterValid) {
                             return false;
                         }
@@ -1220,26 +1027,16 @@ export class AdaptableAgGrid {
                 return result;
             };
         });
-        /**
-         * `getMainMenuItems`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getMainMenuItems', (original_getMainMenuItems) => {
             return (params) => {
-                // couldnt find a way to listen for menu close. There is a Menu Item Select, but you can also close menu from filter and clicking outside menu....
                 return this.agGridMenuAdapter.buildColumnMenu(params, original_getMainMenuItems);
             };
         });
-        /**
-         * `getContextMenuItems`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getContextMenuItems', (original_getContextMenuItems) => {
             return (params) => {
                 return this.agGridMenuAdapter.buildContextMenu(params, original_getContextMenuItems);
             };
         });
-        /**
-         * `components`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'components', (original_components) => {
             const AdaptableToolPanel = getAdaptableToolPanelAgGridComponent(this);
             const components = original_components || {};
@@ -1250,27 +1047,15 @@ export class AdaptableAgGrid {
             return adaptableComponents;
         });
         if (variant === 'react') {
-            // TODO very soon we have to transition to reactiveCustomComponents in React
-            // but for now, if we simply set it to true, it will break our editors, etc
-            // this.agGridOptionsService.setGridOptionsProperty(
-            //   gridOptions,
-            //   'reactiveCustomComponents',
-            //   () => true
-            // );
-        }
-        /**
-         * `sidebar`
-         */
+        }
         if (gridOptions.sideBar != undefined) {
             this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'sideBar', (original_sideBar) => {
                 if (!original_sideBar) {
-                    // lucky us, no sideBar is defined, so we don't have to do anything
                     return original_sideBar;
                 }
                 const isAdaptableToolPanelHidden = this.api.entitlementApi.isModuleHiddenEntitlement('ToolPanel');
                 const adaptableToolPanelDef = this.buildAdaptableToolPanelDef();
                 const mapToolPanelDefs = (toolPanelDefs = []) => {
-                    // if it's an alias for the adaptable tool panel, map it to a ToolPanelDef, otherwise return it as it is
                     return toolPanelDefs.map((toolPanelDef) => toolPanelDef === GeneralConstants.ADAPTABLE_TOOLPANEL_ID
                         ? adaptableToolPanelDef
                         : toolPanelDef);
@@ -1280,7 +1065,6 @@ export class AdaptableAgGrid {
                 };
                 let result;
                 if (original_sideBar === true) {
-                    // create all tool panels with default settings
                     const toolPanels = [];
                     toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_FILTERS);
                     toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_COLUMNS);
@@ -1291,7 +1075,6 @@ export class AdaptableAgGrid {
                         toolPanels: toolPanels,
                     };
                 }
-                // if there is only one tool panel, and it's the adaptable one => we have to handle it
                 else if (typeof original_sideBar === 'string') {
                     if (gridOptions.sideBar === GeneralConstants.ADAPTABLE_TOOLPANEL_ID) {
                         if (!isAdaptableToolPanelHidden)
@@ -1303,23 +1086,19 @@ export class AdaptableAgGrid {
                         result = original_sideBar;
                     }
                 }
-                // if it's an array, process the tool panel definitions
                 else if (Array.isArray(original_sideBar)) {
                     if (!original_sideBar.includes(GeneralConstants.ADAPTABLE_TOOLPANEL_ID) ||
                         isAdaptableToolPanelHidden) {
                         result = original_sideBar;
                     }
-                    // if it's an array, process the tool panel definitions
                     const sidebarDef = {};
                     sidebarDef.toolPanels = mapToolPanelDefs(original_sideBar);
                     result = sidebarDef;
                 }
-                // if it's fully-fledged SideBarDef, process its tool panel definitions
                 else if (isSideBarDefObject(original_sideBar)) {
                     if (original_sideBar.toolPanels?.some((toolpanelDef) => typeof toolpanelDef !== 'string' &&
                         toolpanelDef.id === GeneralConstants.ADAPTABLE_TOOLPANEL_ID &&
                         !isAdaptableToolPanelHidden)) {
-                        // if there is an Adaptable SideBarDef, don't touch it as it may contain user-defined properties
                         result = original_sideBar;
                     }
                     else {
@@ -1337,9 +1116,6 @@ export class AdaptableAgGrid {
             });
         }
         if (gridOptions.statusBar != undefined) {
-            /**
-             * `statusBar`
-             */
             this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'statusBar', (original_statusBar) => {
                 const statusPanels = (original_statusBar?.statusPanels ?? [])?.map((statusPanel) => {
                     if (statusPanel.statusPanel === ADAPTABLE_STATUS_PANEL) {
@@ -1367,9 +1143,6 @@ export class AdaptableAgGrid {
         else {
             this.hasAdaptableStatusBar = false;
         }
-        /**
-         * `getRowStyle`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getRowStyle', (original_getRowStyle) => {
             return (params) => {
                 const result = {
@@ -1380,9 +1153,6 @@ export class AdaptableAgGrid {
                 return result;
             };
         });
-        /**
-         * `getRowClass`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getRowClass', (original_getRowClass) => {
             return (params) => {
                 const alertHighlightClassName = this.api.gridApi.internalApi.getAlertRowClass(params);
@@ -1394,37 +1164,26 @@ export class AdaptableAgGrid {
                     highlightClassName,
                     alertHighlightClassName,
                 ]
-                    // we flatten it because 'original_getRowClass' might return a string[]
                     .flat()
                     .filter((x) => !!x);
                 return returnValue?.length ? returnValue : undefined;
             };
         });
-        /**
-         * `floatingFiltersHeight`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'floatingFiltersHeight', (original_floatingFiltersHeight) => {
             if (this.api.layoutApi.isCurrentLayoutPivot()) {
-                // if Current Layout is Pivot, hide the floating filters from the beginning, otherwise we get an annoying flicker
                 return 0;
             }
             return original_floatingFiltersHeight;
         });
-        /**
-         * `excelStyles`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'excelStyles', (original_excelStyles) => {
             const excelStyles = original_excelStyles || [];
-            // see ##masterDetailHeader
             excelStyles.push({
                 id: '_masterDetailHeader',
                 interior: {
                     color: '#aaaaaa',
                     pattern: 'Solid',
                 },
-            }, 
-            // see #EXCEL_EXPORT_DATA_TYPES
-            {
+            }, {
                 id: 'stringExcelType',
                 dataType: 'String',
             }, {
@@ -1435,30 +1194,17 @@ export class AdaptableAgGrid {
                 dataType: 'DateTime',
             }, {
                 id: 'numberExcelType',
-                // dataType: 'Number',
-                // AG Grid requires either dataType or numberFormat to be set for Numbers
                 numberFormat: {
                     format: `#,##0.00`,
                 },
             });
-            // store original excel styles, we will have to revert to them after each VISUAL EXPORT
             this.agGridExportAdapter.originalExcelStyles = [...excelStyles];
             this.agGridExportAdapter.DANGER_excelStyles = excelStyles;
-            // this array reference will be used for the entire AG Grid session
             return this.agGridExportAdapter.DANGER_excelStyles;
         });
-        /**
-         * `maintainColumnOrder`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'maintainColumnOrder', () => {
-            // see https://www.ag-grid.com/javascript-data-grid/column-updating-definitions/#maintain-column-order
-            // we want to always maintain the column order (provided by Adaptable Layouts), even when column definitions change
             return true;
         });
-        /**
-         * `columnTypes`
-         */
-        // this will have to go/be heavily extended with https://github.com/AdaptableTools/adaptable/issues/2230
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'columnTypes', (original_columnTypes) => {
             const providedColumnTypes = original_columnTypes || {};
             const adaptableSpecialColumnTypes = {
@@ -1481,9 +1227,6 @@ export class AdaptableAgGrid {
             }
             return patchedColumnTypes;
         });
-        /**
-         * `dataTypeDefinitions`
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'dataTypeDefinitions', () => {
             const revertedDateTypeDefinitions = agGridDataTypeDefinitions;
             return revertedDateTypeDefinitions;
@@ -1494,12 +1237,7 @@ export class AdaptableAgGrid {
                 caseSensitive: !!this.adaptableOptions.quickSearchOptions.isQuickSearchCaseSensitive,
             };
         });
-        /**
-         * suppressOverlays
-         */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'suppressOverlays', (original_suppressOverlays) => {
-            // we want to suppress the exporting overlay because having it enabled will turn api.exportDataAsExcel() and api.exportDataAsCsv() into async operations,
-            // see #export_data_synchronously
             let suppressOverlays = original_suppressOverlays || [];
             if (!suppressOverlays.includes('exporting')) {
                 suppressOverlays.push('exporting');
@@ -1507,9 +1245,6 @@ export class AdaptableAgGrid {
             return suppressOverlays;
         });
     }
-    /**
-     * Either initializes the AG Grid instance or delegates it to the framework wrappers (React/Anglar)
-     */
     async initializeAgGrid(gridOptions, modules, renderAgGridFrameworkComponent) {
         if (renderAgGridFrameworkComponent) {
             let result = false;
@@ -1523,8 +1258,6 @@ export class AdaptableAgGrid {
                 return false;
             }
             const agGridApi = result;
-            // framework wrapper may have altered the context value via props
-            // in that case, we have to re-populate it with the Adaptable context values
             const agGridContext = agGridApi.getGridOption('context');
             if (!agGridContext) {
                 return false;
@@ -1533,14 +1266,12 @@ export class AdaptableAgGrid {
                 agGridContext.__adaptable = this;
                 agGridContext.adaptableApi = this.api;
             }
-            // framework wrapper may pass the rowData as a prop
             const rowData = agGridApi.getGridOption('rowData');
             this.initWithLazyData = rowData == undefined || rowData.length === 0;
             if (this.initWithLazyData) {
                 this.logger.info('Initializing with lazy data (no initial rowData).');
             }
             if (!this.getAgGridContainerElement()) {
-                // initialize the agGridContainerElement from the AgGrid instance
                 const gridRoot = this.agGridAdapter.getAgGridRootElement();
                 const gridContainer = gridRoot?.closest('[class*="ag-theme"]');
                 if (!gridContainer) {
@@ -1584,8 +1315,6 @@ export class AdaptableAgGrid {
         }
         return this.DANGER_USE_GETTER_adaptableContainerElement;
     }
-    // This method returns selected cells ONLY (if selection mode is cells or multiple cells).
-    // If the selection mode is row it will returns nothing - use the setSelectedRows() method
     refreshSelectedCellsState() {
         if (!this.isGridRangeSelectable()) {
             return;
@@ -1671,36 +1400,18 @@ export class AdaptableAgGrid {
         };
     }
     addGridEventListeners() {
-        /**
-         * Intercept 3 DOM events and emit them as Adaptable events:
-         * KeyDown
-         * MouseEnter
-         * MouseLeave
-         */
         const gridContainerElement = this.getAgGridContainerElement();
         if (gridContainerElement) {
-            gridContainerElement.addEventListener('keydown', (this.agGridListenerKeydown = (event) => this._emit('KeyDown', event)), 
-            // This is needed to be able to prevent the editor to be opened
-            // in bubling phase the opening is not prevented with ag-grid v30
-            true);
+            gridContainerElement.addEventListener('keydown', (this.agGridListenerKeydown = (event) => this._emit('KeyDown', event)), true);
             gridContainerElement.addEventListener('mouseenter', (this.agGridListenerMouseEnter = (event) => {
                 this._emit('MouseEnter', event);
             }), true);
             gridContainerElement.addEventListener('mouseleave', (this.agGridListenerMouseLeave = (event) => this._emit('MouseLeave', event)));
         }
-        /**
-         * Use Case: User has started inline editing but its disabled in Row Form Options
-         * Action: Stop editing
-         */
         this.agGridAdapter.getAgGridApi().addEventListener('cellEditingStarted', (this.listenerCellEditingStarted = () => {
             if (this.adaptableOptions.rowFormOptions.disableInlineEditing)
                 this.agGridAdapter.getAgGridApi().stopEditing();
         }));
-        /**
-         * Use Case: Grid was already set up and now the initial data has been displayed
-         * Action1: Update the Column Model
-         * Action2: Refresh Calculated Columns
-         */
         this.agGridAdapter.getAgGridApi().addEventListener('firstDataRendered', (this.listenerFirstDataRendered = () => {
             if (this.initWithLazyData) {
                 this.updateColumnModelAndRefreshGrid();
@@ -1709,10 +1420,6 @@ export class AdaptableAgGrid {
             }
             this.autoSizeLayoutIfNeeded();
         }));
-        /**
-         * Use Case: A format column that has ColumnGroupScope needs to be re-evaluated
-         * whenever a column group is expanded or collapsed
-         */
         this.agGridAdapter.getAgGridApi().addEventListener('columnGroupOpened', (this.listenerColumnGroupOpened = () => {
             if (this.api.formatColumnApi.getActiveFormatColumns().some((fc) => {
                 return fc.ColumnGroupScope != null;
@@ -1720,10 +1427,6 @@ export class AdaptableAgGrid {
                 this.updateColumnModelAndRefreshGrid();
             }
         }));
-        /**
-         * Use Case: A pivot column has changed
-         * Action: Autosize pivot columns (if autosize pivot in Layout is true)
-         */
         this.agGridAdapter.getAgGridApi().addEventListener('columnPivotChanged', (this.listenerPivotChanged = (params) => {
             if (params.type == 'columnPivotChanged' &&
                 params.columnApi != null &&
@@ -1734,10 +1437,6 @@ export class AdaptableAgGrid {
                 }
             }
         }));
-        /**
-         * Use Case: User has selected Rows or opened a Row Group
-         * Action: Set Selected Rows (on a debounce of 500ms)
-         */
         this.debouncedSetSelectedRows = debounce(() => {
             if (!this.isReady) {
                 return;
@@ -1754,10 +1453,6 @@ export class AdaptableAgGrid {
                 this.debouncedSetSelectedRows();
             }
         }));
-        /**
-         * Use Case: User has selected a range of cells
-         * Action: Set Selected Cells (on a debounce of 250ms)
-         */
         this.debouncedSetSelectedCells = debounce(() => {
             if (!this.isReady) {
                 return;
@@ -1769,19 +1464,10 @@ export class AdaptableAgGrid {
                 this.debouncedSetSelectedCells();
             }
         }));
-        /**
-         * Use Case: Sort has changed in the Grid
-         * Action1: Fire the Grid Sorted Event
-         * Action2: Set Selected Cells (on a debounce)
-         */
         this.agGridAdapter.getAgGridApi().addEventListener('sortChanged', (this.listenerSortChanged = () => {
             this.debouncedSetSelectedCells();
             this.api.eventApi.internalApi.fireGridSortedEvent();
         }));
-        /**
-         * Use Case: Charts have been created or destroyed, Chart ranges selected or Chart options changed
-         * Action: Call onChartModelChange in Charting Service
-         */
         const eventsThatTriggerChartingChanges = [
             'chartCreated',
             'chartRangeSelectionChanged',
@@ -1789,17 +1475,13 @@ export class AdaptableAgGrid {
             'chartDestroyed',
         ];
         if (this.ModuleService.isAdapTableModulePresent('Charting')) {
-            // We need to break the loop of charting changes for 'chartOptionsChanged', which is triggered by the subsequent agGridApi.updateChart(...)
-            // see #ag_grid_update_chart_loop
             let lastChartOptionsChangePayload = '';
             this.listenerGlobalChartingChanges = (type, params) => {
                 if (eventsThatTriggerChartingChanges.includes(type)) {
                     if (type === 'chartOptionsChanged') {
-                        // Exclude api and context
                         const { api, context, ...sanitizedParams } = params || {};
                         const eventPayload = JSON.stringify(sanitizedParams);
                         if (eventPayload === lastChartOptionsChangePayload) {
-                            // this is a loop, so we ignore it
                             return;
                         }
                         lastChartOptionsChangePayload = eventPayload;
@@ -1809,10 +1491,6 @@ export class AdaptableAgGrid {
             };
             this.agGridAdapter.getAgGridApi().addGlobalListener(this.listenerGlobalChartingChanges);
         }
-        /**
-         * Row and Cell listeners created in 2020
-         * These have supplanted many of the events we previously had and simplified things
-         */
         this.rowListeners = {
             dataChanged: (event) => {
                 this.onRowDataChanged({
@@ -1876,7 +1554,6 @@ export class AdaptableAgGrid {
         return thePlugin;
     }
     initServices() {
-        // create the services
         this.LicenseService = this.initLicenseService();
         this.ChartingService = new ChartingService(this.api);
         this.ThemeService = new ThemeService(this.api);
@@ -1890,7 +1567,6 @@ export class AdaptableAgGrid {
         this.AnnotationsService = new AnnotationsService(this.api);
         this.FlashingCellService = new FlashingCellService(this.api);
         this.RowFormService = new RowFormService(this.api);
-        this.MetamodelService = new MetamodelService(() => this.api.optionsApi.getAdaptableOptions(), true);
     }
     initLicenseService() {
         const globalObject = typeof globalThis !== 'undefined' ? globalThis : window;
@@ -1938,20 +1614,13 @@ export class AdaptableAgGrid {
         modules.set(ModuleConstants.ToolPanelModuleId, new ToolPanelModule(this.api));
         return modules;
     }
-    /**
-     * This method contains all the updates on the AdaptableState which were made AFTER Adaptbale was ready
-     * This was contidioned because we required AG Grid to be ready before we could make these updates
-     * We should be able to refactor the code, no that we no fore sure that Adaptable State is ready BEFORE AG Grid init
-     */
     temporaryAdaptableStateUpdates() {
         this.api.eventApi.on('AdaptableReady', () => {
-            // update status bar state
             const adaptableStatusPanels = this.agGridAdapter
                 .getAgGridApi()
                 .getGridOption('statusBar')
                 ?.statusPanels?.filter((statusPanel) => this.adaptableStatusPanelKeys.includes(statusPanel.key)) ?? [];
             const statusBarModule = this.ModuleService.getModuleById(ModuleConstants.StatusBarModuleId);
-            // need to add only the adaptable panels
             statusBarModule.syncStateWithOptions(adaptableStatusPanels);
         });
     }
@@ -1960,16 +1629,13 @@ export class AdaptableAgGrid {
             return;
         }
         const primaryKey = this.adaptableOptions.primaryKey;
-        // first check if there is a primary key column
         const primaryKeyColDef = this.agGridAdapter.getAgGridApi().getColumnDef(primaryKey);
         if (!primaryKeyColDef) {
             let errorMessage;
-            // if no primary key column then lets check the first row to see if its a data item
             const primaryKeyDataItem = this.getFirstRowNode()?.data[primaryKey];
             if (!primaryKeyDataItem) {
                 errorMessage = `Primary key column "${this.adaptableOptions.primaryKey}" not found. This will affect many Adaptable features.`;
                 if (this.adaptableOptions.alertOptions.showMissingPrimaryKeyAlert) {
-                    // show an alert if that is the option
                     this.api.alertApi.showAlertError('No Primary Key', errorMessage);
                 }
                 else {
@@ -2022,12 +1688,10 @@ export class AdaptableAgGrid {
         this.api.gridApi.internalApi.setColumns(allColumns);
     }
     checkShouldClearExistingFiltersOrSearches() {
-        // if they have selected to clear Filters on startup then do it
         if (this.adaptableOptions.filterOptions.clearFiltersOnStartUp) {
             this.logger.warn('Clearing saved filters (clearFiltersOnStartUp is enabled).');
             this.api.filterApi.clearAllFilters();
         }
-        // if they have selected to clear searches on startup then do it
         if (this.adaptableOptions.quickSearchOptions.clearQuickSearchOnStartUp) {
             this.logger.warn('Clearing saved Quick Search (clearQuickSearchOnStartUp is enabled).');
             this.api.quickSearchApi.clearQuickSearch();
@@ -2050,9 +1714,6 @@ export class AdaptableAgGrid {
         const foundNode = parentRowNode.childrenAfterFilter?.find((c) => c.id == rowNode.id);
         return foundNode != null;
     }
-    /**
-     * Use (lazy evaluated) getters to avoid unnecessary calculations and memoization to avoid recalculating the same values
-     */
     createGridCell(rowNode, columnId, defaults) {
         let _column;
         let _primaryKeyValue;
@@ -2075,12 +1736,9 @@ export class AdaptableAgGrid {
             if (_rawValue === undefined) {
                 _rawValue = self.getRawValueFromRowNode(rowNode, columnId);
                 if (_rawValue?.value != undefined && getIsPivotCell()) {
-                    // for pivot result columns, the raw value is an object with a value property
-                    // we want to return the value property as the raw value
                     _rawValue = _rawValue.value;
                 }
                 if (_rawValue?.value != undefined && typeof _rawValue.toString === 'function') {
-                    // handle columns with custom valueGetters
                     _rawValue = _rawValue.value;
                 }
             }
@@ -2139,17 +1797,12 @@ export class AdaptableAgGrid {
         const agGridApi = gridApi || this.agGridAdapter.getAgGridApi();
         let result;
         if (!this.hasAutogeneratedPrimaryKey) {
-            // support both AG Grid pre & post v31.3.x
-            // TODO remove this with the next major Adaptable version
             result = this.agGridAdapter._agGridApi_getValue(this.adaptableOptions.primaryKey, rowNode, agGridApi);
         }
         if (result == undefined && rowNode.data) {
             result = rowNode.data[this.adaptableOptions.primaryKey];
         }
         if (result == undefined && rowNode.id != undefined) {
-            // when getPrimaryKeyValueFromRowNode is called for group rows,
-            // which don't have a rowNode.data object, the result is undefined
-            // but we do have an id property on the rowNode object, so we'll use that
             result = rowNode.id;
         }
         return result;
@@ -2202,7 +1855,6 @@ export class AdaptableAgGrid {
         if (!column) {
             return rawValue;
         }
-        // prevents from null
         if (rawValue === undefined || rawValue === null) {
             return rawValue;
         }
@@ -2214,11 +1866,9 @@ export class AdaptableAgGrid {
             if (typeof rawValue === 'number') {
                 return rawValue;
             }
-            // empty string or space should not be converted to 0
             if (typeof rawValue === 'string') {
                 return StringExtensions.IsNumeric(rawValue) ? Number(rawValue) : rawValue;
             }
-            // handle objects with toString() (e.g. from valueGetters)
             const numValue = Number(rawValue);
             return isNaN(numValue) ? rawValue : numValue;
         }
@@ -2261,9 +1911,6 @@ export class AdaptableAgGrid {
     refreshHeader() {
         this.agGridAdapter.getAgGridApi().refreshHeader();
     }
-    // TODO AFL: this method seems to be used A LOT
-    // we should check if we couldn't use the `refresh` method instead for some cases
-    // see https://www.ag-grid.com/react-data-grid/view-refresh/#redraw-rows
     redrawRows(rowNodes) {
         const redrawRowsParams = rowNodes
             ? {
@@ -2350,7 +1997,6 @@ export class AdaptableAgGrid {
         this.agGridAdapter.getAgGridApi().selectAll();
     }
     deselectAll() {
-        // need to do both as first just clears selected rows and second clears ranges
         this.agGridAdapter.getAgGridApi().deselectAll();
         this.agGridAdapter.getAgGridApi().clearCellSelection();
     }
@@ -2363,7 +2009,6 @@ export class AdaptableAgGrid {
         }
         this.agGridAdapter.setGridOption('rowData', dataSource);
         this.updateRowGroupsAndColumnGroupsExpandedState();
-        // this.updateColumnModelAndRefreshGrid();
     }
     getGridData() {
         const data = [];
@@ -2379,7 +2024,6 @@ export class AdaptableAgGrid {
             rowData[i][AUTOGENERATED_PK_COLUMN] = createUuid();
         }
     }
-    // add a synthetic PK only if missing (useful in case of updating row data)
     addSyntheticPrimaryKeyIfMissing(rowData = []) {
         this.adaptableOptions.primaryKey = AUTOGENERATED_PK_COLUMN;
         for (let i = 0; i < rowData.length; i++) {
@@ -2397,8 +2041,6 @@ export class AdaptableAgGrid {
     getFirstRowNode() {
         let firstRowNode = this.getFirstDisplayedRowNode();
         if (firstRowNode?.group) {
-            // all groups may be closed so it is safer to get first leaf node
-            // all groups should have at least one leafe node (though not necessarily if using SSRM)
             if (ArrayExtensions.IsNotNullOrEmpty(firstRowNode.allLeafChildren)) {
                 firstRowNode = firstRowNode.allLeafChildren[0];
             }
@@ -2437,10 +2079,6 @@ export class AdaptableAgGrid {
         });
         return data;
     }
-    /**
-     * This method internally differentiates between server-side and client-side row model
-     * and correctly calls the appropriate method as per the current row model type
-     */
     applyAgGridTransaction(transaction) {
         const isServerSideRowModel = this.getAgGridRowModelType() === 'serverSide';
         const agGridApi = this.agGridAdapter.getAgGridApi();
@@ -2448,10 +2086,6 @@ export class AdaptableAgGrid {
             ? agGridApi.applyServerSideTransaction(transaction)
             : agGridApi.applyTransaction(transaction);
     }
-    /**
-     * This method internally differentiates between server-side and client-side row model
-     * and correctly calls the appropriate method as per the current row model type
-     */
     applyAgGridTransactionAsync(transaction, callback) {
         const isServerSideRowModel = this.getAgGridRowModelType() === 'serverSide';
         const agGridApi = this.agGridAdapter.getAgGridApi();
@@ -2713,12 +2347,8 @@ export class AdaptableAgGrid {
     async getDistinctFilterValuesForColumn(options) {
         const { column, previousResult } = options;
         const self = this;
-        // First get the Grid Cells in the Column
         let currentGridCells;
         const getCurrentGridCells = () => {
-            // we do this in a function so it's lazy
-            // but we also store in the outside closure, so we can reuse the value if
-            // already called
             if (currentGridCells) {
                 return currentGridCells;
             }
@@ -2729,7 +2359,6 @@ export class AdaptableAgGrid {
                         ? this.getDistinctGridCellsForDateColumn(column)
                         : this.getDistinctGridCellsForColumn(column));
         };
-        // No distinct values so lets return unique grid cells
         const mapFn = (gridCell, level) => {
             if (level || Array.isArray(gridCell.children)) {
                 const cell = gridCell;
@@ -2758,7 +2387,6 @@ export class AdaptableAgGrid {
                 label: gridCell.displayValue,
             };
         };
-        // If there are custom distinct value, return them; otherwise return the Grids Cells just retrieved
         const customInFilterValues = this.adaptableOptions.filterOptions.customInFilterValues;
         if (customInFilterValues) {
             const gridApiInternal = this.api.gridApi.internalApi;
@@ -2872,9 +2500,7 @@ export class AdaptableAgGrid {
     }
     async getDistinctEditValuesForColumn(options) {
         const { column, gridCell } = options;
-        // First get the Grid Cells in the Column
         const currentGridCells = this.getDistinctGridCellsForColumn(column);
-        // If there are custom distinct value, return them, but only if a module has been specifically set
         const customEditColumnValues = this.adaptableOptions.editOptions.customEditColumnValues;
         if (customEditColumnValues) {
             const customEditValuesContext = {
@@ -2908,7 +2534,6 @@ export class AdaptableAgGrid {
                 return customDistinctValues ?? [];
             }
         }
-        // No distinct values so lets return unique grid cells
         return currentGridCells.map((gridCell) => {
             const result = {
                 value: gridCell.rawValue,
@@ -2920,8 +2545,6 @@ export class AdaptableAgGrid {
     getDistinctGridCellsForGroupedColumn(rowNodes) {
         const groupedColumns = this.api.columnApi.getRowGroupedColumns();
         const treeMode = this.api.gridApi.isTreeDataGrid();
-        // if we're not in tree mode, return if there are no grouped columns
-        // but in tree mode, we have to continue, even if there are no grouped columns
         if (!groupedColumns.length && !treeMode) {
             return [];
         }
@@ -2941,15 +2564,11 @@ export class AdaptableAgGrid {
                 currentParentGridCells.length = level;
             }
             prevLevel = level;
-            // for non-tree mode
-            // or for tree mode, if the rowNode has data - so it's not a filler group
             if (!treeMode || (treeMode && rowNode.data)) {
                 currentGroupKey.push(key);
             }
             const parentGridCell = currentParentGridCells[currentParentGridCells.length - 1];
             const gridCell = this.addDistinctColumnValue(rowNode, AG_GRID_GROUPED_COLUMN, false);
-            // for tree-mode filler nodes, we might end up without a gridCell
-            // so we need to make sure it's defined
             if (gridCell) {
                 gridCell.leafChildrenCount = rowNode.allLeafChildren?.length ?? 0;
                 currentParentGridCells.push(gridCell);
@@ -2984,7 +2603,6 @@ export class AdaptableAgGrid {
             const initialCell = this.addDistinctColumnValue(rowNode, column.columnId, isPivotResultColumn);
             if (initialCell) {
                 const value = initialCell.rawValue;
-                // we want to filter out empty values
                 if (value === '' || value === null || value === undefined) {
                     return;
                 }
@@ -3024,7 +2642,6 @@ export class AdaptableAgGrid {
                 treeDeepMap.set([year, month, day], dayCells);
                 if (includeTime) {
                     const timeCells = treeDeepMap.get([year, month, day, dateInstance.getTime()]) || [];
-                    // if the value is a string, let's use it as the final raw value
                     const timeRawValue = typeof value === 'string' ? value : `${dateInstance.toISOString()}`;
                     let timeDisplayValue = typeof value === 'string'
                         ? value
@@ -3057,7 +2674,6 @@ export class AdaptableAgGrid {
         for (const keys of years) {
             const [year] = keys;
             const yearCells = treeDeepMap.get([year]) || [];
-            // should only be one item in the uniqueYearCells array
             const uniqueYearCell = this.getUniqueGridCells(column, yearCells)[0];
             if (!uniqueYearCell) {
                 continue;
@@ -3077,7 +2693,6 @@ export class AdaptableAgGrid {
                 }
                 uniqueMonthCell.children = [];
                 uniqueYearCell.children.push(uniqueMonthCell);
-                // those are all the days for which there are values in this year/month
                 const keysForMonth = treeDeepMap.getKeysStartingWith([year, month], {
                     depthLimit: 1,
                     excludeSelf: true,
@@ -3136,12 +2751,7 @@ export class AdaptableAgGrid {
             const gridCell = this.addDistinctColumnValue(rowNode, column.columnId, isPivotResultColumn);
             if (gridCell) {
                 const value = gridCell.rawValue;
-                // we want to filter out empty values
                 if (value === '' || value === null || value === undefined) {
-                    // 2025-10-31: we want to allow empty values to be included
-                    // after all - they are not displayed by default
-                    // but will be accessible in the customInFilterValues callback
-                    // return;
                 }
                 gridCells.push(gridCell);
             }
@@ -3161,17 +2771,11 @@ export class AdaptableAgGrid {
         if (!isPivotResultColumn && this.isGroupRowNode(rowNode)) {
             if (this.api.gridApi.isTreeDataGrid()) {
                 if (rowNode.data == undefined) {
-                    // skip Tree Filler Groups
-                    // see https://www.ag-grid.com/javascript-data-grid/tree-data-paths/#filler-groups
                     return;
                 }
-                // if (columnId !== AG_GRID_GROUPED_COLUMN) {
-                //   return;
-                // }
                 return this.getGridCellFromRowNode(rowNode, columnId);
             }
             else {
-                // for normal Table Columns we do NOT return the values of the aggregates
                 if (columnId !== AG_GRID_GROUPED_COLUMN) {
                     return;
                 }
@@ -3179,12 +2783,10 @@ export class AdaptableAgGrid {
             }
         }
         if (isPivotResultColumn) {
-            // if it's a Pivot Result Column, we are interested only in the aggregated(pivoted) data
             if (!rowNode.aggData) {
                 return;
             }
             if (!rowNode.leafGroup) {
-                // if it's a Pivot Result Column, we are interested only in the leaf groups (pivot results, NOT group aggregates)
                 return;
             }
         }
@@ -3206,17 +2808,12 @@ export class AdaptableAgGrid {
             return value;
         };
         const self = this;
-        // handle the special case where GridCells have arrays as values
-        // in this case we want to treat each value in the array as a separate value
         if (this.api.columnApi.internalApi.hasArrayDataType(column)) {
             gridCellsToUse = gridCellsToUse.flatMap((gridCell) => {
                 const rawValueArray = gridCell.rawValue;
                 if (Array.isArray(rawValueArray)) {
                     return rawValueArray.map((rawValue) => ({
                         ...gridCell,
-                        // for now just map the rawValue
-                        // extracting displayValue and normalisedValue is possible
-                        // but it could have a significant performance impact
                         rawValue: rawValue,
                         displayValue: rawValue,
                         normalisedValue: rawValue,
@@ -3225,12 +2822,6 @@ export class AdaptableAgGrid {
                 return [gridCell];
             });
         }
-        // those are grid cells unique per primary key - so cells corresponding to this column
-        // by for every row in the grid
-        // but here we want to collapse them down to values/cells unique by the
-        // value of this column: eg - if this is country column and we have multiple rownodes
-        // in the grid with country: UK, and multiple with country: France, then the end result
-        // of the current function should be 2 cells: one for UK and one for France
         gridCellsToUse.forEach((dataItem) => {
             const value = getter(dataItem);
             if (!cache.has(value)) {
@@ -3250,7 +2841,6 @@ export class AdaptableAgGrid {
         cache.forEach(({ count, cell, rowNodesWithSameCellValue }) => {
             const cellWithCount = cell;
             cellWithCount.count = count;
-            // the visibility of this cell is true if any of the row nodes with this value is visible
             Object.defineProperty(cellWithCount, 'visible', {
                 get: () => {
                     return (rowNodesWithSameCellValue.findIndex((pk) => self.isRowNodeAvailableAfterFiltering(pk) === true) !== -1);
@@ -3313,14 +2903,11 @@ export class AdaptableAgGrid {
         return this.agGridAdapter.getGridOption('statusBar')?.statusPanels ?? [];
     }
     updateCell(cellUpdateRequest) {
-        // 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
         const rowNode = cellUpdateRequest.rowNode ?? this.getRowNodeForPrimaryKey(cellUpdateRequest.primaryKeyValue);
         if (!rowNode) {
             this.logger.warn(`updateCell() - rowNode not found for primaryKeyValue: ${cellUpdateRequest.primaryKeyValue}`);
             return;
         }
-        // update the row node and set it as an edit (for AG Grid Cell Change Detection)
         rowNode.setDataValue(cellUpdateRequest.columnId, cellUpdateRequest.newValue, 'edit');
     }
     forAllRowNodesDo(func, config) {
@@ -3334,8 +2921,6 @@ export class AdaptableAgGrid {
     }
     forAllVisibleRowNodesDo(func, config) {
         if (this.getAgGridRowModelType() !== 'clientSide') {
-            // only in client-side row model can we loop through filtered&sorted rows
-            // see https://www.ag-grid.com/javascript-data-grid/accessing-data/#iterating-rows
             this.logger.warn('forAllVisibleRowNodesDo() is only supported with client-side row model. Falling back to forAllRowNodesDo().');
             return this.forAllRowNodesDo(func, config);
         }
@@ -3348,8 +2933,6 @@ export class AdaptableAgGrid {
         });
     }
     getAgGridRowModelType(gridOptions) {
-        // it seems that this can be null so we need explicitly to return "clientSide" in this case
-        // need to check that for ServerSideRowModel it is ALWAYS returned...
         if (gridOptions) {
             return gridOptions.rowModelType ?? 'clientSide';
         }
@@ -3486,16 +3069,10 @@ export class AdaptableAgGrid {
             this.logger.consoleError('Cannot call showChart before Adaptable is fully initialized.');
             return null;
         }
-        /**
-         * Ag-grid always creates new charts behind the sences.
-         * So we need to update the model inside adaptable state.
-         * This is important to be done as soon as possible so it is not considered new.
-         */
         const chartRef = this.agGridAdapter
             .getAgGridApi()
             .restoreChart(chartDefinition.Model, container);
         const chartModel = this.getChartModels().find((chartModel) => chartModel.chartId === chartRef.chartId);
-        // Update the definition in state so it is not considered new
         this.api.chartingApi.editChartDefinition({
             ...chartDefinition,
             Model: chartModel,
@@ -3508,16 +3085,12 @@ export class AdaptableAgGrid {
             return;
         }
         const upgradableProperties = {
-            // Only Range charts are supported to be created at run time
-            // the other two are pivot & cross-filter
             type: 'rangeChartUpdate',
             chartId: chart.Model.chartId,
             unlinkChart: Boolean(chart.Model.unlinkChart),
             suppressChartRanges: Boolean(chart.Model.suppressChartRanges),
             aggFunc: chart.Model.aggFunc,
         };
-        // Skip the AG Grid API call if the upgradable properties haven't changed
-        // to avoid unnecessary chartOptionsChanged events (see #ag_grid_update_chart_loop)
         const currentModel = this.getChartModels().find((model) => model.chartId === chart.Model.chartId);
         if (currentModel &&
             Boolean(currentModel.unlinkChart) === upgradableProperties.unlinkChart &&
@@ -3525,7 +3098,6 @@ export class AdaptableAgGrid {
             currentModel.aggFunc === upgradableProperties.aggFunc) {
             return;
         }
-        // see also #ag_grid_update_chart_loop
         this.agGridAdapter.getAgGridApi().updateChart(upgradableProperties);
     }
     getChartModels() {
@@ -3612,9 +3184,6 @@ export class AdaptableAgGrid {
         const themeClassNamesToRemove = [];
         const themesToRemove = [];
         const allThemes = this.api.themeApi.getThemes().map((t) => {
-            // we mutate the theme later,
-            // and since we don't want the mutation to end up in state
-            // we better clone it here
             return { ...t };
         });
         const allThemesMap = allThemes.reduce((acc, theme) => {
@@ -3622,8 +3191,6 @@ export class AdaptableAgGrid {
             return acc;
         }, {});
         const themeObject = allThemesMap[themeName];
-        // REMOVE PREVIOUS THEME
-        // const themePrefix = 'ab--theme-'
         const el = document.documentElement;
         el.classList.forEach((cssClassName) => {
             const index = cssClassName.indexOf(GeneralConstants.THEME_STYLE);
@@ -3636,17 +3203,14 @@ export class AdaptableAgGrid {
             }
         });
         themeClassNamesToRemove.forEach((cssClassName) => el.classList.remove(cssClassName));
-        // remove infinite table classnames
         themesToRemove.forEach((theme) => {
             el.classList.remove(`infinite-theme-mode--${theme.Name}`);
         });
         el.classList.remove(`infinite-theme-name--default`);
-        // VARIANT
         let variantTheme = '';
         if (!isSystemTheme && themeObject.Variant) {
             variantTheme = themeObject.Variant;
         }
-        // APPLY NEW THEME
         const newTheme = allThemesMap[themeName];
         const getClassName = (theme) => GeneralConstants.THEME_STYLE + theme;
         el.classList.add(getClassName(themeName));
@@ -3654,16 +3218,13 @@ export class AdaptableAgGrid {
             el.classList.add(getClassName(variantTheme));
         }
         if (isSystemTheme) {
-            // add infinite table classname for theme
             el.classList.add(`infinite-theme-mode--${themeName}`);
         }
         else if (variantTheme) {
             el.classList.add(`infinite-theme-mode--${variantTheme}`);
         }
         el.classList.add(`infinite-theme-name--default`);
-        // Update AG THEME
         this.agGridThemeAdapter.applyAgGridThemeOnAdaptableThemeChange(newTheme, variantTheme, container, themesToRemove);
-        // MAC LIKE SCROLLBARS
         if (this.adaptableOptions.userInterfaceOptions &&
             this.adaptableOptions.userInterfaceOptions.useCustomMacLikeScrollbars &&
             getScrollbarSize() > 0) {
@@ -3746,7 +3307,6 @@ export class AdaptableAgGrid {
             value = sum / distinctRawValues.length;
         }
         else {
-            // median - sort a shallow copy so we don't mutate the source
             const sorted = [...distinctRawValues].sort((a, b) => a - b);
             const mid = Math.floor(sorted.length / 2);
             value = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
@@ -3765,7 +3325,6 @@ export class AdaptableAgGrid {
             };
         }
         else {
-            // should not happen unless someone ignored the TypeScript warnings
             if (config.unmount == undefined) {
                 config.unmount = true;
             }
@@ -3858,7 +3417,6 @@ export class AdaptableAgGrid {
         this.columnMinMaxValuesCache = null;
         this.lifecycleState = 'preDestroyed';
         AdaptableAgGrid.dismissInstance(this);
-        // !! this has to be before clearing up references to container and/or adaptableOptions
         if (config?.unmount) {
             const abContainerElement = this.getAdaptableContainerElement();
             if (abContainerElement != null) {
@@ -3896,8 +3454,6 @@ export class AdaptableAgGrid {
         this.TeamSharingService = null;
         this.RowFormService?.destroy?.();
         this.RowFormService = null;
-        this.MetamodelService?.destroy?.();
-        this.MetamodelService = null;
         this.LicenseService?.destroy?.();
         this.LicenseService = null;
         this.FlashingCellService?.destroy?.();
@@ -3964,7 +3520,6 @@ export class AdaptableAgGrid {
         const perfSetLayout = this.logger.beginPerf(`setLayout(${layout.Name})`);
         const setLayoutMarker = getMarker(this.adaptableOptions.adaptableId).track.Runtime.label.SetLayout.start();
         const isPivot = isPivotLayout(layout);
-        // update the header name for all columns
         this.agGridAdapter
             .getAgGridApi()
             .getColumns()
@@ -3980,9 +3535,6 @@ export class AdaptableAgGrid {
             };
             this.agGridColumnAdapter.setupColumnHeader(colSetupInfo);
         });
-        // need to refresh the header,
-        // as the Layout.ColumnHeaders state property is not implemented in the LayoutManager
-        // and is specific to Adaptable, therefore we need to refresh it manually
         if (!prevLayout ||
             JSON.stringify(prevLayout.ColumnHeaders) !== JSON.stringify(layout.ColumnHeaders)) {
             this.refreshHeader();
@@ -4007,7 +3559,6 @@ export class AdaptableAgGrid {
                 });
             }
         }
-        // this.showQuickFilter()
         this.forPlugins((plugin) => {
             if (plugin.afterSetLayout) {
                 plugin.afterSetLayout(this, layout);
@@ -4097,10 +3648,6 @@ export class AdaptableAgGrid {
                 oldValue: oldValue,
                 newValue: newValue,
                 column: abColumn,
-                /**
-                 * A grouped row does not have an underling data item.
-                 * Because of this we use the rowNode.id as an identifier.
-                 */
                 primaryKeyValue: rowNode.id,
                 rowNode: rowNode,
                 trigger: 'aggChange',
@@ -4126,29 +3673,21 @@ export class AdaptableAgGrid {
         this.performPostEditChecks(rowNode, [cellDataChangedInfo]);
     }
     isUndoChange(dataChange) {
-        // check if this is not a reverted change
         const undoChange = this.api.internalApi.getDataService().extractUndoChange(dataChange);
         return !!undoChange;
     }
-    /**
-     * There are a few things we need to do AFTER we edit a cell and it makes sense to put them in one place
-     */
     performPostEditChecks(rowNode, cellDataChangedInfos) {
         cellDataChangedInfos = expandCellDataChangedInfosWithCalculatedColumns(this.api, cellDataChangedInfos);
         cellDataChangedInfos.forEach((cellDataChangedInfo) => {
-            // if a Cell Data Change is undone, log to the Console
             if (cellDataChangedInfo.trigger === 'undo') {
                 this.logger.info(`Data change reverted: column="${cellDataChangedInfo.column}", primaryKey="${cellDataChangedInfo.primaryKeyValue}", from=${cellDataChangedInfo.newValue} to=${cellDataChangedInfo.oldValue}`);
             }
-            // For Changes except Aggregations, reset cell selection if required
             if (cellDataChangedInfo.trigger === 'edit' ||
                 cellDataChangedInfo.trigger === 'undo' ||
                 cellDataChangedInfo.trigger === 'tick') {
                 this.checkIfChangedCellCurrentlySelected(cellDataChangedInfo);
             }
-            // Call the Data Service to create an Internal Event so other parts of App can respond
             this.DataService.CreateCellDataChangedEvent(cellDataChangedInfo);
-            // Reset Min and Max values for the Column
             this.resetMinMaxCachedValueForColumn(cellDataChangedInfo.column);
         });
         this.refreshCellsBasedOnCellDataChange(rowNode, cellDataChangedInfos);
@@ -4163,20 +3702,16 @@ export class AdaptableAgGrid {
         }
     }
     refreshCellsBasedOnCellDataChange(rowNode, cellDataChangedInfos) {
-        //  Check if node is visible as otherwise AG Grid wont refresh
         if (this.agGridAdapter.isVisibleNode(rowNode)) {
             let dataChangedScope = {
                 wholeRow: false,
                 columnIds: new Set(),
             };
-            // First check Format Column Expressions
             this.checkFormatColumnExpressionStyleChanges(dataChangedScope, cellDataChangedInfos);
-            //  If Scope is whole row then redraw row and return
             if (dataChangedScope.wholeRow) {
                 this.redrawRow(rowNode);
                 return;
             }
-            // Next check for Format Column Predicates, Styled Columns and FreeText Columns to update the ColumnIds refresh list as required
             this.checkFormatColumnPredicateStyleChanges(dataChangedScope, cellDataChangedInfos);
             this.checkFreeTextColumnChanges(dataChangedScope, cellDataChangedInfos);
             this.checkStyledColumnComparisonChanges(dataChangedScope, cellDataChangedInfos);
@@ -4187,7 +3722,6 @@ export class AdaptableAgGrid {
     }
     refreshColumnsBasedOnCellDataChange(cellDataChangedInfos) {
         const columnIdsToUpdate = [];
-        // The only use case is Styled Columns with a Relative Cell Range
         cellDataChangedInfos.forEach((cellDataChangeInfo) => {
             const styledColumn = this.api.styledColumnApi.getActiveStyledColumnForColumn(cellDataChangeInfo.column);
             if (styledColumn &&
@@ -4296,15 +3830,8 @@ export class AdaptableAgGrid {
     }
     refreshLayout() {
         const columnDefs = this.agGridAdapter.getColumnDefinitionsInclSpecialColumns();
-        // this setGridOption call will also trigger layout.onColumnDefsChanged()
-        // which will in turn call updateColumnModelAndRefreshGrid
         this.agGridAdapter.setGridOption('columnDefs', columnDefs);
-        // the setGridOption call above already triggered updateColumnModelAndRefreshGrid,
-        // setting the dedup guard. We force the next call so that the column model
-        // is re-derived after the layout store has been updated.
         this.__forceUpdateColumnModel = true;
-        // this is needed here for when we call setAdaptableStateKey
-        // and pass a new config
         this.updateLayoutInManagerAfterStoreHasChanged();
         this.applyFiltering();
     }
@@ -4342,11 +3869,8 @@ export class AdaptableAgGrid {
     refreshAdaptableAfterLayoutChange(layout) {
         this.logger.info('Refreshing Adaptable after layout change.');
         const prevLayoutForRefresh = this.__prevLayoutForRefresh || this.api.layoutApi.getCurrentLayout();
-        // see #on-regroup-expect-group-column-to-be-recomputed-and-setup-properly
         const rowGroupsChanged = this.isRowGroupDifferentInLayout(prevLayoutForRefresh, layout);
         if (rowGroupsChanged) {
-            // when grouping changes, if we have a filter on the grouped column, we need to remove it
-            // as it is no longer valid
             if (layout.ColumnFilters) {
                 const newFilters = layout.ColumnFilters.filter((filter) => filter.ColumnId !== AG_GRID_GROUPED_COLUMN);
                 if (newFilters.length != layout.ColumnFilters.length) {
@@ -4354,7 +3878,6 @@ export class AdaptableAgGrid {
                     layout.ColumnFilters = newFilters;
                 }
             }
-            // also we need to reset the cache for the group column, when we have rowGripDisplayType single
             if (layout.RowGroupDisplayType === 'single' &&
                 (layout.RowGroupedColumns?.length || layout.PivotGroupedColumns?.length)) {
                 this.api.filterApi.columnFilterApi.resetFilterValues(AG_GRID_GROUPED_COLUMN);
@@ -4372,8 +3895,6 @@ export class AdaptableAgGrid {
         return layout;
     }
     validateColumnDefTypes(columnDefs) {
-        // in Adaptable version 20 we switched from colDef.type to colDef.cellDataType
-        // although we documented this change and try to infer the correct cellDataTypes, it's best to also check if the client dev forgot to adjust his colDefs
         columnDefs.forEach((colDef) => {
             if (colDef.children?.length) {
                 this.validateColumnDefTypes(colDef.children);