@adaptabletools/adaptable 19.0.0 → 19.0.2

package/src/Api/Implementation/GridApiImpl.js

@@ -491,7 +491,22 @@ export class GridApiImpl extends ApiBase {
         if (gridCell.column.readOnly) {
             return false;
         }
-        return this.adaptable.isCellEditable(gridCell.rowNode, this.adaptable.getAgGridColumnForColumnId(gridCell.column.columnId));
+        if (gridCell.rowNode && this.isSummaryNode(gridCell.rowNode)) {
+            return false;
+        }
+        const cellEditableFn = this.getEditOptions().isCellEditable;
+        if (cellEditableFn) {
+            const cellEditableContext = Object.assign({ gridCell }, this.getAdaptableApi().internalApi.buildBaseContext());
+            return cellEditableFn(cellEditableContext);
+        }
+        return true;
+    }
+    isCellEdited(gridCell) {
+        if (!gridCell) {
+            return false;
+        }
+        const cellDataChangedInfo = this.getDataChangeHistoryApi().getDataChangeForGridCell(gridCell);
+        return cellDataChangedInfo != null;
     }
     isEveryCellEditable(gridCells) {
         for (let gridCell of gridCells) {
@@ -504,6 +519,9 @@ export class GridApiImpl extends ApiBase {
     getRowCount() {
         return this.adaptable.getRowCount();
     }
+    getVisibleRowCount() {
+        return this.adaptable.getVisibleRowCount();
+    }
     getRowsInViewport() {
         return this.adaptable.getRowsInViewport();
     }
@@ -555,4 +573,90 @@ export class GridApiImpl extends ApiBase {
     getAllAgGridColumns() {
         return this.adaptable.getAllGridColumns();
     }
+    updateAgGridColumnState(columnState) {
+        const columnExists = this.getColumnApi().doesColumnExist(columnState.colId);
+        if (!columnExists) {
+            this.logWarn(`Column with id ${columnState.colId} does not exist, could NOT update configuration`);
+            return;
+        }
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.applyColumnState({
+            state: [columnState],
+        });
+    }
+    updateAgGridColumnStates(columnStates) {
+        const existingColumnStates = columnStates.filter((cc) => this.getColumnApi().doesColumnExist(cc.colId));
+        const notExistingColumnIds = columnStates
+            .filter((cc) => !this.getColumnApi().doesColumnExist(cc.colId))
+            .map((cc) => cc.colId);
+        notExistingColumnIds.forEach((colId) => {
+            this.logWarn(`Column with id ${colId} does not exist, could NOT update configuration`);
+        });
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.applyColumnState({
+            state: existingColumnStates,
+        });
+    }
+    setAgGridColumnDefinitions(columnDefinitions) {
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.setGridOption('columnDefs', columnDefinitions);
+        this.adaptable.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
+    }
+    updateAgGridColumnDefinition(columnDefinitionToBeUpdated) {
+        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const columnId = columnDefinitionToBeUpdated.colId;
+        const doesColumnExist = this.getColumnApi().doesColumnExist(columnId);
+        if (!doesColumnExist) {
+            this.logWarn(`Column with id ${columnId} does not exist, will add it instead!`);
+            const newColDefs = [...currentColDefs, columnDefinitionToBeUpdated];
+            this.setAgGridColumnDefinitions(newColDefs);
+            return;
+        }
+        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === columnId ? Object.assign(Object.assign({}, colDef), columnDefinitionToBeUpdated) : colDef;
+        });
+        this.setAgGridColumnDefinitions(updatedColDefs);
+    }
+    updateAgGridColumnDefinitions(columnDefinitionsToBeUpdated) {
+        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            const newColDef = newColumnDefinitions.find((c) => c.colId === colDef.colId);
+            return newColDef ? Object.assign(Object.assign({}, colDef), newColDef) : colDef;
+        });
+        // find out new columns which are not in the current column definitions
+        const currentColIds = [];
+        this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            currentColIds.push(colDef.colId);
+            return colDef;
+        });
+        const newColumnDefinitions = columnDefinitionsToBeUpdated.filter((c) => !currentColIds.includes(c.colId));
+        if (newColumnDefinitions.length) {
+            this.logWarn(`Columns with ids ${newColumnDefinitions.map((c) => c.colId).join(', ')} do not exist, will add them instead!`);
+        }
+        this.setAgGridColumnDefinitions([...updatedColDefs, ...newColumnDefinitions]);
+    }
+    removeAgGridColumnDefinition(columnId) {
+        const doesColumnExist = this.getColumnApi().doesColumnExist(columnId);
+        if (!doesColumnExist) {
+            this.logWarn(`Column with id ${columnId} does not exist!`);
+            return;
+        }
+        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        const updatedColDefs = this.adaptable.agGridAdapter
+            .traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === columnId ? null : colDef;
+        })
+            .filter(Boolean);
+        this.setAgGridColumnDefinitions(updatedColDefs);
+    }
+    addAgGridColumnDefinition(newColumnDefinition) {
+        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        // just in case check of there is not already an existing column with the same id and eliminate it
+        const sanitizedColDefs = this.adaptable.agGridAdapter
+            .traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === newColumnDefinition.colId ? null : colDef;
+        })
+            .filter(Boolean);
+        this.setAgGridColumnDefinitions([...sanitizedColDefs, newColumnDefinition]);
+    }
 }

package/src/Api/Implementation/ShortcutApiImpl.d.ts

@@ -14,5 +14,7 @@ export declare class ShortcutApiImpl extends ApiBase implements ShortcutApi {
     deleteAllShortcuts(): void;
     suspendShortcut(shortcut: Shortcut): Shortcut;
     unSuspendShortcut(shortcut: Shortcut): Shortcut;
+    suspendAllShortcut(): void;
+    unSuspendAllShortcut(): void;
     openShortcutSettingsPanel(): void;
 }

package/src/Api/Implementation/ShortcutApiImpl.js

@@ -39,6 +39,12 @@ export class ShortcutApiImpl extends ApiBase {
         this.dispatchAction(ShortcutRedux.ShortcutUnSuspend(shortcut));
         return this.getShortcutById(shortcut.Uuid);
     }
+    suspendAllShortcut() {
+        this.dispatchAction(ShortcutRedux.ShortcutSuspendAll());
+    }
+    unSuspendAllShortcut() {
+        this.dispatchAction(ShortcutRedux.ShortcutUnSuspendAll());
+    }
     openShortcutSettingsPanel() {
         this.showModulePopup(ModuleConstants.ShortcutModuleId);
     }

package/src/Api/Implementation/StyledColumnApiImpl.d.ts

@@ -24,5 +24,7 @@ export declare class StyledColumnApiImpl extends ApiBase implements StyledColumn
     canDisplaySparklines(): boolean;
     suspendStyledColumn(styledColumn: StyledColumn): void;
     unSuspendStyledColumn(styledColumn: StyledColumn): void;
+    suspendAllStyledColumn(): void;
+    unSuspendAllStyledColumn(): void;
     openStyledColumnSettingsPanel(): void;
 }

package/src/Api/Implementation/StyledColumnApiImpl.js

@@ -63,6 +63,12 @@ export class StyledColumnApiImpl extends ApiBase {
     unSuspendStyledColumn(styledColumn) {
         this.dispatchAction(StyledColumnRedux.StyledColumnUnSuspend(styledColumn));
     }
+    suspendAllStyledColumn() {
+        this.dispatchAction(StyledColumnRedux.StyledColumnSuspendAll());
+    }
+    unSuspendAllStyledColumn() {
+        this.dispatchAction(StyledColumnRedux.StyledColumnUnSuspendAll());
+    }
     openStyledColumnSettingsPanel() {
         this.showModulePopup(ModuleConstants.StyledColumnModuleId);
     }

package/src/Api/Implementation/UserInterfaceApiImpl.d.ts

@@ -26,6 +26,7 @@ export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfa
     getEditLookUpItemForColumn(column: AdaptableColumn): EditLookUpPermittedValues | undefined;
     getEditLookUpValuesForEditLookUpItem(editLookUpItem: EditLookUpPermittedValues, gridCell: GridCell): any[] | undefined;
     getEditableCellStyle(): AdaptableStyle | undefined;
+    getEditedCellStyle(): AdaptableStyle | undefined;
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
     getAdaptableObjectTags(): AdaptableObjectTag[] | undefined;
     getCustomIconDefinition(iconName: string): import("../../types").AdaptableIcon | import("../../types").CustomIcon;

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -142,6 +142,9 @@ export class UserInterfaceApiImpl extends ApiBase {
     getEditableCellStyle() {
         return this.getUserInterfaceOptions().editableCellStyle;
     }
+    getEditedCellStyle() {
+        return this.getUserInterfaceOptions().editedCellStyle;
+    }
     getReadOnlyCellStyle() {
         return this.getUserInterfaceOptions().readOnlyCellStyle;
     }

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

@@ -18,7 +18,7 @@ export declare class ActionRowInternalApi extends ApiBase {
     private buidActionRowButtons;
     private prepareCreateData;
     private prepareEditData;
-    private isColumnEditable;
+    private isCellEditable;
     private buildFormField;
     private getFormFieldLabel;
     private buildFormFieldLabelContext;

package/src/Api/Internal/ActionRowInternalApi.js

@@ -49,7 +49,7 @@ export class ActionRowInternalApi extends ApiBase {
             .columnApi.getColumns()
             .filter((column) => {
             // if there is NO rowNode, do NOT display the non-editable fields as they will be empty
-            return !!rowNode || this.isColumnEditable(column, rowNode);
+            return !!rowNode || this.isCellEditable(column, rowNode);
         })
             .filter((column) => !this.getAdaptableApi().columnApi.internalApi.isActionRowButtonColumn(column.columnId) &&
             this.showColumnInActionRowForm(column, actionRowType));
@@ -116,21 +116,23 @@ export class ActionRowInternalApi extends ApiBase {
         dataToSave[this.getOptions().primaryKey] = pkValue;
         return dataToSave;
     }
-    isColumnEditable(column, rowNode) {
-        return rowNode
-            ? this.adaptableInstance.isCellEditable(rowNode, this.adaptableInstance.getAgGridColumnForColumnId(column.columnId))
-            : !column.readOnly;
+    isCellEditable(column, rowNode) {
+        if (!rowNode) {
+            return !column.readOnly;
+        }
+        const gridCell = this.getAdaptableApi().gridApi.getGridCellFromRowNode(rowNode, column.columnId);
+        return this.getAdaptableApi().gridApi.isCellEditable(gridCell);
     }
     buildFormField(type, column, rowNode) {
-        const isColumnEditable = this.isColumnEditable(column, rowNode);
+        const isCellEditable = this.isCellEditable(column, rowNode);
         const fieldValueOptions = this.getFieldValueOptions(column, rowNode);
-        const fieldType = isColumnEditable
+        const fieldType = isCellEditable
             ? !!(fieldValueOptions === null || fieldValueOptions === void 0 ? void 0 : fieldValueOptions.length)
                 ? 'select'
                 : this.getFieldTypeFromColumnType(column)
             : 'textOutput';
         const defaultValue = rowNode
-            ? isColumnEditable
+            ? isCellEditable
                 ? this.getAdaptableApi().gridApi.getRawValueFromRowNode(rowNode, column.columnId)
                 : this.getAdaptableApi().gridApi.getDisplayValueFromRowNode(rowNode, column.columnId)
             : null;

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

@@ -30,10 +30,10 @@ export declare class ExportInternalApi extends ApiBase {
     getReportData(report: Report, includePrimaryKey?: boolean): ReportData;
     getReportDataAsArray(report: Report, includePrimaryKey?: boolean): any[][];
     convertReportDataToArray(reportData: ReportData): any[][];
-    getRowObjectForColumnIds(rowNode: IRowNode, columnIds: string[]): Record<string, any>;
+    getRowObjectForColumnIds(rowNode: IRowNode, columnIds: string[], reportName: string): Record<string, any>;
     publishLiveLiveDataChangedEvent(reportDestination: 'ipushpull' | 'OpenFin', liveDataTrigger: 'Connected' | 'Disconnected' | 'SnapshotSent' | 'LiveDataStarted' | 'LiveDataStopped' | 'LiveDataUpdated', liveReport?: any): void;
-    getCellExportValueFromRowNode(rowNode: IRowNode, columnId: string): any;
-    getCellExportValueFromRawValue(rowNode: IRowNode, cellRawValue: any, columnId: string): any;
+    getCellExportValueFromRowNode(rowNode: IRowNode, columnId: string, reportName: string): any;
+    getCellExportValueFromRawValue(rowNode: IRowNode, cellRawValue: any, columnId: string, reportName: string): any;
     getReportFileName(reportName: string, destination: SystemExportDestination | CustomDestination): string;
     private getCustomExportDateFormat;
     private getCellExportValueFromRawValueByType;

package/src/Api/Internal/ExportInternalApi.js

@@ -361,12 +361,12 @@ export class ExportInternalApi extends ApiBase {
         switch (report.ReportRowScope) {
             case 'AllRows':
                 this.getAdaptableApi().internalApi.forAllRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
                 });
                 break;
             case 'VisibleRows':
                 this.getAdaptableApi().internalApi.forAllVisibleRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
                 });
                 break;
             case 'ExpressionRows':
@@ -375,7 +375,7 @@ export class ExportInternalApi extends ApiBase {
                     if (this.getAdaptableApi()
                         .internalApi.getQueryLanguageService()
                         .evaluateBooleanExpression((_a = report.Query) === null || _a === void 0 ? void 0 : _a.BooleanExpression, ExportModuleId, rowNode)) {
-                        resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                        resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
                     }
                 });
                 break;
@@ -390,7 +390,7 @@ export class ExportInternalApi extends ApiBase {
                     if (selectedRowCells) {
                         const selectedRowColumnIds = selectedRowCells.map((rowCell) => rowCell.column.columnId);
                         const selectedColumnIds = columnIds.filter((columnId) => selectedRowColumnIds.includes(columnId));
-                        const row = this.getRowObjectForColumnIds(rowNode, selectedColumnIds);
+                        const row = this.getRowObjectForColumnIds(rowNode, selectedColumnIds, report.Name);
                         if (includePrimaryKey) {
                             row[this.getAdaptableApi().optionsApi.getPrimaryKey()] = rowPrimaryKeyValue;
                         }
@@ -405,7 +405,7 @@ export class ExportInternalApi extends ApiBase {
                     this.getAdaptableApi().internalApi.forAllRowNodesDo((rowNode) => {
                         const rowPrimaryKeyValue = this.getAdaptableApi().gridApi.getPrimaryKeyValueForRowNode(rowNode);
                         if (selectedGridRowPrimaryKeys.includes(rowPrimaryKeyValue)) {
-                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
+                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
                         }
                     });
                 }
@@ -431,9 +431,9 @@ export class ExportInternalApi extends ApiBase {
             ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.columnId])),
         ];
     }
-    getRowObjectForColumnIds(rowNode, columnIds) {
+    getRowObjectForColumnIds(rowNode, columnIds, reportName) {
         return columnIds.reduce((result, columnId) => {
-            result[columnId] = this.getCellExportValueFromRowNode(rowNode, columnId);
+            result[columnId] = this.getCellExportValueFromRowNode(rowNode, columnId, reportName);
             return result;
         }, {});
     }
@@ -441,24 +441,28 @@ export class ExportInternalApi extends ApiBase {
         const liveDataChangedInfo = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { reportDestination: reportDestination, liveDataTrigger: liveDataTrigger, liveReport: liveReport });
         this.getAdaptableApi().eventApi.emit('LiveDataChanged', liveDataChangedInfo);
     }
-    getCellExportValueFromRowNode(rowNode, columnId) {
-        return this.getCellExportValueFromRawValue(rowNode, this.getAdaptableApi().gridApi.getRawValueFromRowNode(rowNode, columnId), columnId);
+    getCellExportValueFromRowNode(rowNode, columnId, reportName) {
+        return this.getCellExportValueFromRawValue(rowNode, this.getAdaptableApi().gridApi.getRawValueFromRowNode(rowNode, columnId), columnId, reportName);
     }
-    getCellExportValueFromRawValue(rowNode, cellRawValue, columnId) {
+    getCellExportValueFromRawValue(rowNode, cellRawValue, columnId, reportName) {
         if (StringExtensions.IsNullOrEmpty(cellRawValue)) {
             return cellRawValue;
         }
         const column = this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId);
         const columnDataType = column.dataType;
-        // if this is a date column and there is a custom export date format provided, that will take precedence
+        // 1. if it is a Visual Data report then we always ONLY send the formatted value and ignore all other properties
+        if (reportName == VISUAL_DATA_REPORT) {
+            return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, 'formattedValue');
+        }
+        // 2. if this is a date column and there is a custom export date format provided, that will next take precedence
         if (columnDataType === 'Date' && !!this.getCustomExportDateFormat()) {
             const exportDateFormat = this.getCustomExportDateFormat();
             return FormatHelper.DateFormatter(cellRawValue, {
                 Pattern: exportDateFormat,
             });
         }
-        // otherwise check the general export format types
-        let cellExportFormat = this.getAdaptableApi().exportApi.internalApi.getCellExportFormatType(column, columnDataType);
+        // 3. in all other cases check the general export format types
+        const cellExportFormat = this.getAdaptableApi().exportApi.internalApi.getCellExportFormatType(column, columnDataType);
         return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, cellExportFormat);
     }
     getReportFileName(reportName, destination) {

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

@@ -3,7 +3,7 @@ import { GridFilter } from '../../types';
 export declare class GridFilterInternalApi extends ApiBase {
     fireGridFilterAppliedEvent(): void;
     /**
-     * Compares to Grid Filters to see if they are identical
+     * Compares to Grid Filter to see if they are identical
      */
     isGridFilterDifferent(oldFilter: GridFilter, newFilter: GridFilter): boolean;
 }

package/src/Api/Internal/GridFilterInternalApi.js

@@ -11,9 +11,12 @@ export class GridFilterInternalApi extends ApiBase {
         }
     }
     /**
-     * Compares to Grid Filters to see if they are identical
+     * Compares to Grid Filter to see if they are identical
      */
     isGridFilterDifferent(oldFilter, newFilter) {
-        return (oldFilter === null || oldFilter === void 0 ? void 0 : oldFilter.Expression) === (newFilter === null || newFilter === void 0 ? void 0 : newFilter.Expression);
+        if (oldFilter == undefined && newFilter == undefined) {
+            return false;
+        }
+        return (oldFilter === null || oldFilter === void 0 ? void 0 : oldFilter.Expression) !== (newFilter === null || newFilter === void 0 ? void 0 : newFilter.Expression);
     }
 }

package/src/Api/ShortcutApi.d.ts

@@ -53,6 +53,14 @@ export interface ShortcutApi {
      * @returns shortcut
      */
     unSuspendShortcut(shortcut: Shortcut): Shortcut;
+    /**
+     * Suspends all Shortcuts
+     */
+    suspendAllShortcut(): void;
+    /**
+     * Activates all suspended Shortcut
+     */
+    unSuspendAllShortcut(): void;
     /**
      * Opens Settings Panel with Shortcut section selected and visible
      */

package/src/Api/StyledColumnApi.d.ts

@@ -57,6 +57,14 @@ export interface StyledColumnApi {
      * @param styledColumn
      */
     unSuspendStyledColumn(styledColumn: StyledColumn): void;
+    /**
+    * Suspends all Styled Columns
+    */
+    suspendAllStyledColumn(): void;
+    /**
+     * Activates all suspended Styled Column
+     */
+    unSuspendAllStyledColumn(): void;
     /**
      * Checks whether Column with given `columnId` has a PercentBar Style applied
      * @param columnId column ID

package/src/Api/UserInterfaceApi.d.ts

@@ -55,11 +55,15 @@ export interface UserInterfaceApi {
      */
     getEditLookUpValuesForEditLookUpItem(editLookUpItem: EditLookUpPermittedValues, gridCell: GridCell): any[] | undefined;
     /**
-     * Returns Style set for Editable cells
+     * Returns Style set for Editable Cells
      */
     getEditableCellStyle(): AdaptableStyle | undefined;
     /**
-     * Returns Style set for ReadOnly cells
+     * Returns Style for Cells that have been edited
+     */
+    getEditedCellStyle(): AdaptableStyle | undefined;
+    /**
+     * Returns Style set for ReadOnly Cells
      */
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
     /**

package/src/PredefinedConfig/Common/AdaptableFormat.d.ts

@@ -43,7 +43,7 @@ export interface NumberFormatterOptions extends BaseFormatterOptions {
      */
     Suffix?: string;
     /**
-     * Replaces cell value with supplied value (that can contain placeholders)
+     * Replaces cell value with supplied value (that can contain Template Literals)
      */
     Content?: string | number;
     /**

package/src/PredefinedConfig/Common/RowScope.d.ts

@@ -1,5 +1,5 @@
 /**
- * Defines which types of Rows to exclude when rendering Format Columns, Action Columns, Badges
+ * Defines which types of Rows to exclude when rendering Format Columns, Action Columns and Badges
  */
 export type RowScope = {
     /**

package/src/Redux/ActionsReducers/SystemRedux.js

@@ -463,10 +463,8 @@ export const SystemReducer = (state = initialState, action) => {
             });
             const AdaptableFlashingCellsMap = Object.assign({}, state.AdaptableFlashingCellsMap);
             AdaptableFlashingCellsMap[FlashingCell.Uuid] = FlashingCell;
-            return Object.assign({}, state, {
-                AdaptableFlashingCells: AdaptableFlashingCells,
-                AdaptableFlashingCellsMap: AdaptableFlashingCellsMap,
-            });
+            return Object.assign(Object.assign({}, state), { AdaptableFlashingCells,
+                AdaptableFlashingCellsMap });
         }
         case SYSTEM_FLASHING_CELL_DELETE: {
             const { flashingCell: FlashingCell } = action;
@@ -490,10 +488,7 @@ export const SystemReducer = (state = initialState, action) => {
             return Object.assign(Object.assign({}, state), { AdaptableFlashingCells: AdaptableFlashingCells, AdaptableFlashingCellsMap: AdaptableFlashingCellsMap });
         }
         case SYSTEM_FLASHING_CELL_DELETE_ALL: {
-            return Object.assign({}, state, {
-                AdaptableFlashingCells: {},
-                AdaptableFlashingCellsMap: {},
-            });
+            return Object.assign(Object.assign({}, state), { AdaptableFlashingCells: {}, AdaptableFlashingCellsMap: {} });
         }
         case SYSTEM_HIGHLIGHT_CELL_ADD: {
             const actionTypedAdd = action;

package/src/Utilities/license/hashing.js

@@ -1 +1 @@
-const r=3988292384;function n(n=r){var t,o,u,e=new Array;for(t=0;t<256;t++){for(u=t,o=8;o>0;o--)1&~u?u>>>=1:u=u>>>1^n;e[t]=u}return e}function t(){return 4294967295}function o(r,n,t){return n=n>>>8^r[t^255&n]}function u(r){return r=(r=~r)<0?4294967295+r+1:r}export function compute_string(e,c=r){var f,i=n(c),a=0;for(a=t(),f=0;f<e.length;f++)a=o(i,a,e.charCodeAt(f));return`${a=u(a)}`}
+const r=3988292384;function n(r=3988292384){var n,t,o,u=new Array;for(n=0;n<256;n++){for(o=n,t=8;t>0;t--)1&~o?o>>>=1:o=o>>>1^r;u[n]=o}return u}function t(){return 4294967295}function o(r,n,t){return n=n>>>8^r[t^255&n]}function u(r){return r=(r=~r)<0?4294967295+r+1:r}export function compute_string(r,e=3988292384){var c,f=n(e),i=0;for(i=t(),c=0;c<r.length;c++)i=o(f,i,r.charCodeAt(c));return`${i=u(i)}`}

package/src/View/Dashboard/DashboardPopup.js

@@ -72,9 +72,10 @@ class DashboardPopupComponent extends React.Component {
                     React.createElement(CheckBox, { "data-name": "hidden", className: `${baseClassName}__settings-option`, checked: this.props.IsHidden, onChange: (checked) => this.props.onSetDashboardHidden(checked) }, "Hidden"))),
                 React.createElement(Panel, { header: 'Dashboard Contents', style: { borderBottom: '1px solid var(--ab-color-primary)' }, variant: "default", borderRadius: "none", marginTop: 4 },
                     React.createElement(Flex, { className: `${baseClassName}__contents-selector`, flexDirection: "row", padding: 2 },
-                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.Toolbars, checked: this.state.DashboardConfigView == DashboardConfigView.Toolbars, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Tabs & Toolbars"),
-                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.Buttons, checked: this.state.DashboardConfigView == DashboardConfigView.Buttons, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Buttons"),
-                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.PinnedToolbars, checked: this.state.DashboardConfigView == DashboardConfigView.PinnedToolbars, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Pinned Toolbars")),
+                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.Toolbars, checked: this.state.DashboardConfigView == DashboardConfigView.Toolbars, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Tabbed Toolbars"),
+                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.PinnedToolbars, checked: this.state.DashboardConfigView == DashboardConfigView.PinnedToolbars, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Pinned Toolbars"),
+                        ' ',
+                        React.createElement(Radio, { marginLeft: 3, value: DashboardConfigView.Buttons, checked: this.state.DashboardConfigView == DashboardConfigView.Buttons, onChange: (_, e) => this.onDashboardConfigViewChanged(e) }, "Buttons")),
                     React.createElement(Box, { className: `${baseClassName}__Module-Selector`, "data-name": this.state.DashboardConfigView === DashboardConfigView.Toolbars
                             ? 'toolbars'
                             : 'buttons', style: { minHeight: 0, flex: '1 1 0' }, padding: 2 },

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

@@ -39,6 +39,7 @@ export const GridInfoPopup = (props) => {
         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 === null || selectedRowInfo === void 0 ? void 0 : selectedRowInfo.gridRows.length));
         returnRows.push(createReadOnlyColItem(colItems, 'Visible Selected Rows', selectedRowInfo === null || selectedRowInfo === void 0 ? void 0 : selectedRowInfo.gridRows.filter((gr) => { var _a; return ((_a = gr.rowNode) === null || _a === void 0 ? void 0 : _a.displayed) == true; }).length));
         returnRows.push(createReadOnlyColItem(colItems, 'All Columns', props.api.gridApi.getColumnCount()));

package/src/View/Layout/Wizard/getGridFilterPreview.js

@@ -4,7 +4,7 @@ import { Tag } from '../../../components/Tag';
 export const getGridFilterViewItems = (layout) => {
     var _a;
     return {
-        name: 'Grid Filters',
+        name: 'Grid Filter',
         view: (React.createElement(Tag, null,
             React.createElement(ExpressionPreview, { query: { BooleanExpression: (_a = layout.GridFilter) === null || _a === void 0 ? void 0 : _a.Expression } }))),
     };

package/src/View/Layout/Wizard/sections/ColumnsSection.js

@@ -185,7 +185,7 @@ const ColumnRow = (props) => {
 export const ColumnsSection = (props) => {
     const adaptable = useAdaptable();
     const { data: layout } = useOnePageAdaptableWizardContext();
-    const allColumns = adaptable.api.columnApi.getColumns();
+    const allColumns = adaptable.api.columnApi.getStandardColumns();
     const sortedColumns = React.useMemo(() => {
         return ArrayExtensions.sortArrayWithOrder(allColumns.map((col) => col.columnId), layout.Columns, { sortUnorderedItems: false }).map((colId) => adaptable.api.columnApi.getColumnWithColumnId(colId));
     }, [layout, allColumns]);

package/src/View/Layout/Wizard/sections/GridFilterSection.js

@@ -33,7 +33,7 @@ export const GridFilterSection = (props) => {
             props.onChange(Object.assign(Object.assign({}, layout), { GridFilter: Object.assign(Object.assign({}, layout.GridFilter), { Expression: expression }) }));
         }, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })));
     return (React.createElement(Tabs, { style: { height: '100%' } },
-        React.createElement(Tabs.Tab, null, "Grid Filters"),
+        React.createElement(Tabs.Tab, null, "Grid Filter"),
         React.createElement(Tabs.Content, null,
             React.createElement(Panel, null, expressionEditorContent))));
 };

package/src/agGrid/ActionColumnRenderer.d.ts

@@ -7,6 +7,8 @@ export declare class ActionColumnRenderer implements ICellRendererComp {
     private eGui;
     private eventListener;
     private unmountReactRoot?;
+    private layoutSwitchUnsubscribe?;
+    private actionButtons;
     init(params: ActionColumnCellRendererParams): void;
     render(): void;
     getGui(): HTMLElement;

package/src/agGrid/ActionColumnRenderer.js

@@ -2,6 +2,7 @@ import SimpleButton from '../components/SimpleButton';
 import * as React from 'react';
 import { useRerender } from '../components/utils/useRerender';
 import { renderWithAdaptableContext } from '../View/renderWithAdaptableContext';
+import { LAYOUT_SELECT } from '../Redux/ActionsReducers/LayoutRedux';
 const ActionButtons = (props) => {
     const { buttons, adaptableApi, context, rerender } = props;
     return (React.createElement(React.Fragment, null, buttons.map((button, index) => {
@@ -65,6 +66,20 @@ export const ReactActionColumnRenderer = (props) => {
     if (!shouldRender) {
         return null;
     }
+    // subscribe to the LayoutChange event and rerender on change
+    const unsubscribe = adaptable.api.eventApi.on('AdaptableStateChanged', (eventInfo) => {
+        if (eventInfo.actionName === LAYOUT_SELECT) {
+            if (eventInfo.oldState.Layout.CurrentLayout !== eventInfo.newState.Layout.CurrentLayout) {
+                rerender();
+            }
+        }
+    });
+    // unsubscribe on unmount
+    React.useEffect(() => {
+        return () => {
+            unsubscribe();
+        };
+    }, []);
     const pkValue = adaptable.getPrimaryKeyValueFromRowNode(props.node, props.api);
     const buttonContext = Object.assign(Object.assign({ actionColumn, primaryKeyValue: pkValue, rowNode: props.node }, adaptable.api.internalApi.buildBaseContext()), { data: props.data });
     return (React.createElement("div", { className: "ab-ActionColumn" },
@@ -83,6 +98,7 @@ export class ActionColumnRenderer {
         if (!actionColumn || !actionButtons.length) {
             return;
         }
+        this.actionButtons = actionButtons;
         // create the cell
         this.eGui = document.createElement('div');
         this.eGui.className = 'ab-ActionColumn';
@@ -114,13 +130,22 @@ export class ActionColumnRenderer {
         const eGui = this.eGui;
         const doRender = () => {
             this.unmountReactRoot = adaptable.renderReactRoot(renderWithAdaptableContext(ActionButtons({
-                buttons: actionButtons,
+                buttons: this.actionButtons,
                 context: buttonContext,
                 rerender: doRender,
                 adaptableApi: adaptable.api,
             }), adaptable), eGui);
         };
         this.render = doRender;
+        this.layoutSwitchUnsubscribe = adaptable.api.eventApi.on('AdaptableStateChanged', (eventInfo) => {
+            if (eventInfo.actionName === LAYOUT_SELECT) {
+                if (eventInfo.oldState.Layout.CurrentLayout !== eventInfo.newState.Layout.CurrentLayout) {
+                    const { actionButtons: freshActionButtons } = adaptable.api.internalApi.getActionButtonsAndActionColumn(params.colDef);
+                    this.actionButtons = freshActionButtons;
+                    doRender();
+                }
+            }
+        });
         doRender();
     }
     // defined on init
@@ -138,8 +163,9 @@ export class ActionColumnRenderer {
     }
     // gets called when the cell is removed from the grid
     destroy() {
-        var _a;
-        (_a = this.unmountReactRoot) === null || _a === void 0 ? void 0 : _a.call(this);
+        var _a, _b;
+        (_a = this.layoutSwitchUnsubscribe) === null || _a === void 0 ? void 0 : _a.call(this);
+        (_b = this.unmountReactRoot) === null || _b === void 0 ? void 0 : _b.call(this);
         // do cleanup, remove event listener from button
         if (this.eGui) {
             this.eGui.removeEventListener('click', this.eventListener);

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -249,7 +249,6 @@ export declare class AdaptableAgGrid implements IAdaptable {
     getRowNodeByIndex(index: number): IRowNode;
     getAgGridStatusPanels(): import("@ag-grid-community/core").StatusPanelDef[];
     setDataValue(value: any, column: AdaptableColumn, primaryKeyValue: any, rowNode?: IRowNode): void;
-    isCellEditable(rowNode: IRowNode, column: Column): boolean;
     forAllRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
         includeGroupRows?: boolean;
         filterFn?: (rowNode: IRowNode) => boolean;
@@ -285,6 +284,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
     updateChart(chart: ChartDefinition): void;
     getChartModels(): import("@ag-grid-community/core").ChartModel[];
     getRowCount(): number;
+    getVisibleRowCount(): number;
     getColumnCount(): number;
     getVisibleColumnCount(): number;
     isGridGroupable(): boolean;