@adaptabletools/adaptable 19.2.3 → 20.0.0-canary.0

package/src/Api/Internal/GridInternalApi.js

@@ -1,57 +1,20 @@
 import { SortOrder } from '../../PredefinedConfig/Common/Enums';
-import * as GridRedux from '../../Redux/ActionsReducers/GridRedux';
+import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
-import NumberExtensions from '../../Utilities/Extensions/NumberExtensions';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
-import { createBaseContext } from '../../Utilities/ObjectFactory';
 import UIHelper from '../../View/UIHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 export class GridInternalApi extends ApiBase {
-    /**
-     * Fires Grid Sorted Event
-     */
-    fireGridSortedEvent() {
-        if (this.isAdapTableReady()) {
-            const adaptableSortState = this.getAdaptableApi().configApi.getAdaptableSortState();
-            const adaptableApi = this.getAdaptableApi();
-            const gridSortedInfo = Object.assign({ adaptableSortState: adaptableSortState }, this.getAdaptableInternalApi().buildBaseContext());
-            adaptableApi.eventApi.emit('GridSorted', gridSortedInfo);
-        }
-    }
-    /**
-     * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
-     */
-    fireCellChangedEvent(cellDataChangedInfo) {
-        if (this.isAdapTableReady()) {
-            const cellChangedInfo = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { cellChange: cellDataChangedInfo });
-            this.getEventApi().emit('CellChanged', cellChangedInfo);
-        }
-    }
-    /**
-     * Fires Grid Data Changed Event - when a row has changed in AG Grid
-     */
-    fireGridDataChangedEvent(dataRows, rowNodes, rowTrigger) {
-        if (this.isAdapTableReady()) {
-            const gridDataChangedInfo = Object.assign({ changedAt: Date.now(), rowTrigger,
-                dataRows,
-                rowNodes }, this.getAdaptableInternalApi().buildBaseContext());
-            this.getEventApi().emit('GridDataChanged', gridDataChangedInfo);
-            this.getAdaptableInternalApi().getDataService().CreateGridChangedEvent(gridDataChangedInfo);
-        }
-    }
     /**
      * Gets all distinct display values in the Column for given ColumnId
      * @param columnId Column to check
      */
-    getDistinctDisplayValuesForColumn(columnId) {
+    getDistinctDisplayValuesForColumnOld(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
         if (abColumn == undefined) {
             return [];
         }
-        const distinctValuesParams = {
-            visibleRowsOnly: false,
-        };
-        const returnValues = this._adaptable.getDistinctValuesForColumn(abColumn, distinctValuesParams);
+        const returnValues = this._adaptable.getDistinctGridCellsForColumn(abColumn);
         return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
             return cv.normalisedValue;
         });
@@ -64,386 +27,130 @@ export class GridInternalApi extends ApiBase {
      * This is a general method, and it is used in:
      * - Column Filters
      * - Query Builder
+     * - Permitted Values
      *
      * @param columnId Column to check
-     * @param columnFilter Current applied filter
      */
-    async getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly) {
-        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+    async getDistinctFilterDisplayValuesForColumn(options) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(options.columnId);
         if (abColumn == undefined) {
-            return {
-                values: [],
-                suppressClientSideFilter: false,
-            };
-        }
-        const distinctValuesParams = {
-            visibleRowsOnly: showFilteredRowsOnly,
-        };
-        const { gridCells, suppressClientSideFilter } = await this.getDistinctFilterListValuesForColumn(abColumn, filter, distinctValuesParams);
-        const sortedDistinctValues = this.sortDistinctValues(gridCells, abColumn);
-        const shouldShowValuesCount = this.shouldShowValuesCount(abColumn);
-        let valueOptions = [];
-        if (shouldShowValuesCount) {
-            const allGridCells = this._adaptable.getGridCellsForColumn(columnId, this.getColumnFilterOptions().valuesFilterOptions.showCurrentlyFilteredValuesCount);
-            const allGridValues = allGridCells.map((gc) => gc.displayValue);
-            const newsortedDistinctValues = sortedDistinctValues.filter((gc) => gc.displayValue != undefined && gc.displayValue != '' && gc.displayValue != null);
-            valueOptions = newsortedDistinctValues.map((cv) => {
-                const label = cv.displayValue +
-                    NumberExtensions.WrapInParentheses(ArrayExtensions.getOccurrence(allGridValues, cv.displayValue));
-                return {
-                    label: label,
-                    value: cv.normalisedValue,
-                };
-            });
-        }
-        else {
-            valueOptions = sortedDistinctValues.map((cv) => {
-                return {
-                    label: cv.displayValue,
-                    value: cv.normalisedValue,
-                };
-            });
-        }
-        return {
-            values: valueOptions,
-            suppressClientSideFilter,
-        };
-    }
-    shouldShowValuesCount(column) {
-        const showValuesCount = this.getColumnFilterOptions().valuesFilterOptions.showValuesCount;
-        let returnValue = false;
-        if (showValuesCount) {
-            if (typeof showValuesCount === 'function') {
-                const columnFilterContext = Object.assign({ column }, this.getAdaptableInternalApi().buildBaseContext());
-                returnValue = showValuesCount(columnFilterContext);
-            }
-            else {
-                returnValue = showValuesCount;
-            }
-        }
-        return returnValue;
-    }
-    async getDistinctFilterDisplayValuesForColumnForFiltersUI(columnId, filter, showFilteredRowsOnly) {
-        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (!abColumn) {
-            return {
-                values: [],
-                suppressClientSideFilter: false,
-            };
+            return [];
         }
-        const shouldShowValuesCount = this.shouldShowValuesCount(abColumn);
-        const valueOptions = await this.getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly);
-        this.addPredicateValues({
-            valueOptions: valueOptions.values,
+        let gridCells = await this._adaptable.getDistinctFilterValuesForColumn({
             column: abColumn,
-            shouldShowValuesCount,
-            visibleRowsOnly: showFilteredRowsOnly,
+            get currentSearchValue() {
+                return options.currentSearchValue;
+            },
         });
-        return valueOptions;
-    }
-    addPredicateValues(params) {
-        var _a, _b, _c, _d;
-        const { valueOptions, column, shouldShowValuesCount, visibleRowsOnly } = params;
-        const visibleGridCells = this._adaptable.getGridCellsForColumnTemp(column.columnId, visibleRowsOnly);
-        let allGridCells;
-        if (shouldShowValuesCount) {
-            allGridCells = visibleRowsOnly
-                ? visibleGridCells
-                : this._adaptable.getGridCellsForColumnTemp(column.columnId, this.getColumnFilterOptions().valuesFilterOptions.showCurrentlyFilteredValuesCount);
-        }
-        const adaptableApi = this.getAdaptableApi();
-        const predicateIds = adaptableApi.columnFilterApi.internalApi.getValuesFitlerPredicateIds(column);
-        if (ArrayExtensions.IsNullOrEmpty(predicateIds)) {
-            return;
-        }
-        const predicatesPosition = (_d = (_c = (_b = (_a = adaptableApi.optionsApi.getColumnFilterOptions()) === null || _a === void 0 ? void 0 : _a.valuesFilterOptions) === null || _b === void 0 ? void 0 : _b.valuesFilterPredicateOptions) === null || _c === void 0 ? void 0 : _c.predicatesPosition) !== null && _d !== void 0 ? _d : 'Start';
-        const predicateValues = predicateIds
-            .filter((predicateId) => {
-            // we have to make sure it is part of the visibleRowsOnly, when true
-            if (!visibleRowsOnly) {
-                return true;
-            }
-            return this.isPredicateInVisibleCellValues(predicateId, visibleGridCells);
-        })
-            .map((predicateId) => {
-            var _a;
-            const predicateDef = adaptableApi.predicateApi.getPredicateDefById(predicateId);
-            let label = ((_a = predicateDef.label) !== null && _a !== void 0 ? _a : predicateId);
+        gridCells = gridCells || [];
+        const valueOptions = gridCells.map((cv) => {
             return {
-                value: predicateId,
-                label: shouldShowValuesCount
-                    ? label +
-                        NumberExtensions.WrapInParentheses(this.getPredicateOccurance({ predicateId, column, allGridCells }))
-                    : label,
+                label: cv.displayValue,
+                value: cv.normalisedValue,
             };
         });
-        if (predicatesPosition === 'End') {
-            valueOptions.push(...predicateValues);
-        }
-        else {
-            valueOptions.unshift(...predicateValues);
-        }
-    }
-    isPredicateInVisibleCellValues(predicateId, allGridCells) {
-        const predicate = this.getPredicateApi().getPredicateDefById(predicateId);
-        if (!predicate) {
-            return false;
-        }
-        const commonContext = createBaseContext(this.getAdaptableApi());
-        for (let gridCell of allGridCells) {
-            if (this.getPredicateApi().handlePredicate({
-                PredicateId: predicate.id,
-            }, Object.assign({ value: gridCell.rawValue, oldValue: null, displayValue: gridCell.displayValue, node: gridCell.rowNode, column: gridCell.column }, commonContext), false)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    getPredicateOccurance(params) {
-        const { predicateId, allGridCells, column } = params;
-        const predicate = this.getPredicateApi().getPredicateDefById(predicateId);
-        if (!predicate) {
-            return 0;
-        }
-        let count = 0;
-        const commonContext = createBaseContext(this.getAdaptableApi());
-        for (let gridCell of allGridCells) {
-            if (this.getPredicateApi().handlePredicate({
-                PredicateId: predicate.id,
-            }, Object.assign({ value: gridCell.rawValue, oldValue: null, displayValue: gridCell.displayValue, node: gridCell.rowNode, column }, commonContext), false)) {
-                count++;
-            }
-        }
-        return count;
-    }
-    async getDistinctFilterListValuesForColumn(column, filter, distinctValuesParams) {
-        var _a;
-        const filterPermittedValues = (_a = this.getUserInterfaceApi().getFilterPermittedValuesForColumn(column)) !== null && _a !== void 0 ? _a : {
-            suppressFilterSearchBar: false,
-            values: () => undefined,
-        };
-        let preparedPermittedValues = undefined;
-        try {
-            const filterPermittedValuesParams = Object.assign(Object.assign({}, createBaseContext(this.getAdaptableApi())), { column: column, searchFilter: filter });
-            preparedPermittedValues = await (filterPermittedValues === null || filterPermittedValues === void 0 ? void 0 : filterPermittedValues.values(filterPermittedValuesParams));
-        }
-        catch (error) {
-            this._adaptable.logger.consoleError(`Failed to load filter permitted values`, column, filter, error);
-        }
-        distinctValuesParams.permittedValues = preparedPermittedValues;
-        return {
-            suppressClientSideFilter: filterPermittedValues.suppressFilterSearchBar,
-            gridCells: this._adaptable.getDistinctValuesForColumn(column, distinctValuesParams),
-        };
+        return valueOptions;
     }
-    /**
-     * Gets all distinct Custom Sort values for the Column with the given ColumnId
-     * @param columnId Column to check
-     */
-    async getDistinctCustomSortDisplayValuesForColumn(columnId) {
+    async getDistinctValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (abColumn == undefined) {
-            return [];
-        }
-        const distinctValuesParams = {
-            visibleRowsOnly: false,
-        };
-        const gridCells = await this.getDistinctCustomSortValuesForColumn(abColumn, distinctValuesParams);
-        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
-            return cv.normalisedValue;
-        });
-    }
-    async getDistinctCustomSortValuesForColumn(column, distinctValuesParams) {
-        const customSortPermittedValues = await this.getUserInterfaceApi().getCustomSortPermittedValuesForColumn(column);
-        let preparedPermittedValues = undefined;
-        try {
-            const permittedValuesParams = Object.assign(Object.assign({}, createBaseContext(this.getAdaptableApi())), { column: column });
-            preparedPermittedValues = await (customSortPermittedValues === null || customSortPermittedValues === void 0 ? void 0 : customSortPermittedValues.values(permittedValuesParams));
-        }
-        catch (error) {
-            this._adaptable.logger.consoleError(`Failed to load custom sort permitted values`, column, error);
+        if (!abColumn) {
+            return undefined;
         }
-        distinctValuesParams.permittedValues = preparedPermittedValues;
-        return this._adaptable.getDistinctValuesForColumn(column, distinctValuesParams);
+        const gridCells = await this._adaptable.getDistinctValuesForColumn(abColumn);
+        return gridCells;
     }
-    /**
-     * Gets all distinct Bulk Update values for the Column with the given ColumnId
-     * @param columnId Column to check
-     * @param selectedGridCells Selected grid cells
-     */
-    async getDistinctBulkUpdateDisplayValuesForColumn(columnId, selectedGridCells) {
-        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (abColumn == undefined) {
-            return [];
-        }
-        const distinctValuesParams = {
-            visibleRowsOnly: false,
-        };
-        const gridCells = await this.getDistinctBulkUpdateValuesForColumn(abColumn, selectedGridCells, distinctValuesParams);
-        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
-            return cv.normalisedValue;
+    async getDistinctDisplayValuesForColumn(columnId) {
+        const distinctValues = await this.getDistinctValuesForColumn(columnId);
+        return distinctValues.map((gc) => {
+            return gc.displayValue;
         });
     }
-    async getDistinctBulkUpdateValuesForColumn(column, selectedGridCells, distinctValuesParams) {
-        const bulkUpdatePermittedValues = await this.getUserInterfaceApi().getBulkUpdatePermittedValuesForColumn(column);
-        let preparedPermittedValues = undefined;
-        try {
-            const bulkUpdatePermittedValuesParams = Object.assign(Object.assign({}, createBaseContext(this.getAdaptableApi())), { column: column, gridCells: selectedGridCells });
-            preparedPermittedValues = await (bulkUpdatePermittedValues === null || bulkUpdatePermittedValues === void 0 ? void 0 : bulkUpdatePermittedValues.values(bulkUpdatePermittedValuesParams));
-        }
-        catch (error) {
-            this._adaptable.logger.consoleError(`Failed to load bulk permitted values`, error, column, selectedGridCells);
-        }
-        distinctValuesParams.permittedValues = preparedPermittedValues;
-        return this._adaptable.getDistinctValuesForColumn(column, distinctValuesParams);
-    }
-    /**
-     * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
-     * @param columnId Column to check
-     */
-    getDistinctVisibleDisplayValuesForColumn(columnId) {
-        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (abColumn == undefined) {
-            return [];
+    async getDistinctEditDisplayValuesForColumn(options) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(options.columnId);
+        if (!abColumn) {
+            return undefined;
         }
-        const distinctValuesParams = {
-            visibleRowsOnly: true,
-        };
-        const returnValues = this._adaptable.getDistinctValuesForColumn(abColumn, distinctValuesParams);
-        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
-            return cv.normalisedValue;
+        let gridCells = await this._adaptable.getDistinctEditValuesForColumn({
+            column: abColumn,
+            gridCell: options.gridCell,
+            get currentSearchValue() {
+                return options.currentSearchValue;
+            },
+        });
+        gridCells = gridCells || [];
+        return gridCells.map((gc) => {
+            return {
+                label: gc.displayValue,
+                value: gc.normalisedValue,
+            };
         });
     }
     /**
      * Gets all distinct raw values in Column. Values are sorted.
      * @param columnId Column to check
-     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
      */
-    getDistinctRawValuesForColumn(columnId, skipRowNode) {
+    getDistinctRawValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
         if (abColumn == undefined) {
             return [];
         }
-        return this.sortDistinctValues(this.getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode), abColumn).map((cv) => {
+        return this.sortDistinctValues(this.getUnsortedDistinctRawValuesForColumn(columnId), abColumn).map((cv) => {
             return cv.rawValue;
         });
     }
     /**
      * Gets all distinct raw values in Column. Values are un-sorted.
      * @param columnId Column to check
-     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
-     */
-    getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode) {
-        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (abColumn == undefined) {
-            return [];
-        }
-        const distinctValuesParams = {
-            visibleRowsOnly: false,
-            skipRowNode: skipRowNode,
-        };
-        return this._adaptable.getDistinctValuesForColumn(abColumn, distinctValuesParams);
-    }
-    /**
-     * Gets all distinct visible raw values in the Column
-     * @param columnId Column to check
      */
-    getDistinctVisibleRawValuesForColumn(columnId) {
+    getUnsortedDistinctRawValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
         if (abColumn == undefined) {
             return [];
         }
-        const distinctValuesParams = {
-            visibleRowsOnly: true,
-        };
-        const returnValues = this._adaptable.getDistinctValuesForColumn(abColumn, distinctValuesParams);
-        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
-            return cv.rawValue;
-        });
+        return this._adaptable.getDistinctGridCellsForColumn(abColumn);
     }
     sortDistinctValues(returnValues, column) {
         // this does NOT into account Custom Sort - far too hard for now...
-        let sortOrder = SortOrder.Asc;
-        if (this.getColumnFilterOptions().valuesFilterOptions.sortValuesFilter) {
-            let columnSort = this.getGridApi().getColumnSortForColumn(column.columnId);
-            if (columnSort && columnSort.SortOrder == 'Desc') {
-                sortOrder = SortOrder.Desc;
+        let sortOrder = undefined;
+        let columnSort = this.getGridApi().getColumnSortForColumn(column.columnId);
+        if (columnSort && columnSort.SortOrder) {
+            sortOrder =
+                columnSort.SortOrder === 'Asc'
+                    ? SortOrder.Asc
+                    : columnSort.SortOrder === 'Desc'
+                        ? SortOrder.Desc
+                        : undefined;
+        }
+        if (sortOrder) {
+            if (this.getColumnApi().hasNumberDataType(column?.columnId)) {
+                returnValues = ArrayExtensions.sortCellValueArrayNumeric(returnValues, sortOrder);
+            }
+            else if (this.getColumnApi().hasDateDataType(column?.columnId)) {
+                returnValues = ArrayExtensions.sortCellValueArrayDates(returnValues, sortOrder);
+            }
+            else {
+                returnValues = ArrayExtensions.sortCellValueArray(returnValues, sortOrder);
             }
-        }
-        if (this.getColumnApi().hasNumberDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
-            returnValues = ArrayExtensions.sortCellValueArrayNumeric(returnValues, sortOrder);
-        }
-        else if (this.getColumnApi().hasDateDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
-            returnValues = ArrayExtensions.sortCellValueArrayDates(returnValues, sortOrder);
-        }
-        else {
-            returnValues = ArrayExtensions.sortCellValueArray(returnValues, sortOrder);
         }
         return returnValues;
     }
     setColumns(columns) {
-        this.dispatchAction(GridRedux.GridSetColumns(columns));
+        this.dispatchAction(InternalRedux.SetColumns(columns));
     }
     setSelectedCells(selectedCellInfo) {
-        this.dispatchAction(GridRedux.GridSetSelectedCells(selectedCellInfo));
+        this.dispatchAction(InternalRedux.SetSelectedCells(selectedCellInfo));
     }
     setSelectedRows(selectedRowInfo) {
-        this.dispatchAction(GridRedux.GridSetSelectedRows(selectedRowInfo));
+        this.dispatchAction(InternalRedux.SetSelectedRows(selectedRowInfo));
     }
     buildStandaloneColumnHeader(column) {
         return this._adaptable.agGridMenuAdapter.buildStandaloneColumnHeader(column);
     }
-    getEditLookUpValuesForColumn(editLookUpItem, column, gridCell) {
-        if (!editLookUpItem || !column) {
-            return undefined;
-        }
-        let editLookUpValues = editLookUpItem.values;
-        // first do the function then get hardcoded items
-        if (editLookUpValues != null && typeof editLookUpValues === 'function') {
-            const editLookUpContext = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { column: column, gridCell });
-            return editLookUpValues(editLookUpContext);
-        }
-        else {
-            let arr = editLookUpValues;
-            if (arr && ArrayExtensions.IsNotNullOrEmpty(arr)) {
-                return arr;
-            }
-        }
-        // if no hard-coded values or function provided then just get the distinct values for the column
-        // this will use the columnApi method that first looks for permitted values and then distinct values
-        return this.getDistinctDisplayValuesForColumn(column.columnId);
-    }
-    getAgGridDataType(dataType) {
-        if (!dataType) {
-            return 'abColDefString';
-        }
-        switch (dataType) {
-            case 'Boolean':
-                return 'abColDefBoolean';
-            case 'Date':
-                return 'abColDefDate';
-            case 'Number':
-                return 'abColDefNumber';
-            case 'Object':
-                return 'abColDefObject';
-            case 'String':
-                return 'abColDefString';
-            case 'NumberArray':
-                return 'abColDefNumberArray';
-            case 'TupleNumberArray':
-                return 'abColDefTupleNumberArray';
-            case 'ObjectNumberArray':
-                return 'abColDefObjectNumberArray';
-            default:
-                return 'abColDefCustom';
-        }
-    }
     getRowHighlightStyle(params) {
-        var _a;
-        const primaryKeyValue = this._adaptable.getPrimaryKeyValueFromRowNode(params.node, params.api);
-        const highlightRow = (_a = this.getAdaptableApi()
-            .internalApi.getSystemState()
-            .HighlightedRows) === null || _a === void 0 ? void 0 : _a.find((highlightRow) => {
+        const primaryKeyValue = this.getGridApi().getPrimaryKeyValueForRowNode(params.node);
+        const highlightRow = this.getAdaptableInternalApi()
+            .getInternalState()
+            .RowHighlightInfo?.find((highlightRow) => {
             return highlightRow.primaryKeyValue === primaryKeyValue;
         });
         if (highlightRow) {
@@ -451,9 +158,8 @@ export class GridInternalApi extends ApiBase {
         }
     }
     getAlertRowStyle(params) {
-        var _a, _b;
         const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
-        const highlightRow = (_b = (_a = alert === null || alert === void 0 ? void 0 : alert.alertDefinition) === null || _a === void 0 ? void 0 : _a.AlertProperties) === null || _b === void 0 ? void 0 : _b.HighlightRow;
+        const highlightRow = alert?.alertDefinition?.AlertProperties?.HighlightRow;
         if (highlightRow) {
             return typeof highlightRow === 'object'
                 ? convertAdaptableStyleToCSS(highlightRow)
@@ -464,22 +170,20 @@ export class GridInternalApi extends ApiBase {
         return null;
     }
     getAlertRowClass(params) {
-        var _a, _b;
         const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
-        const highlightRow = (_b = (_a = alert === null || alert === void 0 ? void 0 : alert.alertDefinition) === null || _a === void 0 ? void 0 : _a.AlertProperties) === null || _b === void 0 ? void 0 : _b.HighlightRow;
-        return typeof highlightRow === 'object' && (highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.ClassName)
-            ? highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.ClassName
+        const highlightRow = alert?.alertDefinition?.AlertProperties?.HighlightRow;
+        return typeof highlightRow === 'object' && highlightRow?.ClassName
+            ? highlightRow?.ClassName
             : null;
     }
     getRowHighlightClass(params) {
-        var _a;
-        const primaryKeyValue = this._adaptable.getPrimaryKeyValueFromRowNode(params.node, params.api);
-        const highlightRow = (_a = this.getAdaptableApi()
-            .internalApi.getSystemState()
-            .HighlightedRows) === null || _a === void 0 ? void 0 : _a.find((highlightRow) => {
+        const primaryKeyValue = this.getGridApi().getPrimaryKeyValueForRowNode(params.node);
+        const highlightRow = this.getAdaptableInternalApi()
+            .getInternalState()
+            .RowHighlightInfo?.find((highlightRow) => {
             return highlightRow.primaryKeyValue === primaryKeyValue;
         });
-        return typeof (highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.highlightStyle) === 'object'
+        return typeof highlightRow?.highlightStyle === 'object'
             ? highlightRow.highlightStyle.ClassName
             : null;
     }
@@ -499,8 +203,7 @@ export class GridInternalApi extends ApiBase {
         };
     }
     hasCellEditableAccordingToEditOptions() {
-        var _a;
-        return typeof ((_a = this.getEditOptions()) === null || _a === void 0 ? void 0 : _a.isCellEditable) === 'function';
+        return typeof this.getEditOptions()?.isCellEditable === 'function';
     }
     /**
      * Returns UNDEFINED if no EditOptions.isCellEditable is provided, otherwise returns the result of the function
@@ -508,10 +211,13 @@ export class GridInternalApi extends ApiBase {
      * DO NOT USE THIS METHOD DIRECTLY - use `GridApi.isCellEditable` instead
      */
     isCellEditableAccordingToEditOptions(gridCell, defaultColDefinitionEditableValue) {
-        var _a;
-        const cellEditable = (_a = this.getEditOptions()) === null || _a === void 0 ? void 0 : _a.isCellEditable;
+        const cellEditable = this.getEditOptions()?.isCellEditable;
         if (cellEditable) {
-            const cellEditableContext = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { gridCell, defaultColDefEditableValue: defaultColDefinitionEditableValue });
+            const cellEditableContext = {
+                ...this.getAdaptableInternalApi().buildBaseContext(),
+                gridCell,
+                defaultColDefEditableValue: defaultColDefinitionEditableValue,
+            };
             return cellEditable(cellEditableContext);
         }
         return undefined;

package/src/Api/Internal/LayoutInternalApi.d.ts

@@ -1,52 +1,35 @@
 import { LayoutAssociatedObject } from '../../AdaptableOptions/LayoutOptions';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
-import { Layout, LayoutState } from '../../PredefinedConfig/LayoutState';
+import { Layout, PivotLayout, TableLayout } from '../../PredefinedConfig/LayoutState';
 import { ApiBase } from '../Implementation/ApiBase';
+import { ColDef, ColGroupDef } from 'ag-grid-enterprise';
 export declare class LayoutInternalApi extends ApiBase {
-    /**
-     * Fires the `LayoutChanged` event
-     * @param trigger what caused event to fire
-     * @param oldSate Layout State before change
-     * @param newState Layout State after change
-     */
-    fireLayoutChangedEvent(trigger: string, oldSate: LayoutState, newState: LayoutState, skipEqualityCheck?: boolean): void;
+    getNormalizedLayout(layout: TableLayout | PivotLayout): TableLayout | PivotLayout;
+    sortColumnDefsByPivotAggregationOrder(columnDefs: (ColDef | ColGroupDef)[], pivotAggregationColumns: PivotLayout['PivotAggregationColumns']): (ColDef | ColGroupDef)[];
     /**
      * Compares 2 Layouts for equality
      * @param layout1 First Layout
      * @param layout2 Second Layout
      */
     areLayoutsEqual(layout1: Layout, layout2: Layout): boolean;
-    /**
-     * Creates a Default Layout (when none provided in Config)
-     * @returns layout
-     */
-    createDefaultLayoutIfNeeded(): Layout | null;
-    /**
-     * Returns true if Layouts will contain Expanded Row Groups information
-     */
-    areExpandedRowGroupsSavedInLayouts(): boolean;
-    /**
-     * Checks if the draft layout and the current layout are the same.
-     * Useful when `autoSaveLayouts=true`
-     */
-    areDraftAndCurrentLayoutEqual(): boolean;
     /**
      * Returns what the layout supports.
      * This takes into account the data-source.
      */
     getLayoutSupportedFeatures(): {
         RowGroupedColumns: boolean;
-        AggregationColumns: boolean;
+        TableAggregationColumns: boolean;
+        PivotAggregationColumns: boolean;
         PivotColumns: boolean;
         ColumnFilters: boolean;
         GridFilter: boolean;
         ColumnSorts: boolean;
         RowSummaries: boolean;
     };
-    updateCurrentDraftLayout(layout: Layout): void;
     hasLayoutSpecificObjects(): boolean;
     isObjectAvailableInLayout(object: LayoutAssociatedObject, module: AdaptableModule, layout: Layout): boolean;
     showLayoutNotAssociatedObjects(): boolean;
     isLayoutGrouped(layout?: Layout): boolean;
     setupRowSummaries(): void;
+    refreshLayout(): void;
 }