@adaptabletools/adaptable 22.0.0-canary.1 → 22.0.0-canary.3

package/src/View/GridInfo/GridInfoPopup/GridInfoPopup.js

@@ -1,82 +1,73 @@
 import * as React from 'react';
+import ArrayExtensions from '../../../Utilities/Extensions/ArrayExtensions';
+import { ADAPTABLE_VERSION } from '../../../EnvVars';
+import { AG_GRID_VERSION } from '../../../agGrid/AgGridModulesAdapter';
+import { DataSource, InfiniteTableGrid } from '../../../components/InfiniteTable';
 import Panel from '../../../components/Panel';
 import { Tabs } from '../../../components/Tabs';
-import ArrayExtensions from '../../../Utilities/Extensions/ArrayExtensions';
-import Helper from '../../../Utilities/Helpers/Helper';
-import { AdaptablePopover } from '../../AdaptablePopover';
-import { AdaptableObjectCollection } from '../../Components/AdaptableObjectCollection';
-import { AdaptableObjectRow } from '../../Components/AdaptableObjectRow';
 import { PopupPanel } from '../../Components/Popups/AdaptablePopup/PopupPanel';
 import { AdaptableObjectsSummary } from './AdaptableObjectsSummary';
-import { ADAPTABLE_VERSION } from '../../../EnvVars';
-import { AG_GRID_VERSION } from '../../../agGrid/AgGridModulesAdapter';
 import clsx from 'clsx';
 const adaptableVersion = ADAPTABLE_VERSION;
 const agGridVersion = AG_GRID_VERSION;
 export const GridInfoPopup = (props) => {
     const api = props.api;
-    const CreateGridSummaries = (colItems) => {
-        const returnRows = [];
-        const calcColumns = api.calculatedColumnApi
-            .getCalculatedColumns()
-            .map((c) => c.ColumnId);
-        const actionColumns = api.actionColumnApi
-            .getActionColumns()
-            .map((ac) => ac.columnId);
-        const freeTextColumns = api.freeTextColumnApi
-            .getFreeTextColumns()
-            .map((c) => c.ColumnId);
-        const columnFilterDescription = api.filterApi.columnFilterApi.columnFiltersToString(api.filterApi.columnFilterApi.getColumnFilters());
-        const gridFilterExpression = api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
-        const sorts = ArrayExtensions.IsNotNullOrEmpty(props.api.gridApi.getColumnSorts())
-            ? api.gridApi.getColumnSorts().map((gs) => {
-                return api.columnApi.getFriendlyNameForColumnId(gs.ColumnId) + ': ' + gs.SortOrder;
-            })
-            : null;
-        const selectedRowInfo = api.gridApi.getSelectedRowInfo();
-        if (api.optionsApi.getUserInterfaceOptions()?.showAdapTableVersion) {
-            returnRows.push(createReadOnlyColItem(colItems, 'AdapTable Version', adaptableVersion));
-        }
-        if (api.optionsApi.getUserInterfaceOptions()?.showAgGridVersion) {
-            returnRows.push(createReadOnlyColItem(colItems, 'AG Grid Version', agGridVersion));
-        }
-        returnRows.push(createReadOnlyColItem(colItems, 'Sorted Columns', ArrayExtensions.IsNotNullOrEmpty(sorts) ? sorts.join('; ') : 'None'));
-        returnRows.push(createReadOnlyColItem(colItems, 'Column Filters', columnFilterDescription));
-        returnRows.push(createReadOnlyColItem(colItems, 'Grid Filter', gridFilterExpression));
-        returnRows.push(createReadOnlyColItem(colItems, 'All Rows', props.api.gridApi.getRowCount()));
-        returnRows.push(createReadOnlyColItem(colItems, 'Visible Rows', props.api.gridApi.getVisibleRowCount()));
-        returnRows.push(createReadOnlyColItem(colItems, 'Selected Rows', selectedRowInfo?.gridRows.length));
-        returnRows.push(createReadOnlyColItem(colItems, 'Visible Selected Rows', selectedRowInfo?.gridRows.filter((gr) => gr.rowNode?.displayed == true).length));
-        returnRows.push(createReadOnlyColItem(colItems, 'All Columns', props.api.gridApi.getColumnCount()));
-        returnRows.push(createReadOnlyColItem(colItems, 'Visible Columns', props.api.gridApi.getVisibleColumnCount()));
-        returnRows.push(createReadOnlyColItem(colItems, 'Calculated Columns', ArrayExtensions.IsNotNullOrEmpty(calcColumns)
+    const keyValuePairs = [];
+    const calcColumns = api.calculatedColumnApi
+        .getCalculatedColumns()
+        .map((c) => c.ColumnId);
+    const actionColumns = api.actionColumnApi
+        .getActionColumns()
+        .map((ac) => ac.columnId);
+    const freeTextColumns = api.freeTextColumnApi
+        .getFreeTextColumns()
+        .map((c) => c.ColumnId);
+    const columnFilterDescription = api.filterApi.columnFilterApi.columnFiltersToString(api.filterApi.columnFilterApi.getColumnFilters());
+    const gridFilterExpression = api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
+    const sorts = ArrayExtensions.IsNotNullOrEmpty(props.api.gridApi.getColumnSorts())
+        ? api.gridApi.getColumnSorts().map((gs) => {
+            return api.columnApi.getFriendlyNameForColumnId(gs.ColumnId) + ': ' + gs.SortOrder;
+        })
+        : null;
+    const selectedRowInfo = api.gridApi.getSelectedRowInfo();
+    if (api.optionsApi.getUserInterfaceOptions()?.showAdapTableVersion) {
+        keyValuePairs.push({ Key: 'AdapTable Version', Value: adaptableVersion });
+    }
+    if (api.optionsApi.getUserInterfaceOptions()?.showAgGridVersion) {
+        keyValuePairs.push({ Key: 'AG Grid Version', Value: agGridVersion });
+    }
+    keyValuePairs.push({ Key: 'Sorted Columns', Value: ArrayExtensions.IsNotNullOrEmpty(sorts) ? sorts.join('; ') : 'None' });
+    keyValuePairs.push({ Key: 'Column Filters', Value: columnFilterDescription });
+    keyValuePairs.push({ Key: 'Grid Filter', Value: gridFilterExpression });
+    keyValuePairs.push({ Key: 'All Rows', Value: props.api.gridApi.getRowCount() });
+    keyValuePairs.push({ Key: 'Visible Rows', Value: props.api.gridApi.getVisibleRowCount() });
+    keyValuePairs.push({ Key: 'Selected Rows', Value: selectedRowInfo?.gridRows.length });
+    keyValuePairs.push({ Key: 'Visible Selected Rows', Value: selectedRowInfo?.gridRows.filter((gr) => gr.rowNode?.displayed == true).length });
+    keyValuePairs.push({ Key: 'All Columns', Value: props.api.gridApi.getColumnCount() });
+    keyValuePairs.push({ Key: 'Visible Columns', Value: props.api.gridApi.getVisibleColumnCount() });
+    keyValuePairs.push({ Key: 'Calculated Columns', Value: ArrayExtensions.IsNotNullOrEmpty(calcColumns)
             ? ArrayExtensions.createCommaSeparatedString(calcColumns)
-            : 'None'));
-        returnRows.push(createReadOnlyColItem(colItems, 'Free Text Columns', ArrayExtensions.IsNotNullOrEmpty(freeTextColumns)
+            : 'None' });
+    keyValuePairs.push({ Key: 'Free Text Columns', Value: ArrayExtensions.IsNotNullOrEmpty(freeTextColumns)
             ? ArrayExtensions.createCommaSeparatedString(freeTextColumns)
-            : 'None'));
-        returnRows.push(createReadOnlyColItem(colItems, 'Action Columns', ArrayExtensions.IsNotNullOrEmpty(actionColumns)
+            : 'None' });
+    keyValuePairs.push({ Key: 'CalcuActionlated Columns', Value: ArrayExtensions.IsNotNullOrEmpty(actionColumns)
             ? ArrayExtensions.createCommaSeparatedString(actionColumns)
-            : 'None'));
-        return returnRows;
+            : 'None' });
+    const domProps = {
+        className: 'twa:flex-1 twa:min-h-0 twa:w-full',
     };
-    const createReadOnlyColItem = (colItems, item1, item2, item3) => {
-        let rowColItems = Helper.cloneObject(colItems);
-        rowColItems[0].Content = item1;
-        rowColItems[1].Content = item2;
-        if (item3) {
-            let infoButton = React.createElement(AdaptablePopover, { headerText: null, bodyText: [item3] });
-            rowColItems[2].Content = infoButton;
-        }
-        return rowColItems;
+    keyValuePairs.map((keyValuePair) => {
+        return {
+            Key: keyValuePair.Key,
+            Value: keyValuePair.Value === 'Ignore' ? null : keyValuePair.Value,
+        };
+    })
+        .filter((x) => x.Value);
+    const columnsMap = {
+        Key: { field: 'Key', header: 'Property', defaultFlex: 1 },
+        Value: { field: 'Value', header: 'Value', defaultFlex: 3 },
     };
-    let propValueColItems = [
-        { Content: 'Property', Size: 5 },
-        { Content: 'Value', Size: 7 },
-    ];
-    let gridSummaries = CreateGridSummaries(propValueColItems).map((x, index) => {
-        return React.createElement(AdaptableObjectRow, { key: index, colItems: x });
-    });
     const baseClassName = 'ab-GridInfo';
     return (React.createElement(PopupPanel, { className: clsx(baseClassName), headerText: 'Grid Info', glyphicon: 'info', scrollable: false },
         React.createElement(Panel, { className: "twa:flex-1 twa:border-none twa:shadow-md twa:overflow-hidden" },
@@ -85,7 +76,8 @@ export const GridInfoPopup = (props) => {
                     React.createElement(Tabs.Tab, null, "Grid Summary"),
                     React.createElement(Tabs.Tab, null, "Grid State"),
                     React.createElement(Tabs.Content, null,
-                        React.createElement(AdaptableObjectCollection, { className: "twa:flex-1 twa:min-h-0" /* so the collection scrolls nicely, the header remains fixed*/, colItems: propValueColItems, items: gridSummaries })),
+                        React.createElement(DataSource, { data: keyValuePairs, primaryKey: "Key" },
+                            React.createElement(InfiniteTableGrid, { domProps: domProps, columns: columnsMap }))),
                     React.createElement(Tabs.Content, null,
                         React.createElement(AdaptableObjectsSummary, { className: "twa:min-h-0 twa:overflow-auto twa:p-2" })))))));
 };

package/src/View/QuickSearch/QuickSearchPopup.js

@@ -35,7 +35,10 @@ const QuickSearchPopupComponent = (props) => {
             React.createElement(Card, null,
                 React.createElement(Card.Title, null, "Behaviour"),
                 React.createElement(Card.Body, { className: "twa:p-1", gap: 2 },
-                    React.createElement(HelpBlock, { className: "twa:text-2 twa:w-fit" }, "Filters the Grid to only show rows with matching cells; use with care as can cause performance issues"),
+                    React.createElement(HelpBlock, { className: "twa:text-2 twa:w-fit" },
+                        "Filter Grid when searching to only show rows with matching cells; ",
+                        React.createElement("b", null, "use with care"),
+                        " as can cause performance issues"),
                     React.createElement(CheckBox, { "data-name": "filter-quick-search-results", value: "existing", checked: state.RunQueryAfterQuickSearch, disabled: StringExtensions.IsNotNullOrEmpty(searchText), onChange: onQuickSearchBehaviourChange }, "Filter using Quick Search Results"))),
             React.createElement(Card.Title, { border: false, className: "twa:pt-3" }, "Cell Matching Style"),
             React.createElement(Card, null,

package/src/View/Schedule/Wizard/ScheduleSettingsWizard/ScheduleSettingsReminder.js

@@ -20,13 +20,13 @@ export const ScheduleSettingsReminder = (props) => {
     const handleHeaderChange = (event) => {
         props.onChange({
             ...props.reminderSchedule,
-            Header: event.target?.value,
+            Header: event.target.value,
         });
     };
     const handleMessageChange = (event) => {
         props.onChange({
             ...props.reminderSchedule,
-            Message: event.target?.value,
+            Message: event.target.value,
         });
     };
     const handleDisplayNotificationChange = (checked) => {

package/src/View/SmartEdit/SmartEditViewPanel.js

@@ -13,6 +13,7 @@ import { connect } from 'react-redux';
 import { Select } from '../../components/Select';
 import { Flex } from '../../components/Flex';
 class SmartEditViewPanelComponent extends React.Component {
+    cleanupEvent;
     constructor(props) {
         super(props);
         this.state = {

package/src/View/Theme/ThemePopup.js

@@ -11,22 +11,6 @@ import { Icon } from '../../components/icons';
 import { ThemeSelector } from './ThemeSelector';
 import { Box } from '../../components/Flex';
 class ThemePopupComponent extends React.Component {
-    constructor() {
-        super(...arguments);
-        this.handleCreateNewTheme = (variant) => {
-            let nthItem = this.props.UserThemes.length + 1;
-            let name = 'Custom-Theme-' + nthItem;
-            // make sure it is unique
-            while (this.props.UserThemes.some((theme) => theme.Name === name)) {
-                nthItem++;
-                name = 'Custom-Theme-' + nthItem;
-            }
-            const newTheme = ObjectFactory.CreateEmptyTheme(name);
-            newTheme.Variant = variant;
-            this.props.api.themeApi.addUserTheme(newTheme);
-            this.props.api.themeApi.loadTheme(newTheme.Name);
-        };
-    }
     render() {
         const isCustomTheme = this.props.api.themeApi
             .getUserThemes()
@@ -59,6 +43,19 @@ class ThemePopupComponent extends React.Component {
     onChangeTheme(value) {
         this.props.SelectTheme(value);
     }
+    handleCreateNewTheme = (variant) => {
+        let nthItem = this.props.UserThemes.length + 1;
+        let name = 'Custom-Theme-' + nthItem;
+        // make sure it is unique
+        while (this.props.UserThemes.some((theme) => theme.Name === name)) {
+            nthItem++;
+            name = 'Custom-Theme-' + nthItem;
+        }
+        const newTheme = ObjectFactory.CreateEmptyTheme(name);
+        newTheme.Variant = variant;
+        this.props.api.themeApi.addUserTheme(newTheme);
+        this.props.api.themeApi.loadTheme(newTheme.Name);
+    };
 }
 function mapStateToProps(state, ownProps) {
     return {

package/src/View/UIHelper.d.ts

@@ -38,6 +38,7 @@ export declare function getMessageTypeByStatusColour(statusColour: StatusColour)
 export declare function getButtonToneByMessageType(messageType: AdaptableMessageType): 'success' | 'error' | 'neutral' | 'none' | 'warning' | 'info' | 'accent';
 export declare function getGlyphByMessageType(messageType: AdaptableMessageType): AdaptableSystemIconName;
 export declare function getColorByMessageType(messageType: AdaptableMessageType): string;
+export declare function getCSSColorByMessageType(messageType: AdaptableMessageType): string;
 export declare function getStyleForStatusColour(statusColour: StatusColour): CSSProperties;
 export declare function getStyleForMessageType(messageType: AdaptableMessageType): CSSProperties;
 export declare function getGlyphForStatusColour(statusColour: StatusColour): string;
@@ -75,6 +76,7 @@ export declare const UIHelper: {
     getGlyphForMessageType: typeof getGlyphForMessageType;
     getStyleForMessageType: typeof getStyleForMessageType;
     getMessageTypeFromAdaptableAlerts: typeof getMessageTypeFromAdaptableAlerts;
+    getCSSColorByMessageType: typeof getCSSColorByMessageType;
     getButtonColourForAdaptableAlerts: typeof getButtonColourForAdaptableAlerts;
     getButtonTextColourForArrayandMessageType: typeof getButtonTextColourForArrayandMessageType;
     getButtonTextColourForMessageType: typeof getButtonTextColourForMessageType;

package/src/View/UIHelper.js

@@ -202,6 +202,20 @@ export function getColorByMessageType(messageType) {
             return 'var(--ab-color-info)';
     }
 }
+export function getCSSColorByMessageType(messageType) {
+    switch (messageType) {
+        case 'Error':
+            return 'error';
+        case 'Warning':
+            return 'warn';
+        case 'Success':
+            return 'success';
+        case 'Info':
+            return 'info';
+        default:
+            return '';
+    }
+}
 export function getStyleForStatusColour(statusColour) {
     let result;
     switch (statusColour) {
@@ -449,6 +463,7 @@ export const UIHelper = {
     getGlyphForMessageType,
     getStyleForMessageType,
     getMessageTypeFromAdaptableAlerts,
+    getCSSColorByMessageType,
     getButtonColourForAdaptableAlerts,
     getButtonTextColourForArrayandMessageType,
     getButtonTextColourForMessageType,

package/src/agGrid/Adaptable.js

@@ -21,6 +21,10 @@ export class Adaptable {
     }
 }
 export class AdaptableNoCodeWizard {
+    init;
+    adaptableOptions;
+    extraOptions;
+    agGridModules;
     /**
      * @param adaptableOptions
      */

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -257,10 +257,10 @@ export declare class AdaptableAgGrid implements IAdaptable {
         added: IRowNode[];
         updated: IRowNode[];
     }>;
-    applyGridDataTransaction(dataTransaction: {
+    manageGridRows(dataRows: {
         add?: any[];
         update?: any[];
-        remove?: any[];
+        delete?: any[];
     }, config?: DataUpdateConfig): Promise<{
         addedRows: IRowNode[];
         updatedRows: IRowNode[];

package/src/agGrid/AdaptableAgGrid.js

@@ -155,38 +155,77 @@ LocalEventService_Prototype.dispatchEvent = function (event) {
 const adaptableInstances = {};
 const publishTimestamp = Number(ADAPTABLE_PUBLISH_TIMESTAMP);
 export class AdaptableAgGrid {
+    logger;
+    _id;
+    lifecycleState;
+    variant;
+    emitter;
+    /**
+     * Runtime flags
+     */
+    hasAutogeneratedPrimaryKey;
+    hasAdaptableToolPanel;
+    initWithLazyData;
+    _rawAdaptableOptions;
+    adaptableOptions;
+    _isDetailGrid;
+    _isDetailGridForIndex;
+    agGridOptionsService;
+    agGridAdapter;
+    agGridColumnAdapter;
+    agGridMenuAdapter;
+    agGridExportAdapter;
+    agGridThemeAdapter;
+    agGridModulesAdapter;
+    DANGER_USE_GETTER_adaptableContainerElement;
+    DANGER_USE_GETTER_agGridContainerElement;
+    api;
+    adaptableStore;
+    adaptableModules;
+    DataService;
+    CalculatedColumnExpressionService;
+    ModuleService;
+    ValidationService;
+    QueryLanguageService;
+    AlertService;
+    TeamSharingService;
+    MetamodelService;
+    RowFormService;
+    Fdc3Service;
+    AnnotationsService;
+    FlashingCellService;
+    LicenseService;
+    ChartingService;
+    ThemeService;
+    rowListeners;
+    throttleFilterOnDataChange;
+    debouncedSetSelectedRows;
+    debouncedSetSelectedCells;
+    agGridListenerKeydown;
+    agGridListenerMouseEnter;
+    agGridListenerMouseLeave;
+    listenerGlobalSetRowSelection;
+    listenerGlobalChartingChanges;
+    listenerCellEditingStarted;
+    listenerFirstDataRendered;
+    listenerPivotChanged;
+    listenerCellSelectionChanged;
+    listenerSortChanged;
+    listenerColumnGroupOpened;
+    layoutManager;
+    columnMinMaxValuesCache = {};
+    renderReactRoot = (node, container) => defaultRenderReactRoot(node, container);
+    unmountReactRoot;
+    unmountLoadingScreen;
+    /**
+     * Temporary, these are MIGRATION technical debts, and should be removed as soon as possible
+     */
+    adaptableStatusPanelKeys = [];
+    // see #no_additional_react_root
+    _PRIVATE_adaptableJSXElement;
+    _prevLayout;
+    __prevLayoutForRefresh;
     constructor(config) {
-        this.columnMinMaxValuesCache = {};
-        this.renderReactRoot = (node, container) => defaultRenderReactRoot(node, container);
-        /**
-         * Temporary, these are MIGRATION technical debts, and should be removed as soon as possible
-         */
-        this.adaptableStatusPanelKeys = [];
-        // only for our private / internal events used within Adaptable
-        // public events are emitted through the EventApi
-        this._emit = (eventName, data) => {
-            if (this.emitter) {
-                return this.emitter.emit(eventName, data);
-            }
-        };
-        this._emitSync = (eventName, data) => {
-            if (this.emitter) {
-                return this.emitter.emitSync(eventName, data);
-            }
-        };
-        this._on = (eventName, callback) => {
-            if (!this.emitter) {
-                return () => { };
-            }
-            return this.emitter.on(eventName, callback);
-        };
-        this._onIncludeFired = (eventName, callback) => {
-            if (!this.emitter) {
-                return () => { };
-            }
-            return this.emitter.onIncludeFired(eventName, callback);
-        };
-        this.__updateColumnModelAndRefreshGrid_already_called = false;
         this.lifecycleState = 'initial';
         this.emitter = new Emitter();
         this.agGridOptionsService = new AgGridOptionsService(this);
@@ -222,6 +261,30 @@ 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);
+        }
+    };
+    _emitSync = (eventName, data) => {
+        if (this.emitter) {
+            return this.emitter.emitSync(eventName, data);
+        }
+    };
+    _on = (eventName, callback) => {
+        if (!this.emitter) {
+            return () => { };
+        }
+        return this.emitter.on(eventName, callback);
+    };
+    _onIncludeFired = (eventName, callback) => {
+        if (!this.emitter) {
+            return () => { };
+        }
+        return this.emitter.onIncludeFired(eventName, callback);
+    };
     /**
      * Internal initializer for Adaptable, directly called by the React and Angular Adaptable wrappers
      * @private
@@ -782,7 +845,8 @@ You need to define at least one Layout!`);
                 return original_autoGroupColumnDef;
             }
             if (typeof original_autoGroupColumnDef?.filter === 'object') {
-                this.logger.warn(`autoGroupColumnDef.filter is set and overrides the Adaptable custom filter mechanism! We recommend using a ColumnOptions.columnHeader instead!`);
+                this.logger.consoleWarn(`autoGroupColumnDef.filter is set and overrides the Adaptable custom filter mechanism, so Adaptable will not be able to manage filtering for the Group Column!
+                      Please contact the Adaptable Support Team for further assistance and investigation.`);
                 return original_autoGroupColumnDef;
             }
             const autoGroupColumnDef = { ...original_autoGroupColumnDef };
@@ -790,7 +854,8 @@ You need to define at least one Layout!`);
             // !! 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.error('autoGroupColumnDef.filterValueGetter was called unexpectedly; this is not an expected execution path!', params);
+                this.logger.consoleWarn(`An unexpected invocation of autoGroupColumnDef.filterValueGetter was detected. This execution path is not expected under normal operation.
+                      Please contact the Adaptable Support Team for further assistance and investigation.`, params);
                 return '';
             };
             // !! it is important that we always return the same component / handler instances
@@ -2066,6 +2131,7 @@ You need to define at least one Layout!`);
         }
         return rawValue;
     }
+    __updateColumnModelAndRefreshGrid_already_called = false;
     updateColumnModelAndRefreshGrid() {
         if (this.__updateColumnModelAndRefreshGrid_already_called) {
             return;
@@ -2401,18 +2467,18 @@ You need to define at least one Layout!`);
             });
         }
     }
-    async applyGridDataTransaction(dataTransaction, config = {}) {
+    async manageGridRows(dataRows, config = {}) {
         const result = {
             addedRows: [],
             updatedRows: [],
             removedRows: [],
         };
-        if (!dataTransaction) {
+        if (!dataRows) {
             return result;
         }
-        const addDataRows = dataTransaction.add;
-        const updateDataRows = dataTransaction.update;
-        const removeDataRows = dataTransaction.remove;
+        const addDataRows = dataRows.add;
+        const updateDataRows = dataRows.update;
+        const removeDataRows = dataRows.delete;
         if (this.hasAutogeneratedPrimaryKey) {
             this.addSyntheticPrimaryKeyIfMissing(addDataRows);
         }

package/src/agGrid/AdaptableFilterHandler.js

@@ -1,4 +1,8 @@
 export class AdaptableFilterHandler {
+    adaptableApi;
+    colId;
+    filterDisplayValuesResult;
+    previousFilterDisplayValuesResult;
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
     }

package/src/agGrid/AdaptableLogger.d.ts

@@ -1,5 +1,8 @@
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
 export declare const errorOnce: (message: string) => void;
+/**
+ * AdapTable's Logger
+ */
 export declare class AdaptableLogger {
     private adaptableId;
     private debugger;

package/src/agGrid/AdaptableLogger.js

@@ -11,7 +11,17 @@ export const errorOnce = (message) => {
     console.error(message);
     errorOnceFlags[message] = true;
 };
+/**
+ * AdapTable's Logger
+ */
 export class AdaptableLogger {
+    adaptableId;
+    debugger;
+    infoLogger;
+    successLogger;
+    warnLogger;
+    errorLogger;
+    perfLogger;
     // use static loggers whenever access to AdaptableLogger instance is not feasible
     static consoleErrorBase(message, ...optionalParams) {
         if (optionalParams?.length) {

package/src/agGrid/AgGridAdapter.js

@@ -13,9 +13,19 @@ import { isWeightedAverageAggFuncName } from '../AdaptableState/Common/Aggregati
 const DANGER_AG_GRID_BEANS_MAP = {};
 const getColumnApiModule = () => ColumnApiModule;
 export class AgGridAdapter {
+    _adaptableInstance;
+    DANGER_USE_GETTER_gridApi;
+    DANGER_gridApi_from_args;
+    // see #gridOpts_monkey_patch
+    DANGER_updateGridOptionsMonkeyPatcher;
+    // see #aggColumnFilters_monkey_patch
+    DANGER_doFiltersPassMonkeyPatcher;
+    DANGER_isAggFilterPresentMonkeyPatcher;
+    activePivotColumnFilters_MEMO = new WeakMap();
+    initialGridOptions;
+    _agGridId;
     constructor(_adaptableInstance, config) {
         this._adaptableInstance = _adaptableInstance;
-        this.activePivotColumnFilters_MEMO = new WeakMap();
         const columnApiModuleReference = config?.getAgGridColumnApiModuleReference?.() ?? getColumnApiModule();
         const ColumnDefFactory_Prototype = columnApiModuleReference?.beans?.[0]?.prototype;
         if (!ColumnDefFactory_Prototype) {

package/src/agGrid/AgGridColumnAdapter.js

@@ -27,6 +27,8 @@ export function getEditorForColumnDataType(columnDataType, variant) {
     }
 }
 export class AgGridColumnAdapter {
+    adaptableInstance;
+    colDefPropertyCache;
     constructor(adaptableInstance) {
         this.adaptableInstance = adaptableInstance;
         this.colDefPropertyCache = new Map();
@@ -300,12 +302,10 @@ export class AgGridColumnAdapter {
                 // see #header_text_align
                 const formatColumnWithTextAlignment = this.getRelevantFormatColumnHeaderStyles(abColumn)
                     // we take the first one only, even if multiple are defined
-                    .find((fc) => fc.CellAlignment != undefined);
+                    .find((fc) => fc.Style?.Alignment != undefined);
                 if (formatColumnWithTextAlignment) {
-                    baseHeaderClass = [
-                        ...baseHeaderClass,
-                        `ab-header__align-${formatColumnWithTextAlignment.CellAlignment.toLowerCase()}`,
-                    ];
+                    const alignment = formatColumnWithTextAlignment.Style.Alignment.toLowerCase();
+                    baseHeaderClass = [...baseHeaderClass, `ab-header__align-${alignment}`];
                 }
                 const formatColumns = this.adaptableApi.formatColumnApi.internalApi.getFormatColumnWithStyleClassNameForColumn(abColumn, {
                     target,
@@ -1261,19 +1261,6 @@ export class AgGridColumnAdapter {
             const formatColumnStyle = formatColumn.Style
                 ? convertAdaptableStyleToCSS(formatColumn.Style)
                 : {};
-            if (formatColumn.CellAlignment) {
-                switch (formatColumn.CellAlignment) {
-                    case 'Left':
-                        style.textAlign = 'left';
-                        break;
-                    case 'Right':
-                        style.textAlign = 'right';
-                        break;
-                    case 'Center':
-                        style.textAlign = 'center';
-                        break;
-                }
-            }
             return { ...style, ...formatColumnStyle };
         }, {});
     }

package/src/agGrid/AgGridExportAdapter.js

@@ -8,17 +8,18 @@ import { createUuid } from '../AdaptableState/Uuid';
 import { inferSchema, initParser } from 'udsv';
 import { AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_COLUMN, } from '../Utilities/Constants/GeneralConstants';
 export class AgGridExportAdapter {
+    _adaptableInstance;
+    /**
+     * !!!
+     * do NOT mutate this array reference, this is passed only initially to AG Grid and we can only change it's internal state
+     */
+    DANGER_excelStyles = [];
+    originalExcelStyles = [];
+    excelStylesCache = {};
+    cellOrHeaderClassKey2ExcelStyleIdMap = {};
+    excelStylesWithFormattedDate = {};
     constructor(_adaptableInstance) {
         this._adaptableInstance = _adaptableInstance;
-        /**
-         * !!!
-         * do NOT mutate this array reference, this is passed only initially to AG Grid and we can only change it's internal state
-         */
-        this.DANGER_excelStyles = [];
-        this.originalExcelStyles = [];
-        this.excelStylesCache = {};
-        this.cellOrHeaderClassKey2ExcelStyleIdMap = {};
-        this.excelStylesWithFormattedDate = {};
     }
     get agGridApi() {
         return this._adaptableInstance.agGridAdapter.getAgGridApi();

package/src/agGrid/AgGridFilterAdapter.js

@@ -14,6 +14,10 @@ export const AgGridFilterAdapterFactory = (adaptable) => {
         return 'filter_' + colId + '_' + adaptable.adaptableOptions.adaptableId;
     }
     return class AgGridFilterAdapter {
+        params;
+        filterContainer;
+        column;
+        unmountReactRoot;
         init(params) {
             this.params = params;
             this.column = params.column;