@adaptabletools/adaptable 21.1.3-canary.0 → 21.2.0

package/src/Redux/ActionsReducers/CommentsRedux.d.ts

@@ -2,74 +2,77 @@ import * as Redux from 'redux';
 import { CommentThread, AdaptableComment, CommentState } from '../../AdaptableState/CommentState';
 import { CellAddress } from '../../types';
 /**
- * @ReduxAction A Comments has been added
+ * @ReduxAction A Comment has been added
  */
-export declare const COMMENTS_ADD = "COMMENTS_ADD";
+export declare const COMMENT_ADD = "COMMENT_ADD";
 /**
- * @ReduxAction Cell Comments has been added
+ * @ReduxAction A Comment Thread has been added
  */
-export declare const COMMENTS_CELL_ADD = "COMMENTS_CELL_ADD";
+export declare const COMMENT_THREAD_ADD = "COMMENT_THREAD_ADD";
 /**
- * @ReduxAction Cell comments have been removed
+ * @ReduxAction A Comment Thread has been removed
  */
-export declare const COMMENTS_CELL_DELETE = "COMMENTS_CELL_DELETE";
+export declare const COMMENT_THREAD_DELETE = "COMMENT_THREAD_DELETE";
 /**
- * @ReduxAction A Comments has been edited
+ * @ReduxAction A Comment has been edited
  */
-export declare const COMMENTS_EDIT = "COMMENTS_EDIT";
+export declare const COMMENT_EDIT = "COMMENT_EDIT";
 /**
- * @ReduxAction A Comments has been deleted
+ * @ReduxAction A Comment has been deleted
  */
-export declare const COMMENTS_DELETE = "COMMENTS_DELETE";
+export declare const COMMENT_DELETE = "COMMENT_DELETE";
 /**
  * @ReduxAction Comments Module is ready
  */
 export declare const COMMENTS_READY = "COMMENTS_READY";
-export declare const COMMENTS_LOAD = "COMMENTS_LOAD";
+/**
+ * @ReduxAction Comments have been loaded
+ */
+export declare const COMMENTS_THREADS_LOAD = "COMMENTS_THREADS_LOAD";
 export interface AdaptableCommentAction extends Redux.Action {
     comment: AdaptableComment;
     cellAddress: CellAddress;
 }
-export interface AdaptableCommentsAddAction extends AdaptableCommentAction {
+export interface AdaptableCommentAddAction extends AdaptableCommentAction {
 }
-export interface AdaptableCommentsCellAddAction extends Redux.Action {
+export interface AdaptableCommentThreadAddAction extends Redux.Action {
     commentThread: CommentThread;
 }
-export interface AdaptableCommentsSetAction extends Redux.Action {
-    commentThread: CommentThread[];
+export interface AdaptableCommentThreadsLoadAction extends Redux.Action {
+    commentThreads: CommentThread[];
 }
-export interface AdaptableCommentsCellDeleteAction extends Redux.Action {
+export interface AdaptableCommentThreadDeleteAction extends Redux.Action {
     cellAddress: CellAddress;
 }
-export interface AdaptableCommentsEditAction extends AdaptableCommentAction {
+export interface AdaptableCommentEditAction extends AdaptableCommentAction {
 }
-export interface AdaptableCommentsDeleteAction extends Redux.Action {
+export interface AdaptableCommentDeleteAction extends Redux.Action {
     commentUuid: AdaptableComment['Uuid'];
     cellAddress: CellAddress;
 }
-export interface NoteReadyAction extends Redux.Action {
+export interface CommentReadyAction extends Redux.Action {
     commentState: CommentState;
 }
-export declare const CommentsSet: ({ commentThread, }: {
-    commentThread: CommentThread[];
-}) => AdaptableCommentsSetAction;
-export declare const CommentsAdd: ({ comment, cellAddress, }: {
+export declare const CommentThreadsLoad: ({ commentThreads, }: {
+    commentThreads: CommentThread[];
+}) => AdaptableCommentThreadsLoadAction;
+export declare const CommentAdd: ({ comment, cellAddress, }: {
     comment: AdaptableComment;
     cellAddress: CellAddress;
-}) => AdaptableCommentsAddAction;
-export declare const CommentsCellAdd: ({ commentThread, }: {
+}) => AdaptableCommentAddAction;
+export declare const CommentThreadAdd: ({ commentThread, }: {
     commentThread: CommentThread;
-}) => AdaptableCommentsCellAddAction;
-export declare const CommentsCellDelete: ({ cellAddress: cellAddress, }: {
+}) => AdaptableCommentThreadAddAction;
+export declare const CommentThreadDelete: ({ cellAddress: cellAddress, }: {
     cellAddress: CellAddress;
-}) => AdaptableCommentsCellDeleteAction;
-export declare const CommentsEdit: ({ comment, cellAddress, }: {
+}) => AdaptableCommentThreadDeleteAction;
+export declare const CommentEdit: ({ comment, cellAddress, }: {
     comment: AdaptableComment;
     cellAddress: CellAddress;
-}) => AdaptableCommentsEditAction;
+}) => AdaptableCommentEditAction;
 export declare const CommentsDelete: ({ commentUuid, cellAddress, }: {
     commentUuid: AdaptableComment['Uuid'];
     cellAddress: CellAddress;
-}) => AdaptableCommentsDeleteAction;
+}) => AdaptableCommentDeleteAction;
 export declare const GetCellCommentSelector: (state: CommentState, address: CellAddress) => CommentThread | undefined;
 export declare const CommentsReducer: Redux.Reducer<CommentState>;

package/src/Redux/ActionsReducers/CommentsRedux.js

@@ -2,54 +2,57 @@ import { EMPTY_ARRAY } from '../../Utilities/Constants/GeneralConstants';
 import ObjectFactory from '../../Utilities/ObjectFactory';
 import { AnnotationsService } from '../../Utilities/Services/AnnotationsService';
 /**
- * @ReduxAction A Comments has been added
+ * @ReduxAction A Comment has been added
  */
-export const COMMENTS_ADD = 'COMMENTS_ADD';
+export const COMMENT_ADD = 'COMMENT_ADD';
 /**
- * @ReduxAction Cell Comments has been added
+ * @ReduxAction A Comment Thread has been added
  */
-export const COMMENTS_CELL_ADD = 'COMMENTS_CELL_ADD';
+export const COMMENT_THREAD_ADD = 'COMMENT_THREAD_ADD';
 /**
- * @ReduxAction Cell comments have been removed
+ * @ReduxAction A Comment Thread has been removed
  */
-export const COMMENTS_CELL_DELETE = 'COMMENTS_CELL_DELETE';
+export const COMMENT_THREAD_DELETE = 'COMMENT_THREAD_DELETE';
 /**
- * @ReduxAction A Comments has been edited
+ * @ReduxAction A Comment has been edited
  */
-export const COMMENTS_EDIT = 'COMMENTS_EDIT';
+export const COMMENT_EDIT = 'COMMENT_EDIT';
 /**
- * @ReduxAction A Comments has been deleted
+ * @ReduxAction A Comment has been deleted
  */
-export const COMMENTS_DELETE = 'COMMENTS_DELETE';
+export const COMMENT_DELETE = 'COMMENT_DELETE';
 /**
  * @ReduxAction Comments Module is ready
  */
 export const COMMENTS_READY = 'COMMENTS_READY';
-export const COMMENTS_LOAD = 'COMMENTS_LOAD';
-export const CommentsSet = ({ commentThread, }) => ({
-    type: COMMENTS_LOAD,
-    commentThread,
+/**
+ * @ReduxAction Comments have been loaded
+ */
+export const COMMENTS_THREADS_LOAD = 'COMMENTS_THREADS_LOAD';
+export const CommentThreadsLoad = ({ commentThreads, }) => ({
+    type: COMMENTS_THREADS_LOAD,
+    commentThreads,
 });
-export const CommentsAdd = ({ comment, cellAddress, }) => ({
-    type: COMMENTS_ADD,
+export const CommentAdd = ({ comment, cellAddress, }) => ({
+    type: COMMENT_ADD,
     comment,
     cellAddress,
 });
-export const CommentsCellAdd = ({ commentThread, }) => ({
-    type: COMMENTS_CELL_ADD,
+export const CommentThreadAdd = ({ commentThread, }) => ({
+    type: COMMENT_THREAD_ADD,
     commentThread,
 });
-export const CommentsCellDelete = ({ cellAddress: cellAddress, }) => ({
-    type: COMMENTS_CELL_DELETE,
+export const CommentThreadDelete = ({ cellAddress: cellAddress, }) => ({
+    type: COMMENT_THREAD_DELETE,
     cellAddress: cellAddress,
 });
-export const CommentsEdit = ({ comment, cellAddress, }) => ({
-    type: COMMENTS_EDIT,
+export const CommentEdit = ({ comment, cellAddress, }) => ({
+    type: COMMENT_EDIT,
     comment,
     cellAddress,
 });
 export const CommentsDelete = ({ commentUuid, cellAddress, }) => ({
-    type: COMMENTS_DELETE,
+    type: COMMENT_DELETE,
     cellAddress,
     commentUuid,
 });
@@ -66,7 +69,7 @@ const initialState = {
 };
 export const CommentsReducer = (state = initialState, action) => {
     switch (action.type) {
-        case COMMENTS_ADD: {
+        case COMMENT_ADD: {
             const addAction = action;
             const commentThread = state.CommentThreads ?? [];
             const cellCommentIndex = commentThread.findIndex((cellComments) => {
@@ -89,7 +92,7 @@ export const CommentsReducer = (state = initialState, action) => {
             }
             return { ...state, CommentThreads: comments };
         }
-        case COMMENTS_CELL_ADD: {
+        case COMMENT_THREAD_ADD: {
             return {
                 ...state,
                 CommentThreads: [
@@ -98,14 +101,14 @@ export const CommentsReducer = (state = initialState, action) => {
                 ],
             };
         }
-        case COMMENTS_CELL_DELETE: {
+        case COMMENT_THREAD_DELETE: {
             const deleteAction = action;
             return {
                 ...state,
                 CommentThreads: (state.CommentThreads ?? []).filter((cellComments) => !AnnotationsService.isSameAddress(cellComments, deleteAction.cellAddress)),
             };
         }
-        case COMMENTS_EDIT: {
+        case COMMENT_EDIT: {
             const editAction = action;
             let edited = false;
             const adaptableCellComments = (state.CommentThreads ?? []).map((cellComments) => {
@@ -128,7 +131,7 @@ export const CommentsReducer = (state = initialState, action) => {
                 CommentThreads: adaptableCellComments,
             };
         }
-        case COMMENTS_DELETE: {
+        case COMMENT_DELETE: {
             const deleteAction = action;
             const adaptableCellComments = (state.CommentThreads ?? [])
                 .map((cellComments) => {
@@ -152,10 +155,10 @@ export const CommentsReducer = (state = initialState, action) => {
                 CommentThreads: adaptableCellComments,
             };
         }
-        case COMMENTS_LOAD: {
+        case COMMENTS_THREADS_LOAD: {
             return {
                 ...state,
-                CommentThreads: action.commentThread,
+                CommentThreads: action.commentThreads,
             };
         }
         default:

package/src/Redux/Store/AdaptableStore.js

@@ -864,11 +864,11 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                  * Use Case: Comments has been edited/deleted/added
                  * Action: Triangle can be removed/added
                  */
-                case CommentsRedux.COMMENTS_ADD:
-                case CommentsRedux.COMMENTS_EDIT:
-                case CommentsRedux.COMMENTS_DELETE:
-                case CommentsRedux.COMMENTS_CELL_DELETE:
-                case CommentsRedux.COMMENTS_CELL_ADD: {
+                case CommentsRedux.COMMENT_ADD:
+                case CommentsRedux.COMMENT_EDIT:
+                case CommentsRedux.COMMENT_DELETE:
+                case CommentsRedux.COMMENT_THREAD_DELETE:
+                case CommentsRedux.COMMENT_THREAD_ADD: {
                     let returnAction = next(action);
                     adaptable.AnnotationsService.checkListenToEvents();
                     let rowNode = null;
@@ -893,7 +893,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     }
                     return returnAction;
                 }
-                case CommentsRedux.COMMENTS_LOAD: {
+                case CommentsRedux.COMMENTS_THREADS_LOAD: {
                     const previousCommentThreads = adaptable.api.commentApi.getAllComments();
                     let returnAction = next(action);
                     const newCommentThreads = adaptable.api.commentApi.getAllComments() ?? [];

package/src/Strategy/CommentModule.js

@@ -30,7 +30,9 @@ export class CommentModule extends AdaptableModuleBase {
         if (!this.api.commentApi.internalApi.areCommentsSupportedInLayout()) {
             return;
         }
-        if (menuContext.isRowGroupColumn || menuContext.isGroupedNode) {
+        if (menuContext.isRowGroupColumn ||
+            menuContext.isGroupedNode ||
+            !menuContext.isSingleSelectedCell) {
             return;
         }
         const items = [];

package/src/Strategy/FlashingCellModule.js

@@ -185,7 +185,7 @@ export class FlashingCellModule extends AdaptableModuleBase {
                             ColumnIds: [column.columnId],
                         },
                         Rule: {
-                            Predicates: [{ PredicateId: 'AnyChange' }],
+                            BooleanExpression: 'ANY_CHANGE([' + column.columnId + '])',
                         },
                     })),
                 ];
@@ -228,8 +228,8 @@ export class FlashingCellModule extends AdaptableModuleBase {
         const predicateDefHandlerContext = {
             value: dataChangedEvent.newValue,
             oldValue: dataChangedEvent.oldValue,
-            // TODO send real display value
-            displayValue: null,
+            rawValue: dataChangedEvent.newValue,
+            displayValue: dataChangedEvent.newValue,
             node: dataChangedEvent.rowNode,
             column: dataChangedEvent.column,
             ...this.api.internalApi.buildBaseContext(),

package/src/Strategy/LayoutModule.js

@@ -283,7 +283,8 @@ export class LayoutModule extends AdaptableModuleBase {
         };
         let columns = (layout.TableColumns || [])
             .filter((c) => !this.api.columnApi.isAutoRowGroupColumn(c))
-            .filter((c) => !this.api.columnApi.isPivotResultColumn(c));
+            .filter((c) => !this.api.columnApi.isPivotResultColumn(c))
+            .filter((c) => !this.api.columnApi.isSelectionColumn(c));
         if (columns.length >
             maxColumnsToDisplay + 1 /* +1 is to show tag only beginning with 2, 'other 2' */) {
             const extraColumns = columns.length - maxColumnsToDisplay;

package/src/Strategy/NoteModule.js

@@ -18,7 +18,9 @@ export class NoteModule extends AdaptableModuleBase {
         if (!this.api.noteApi.internalApi.areNotesSupported()) {
             return;
         }
-        if (menuContext.isRowGroupColumn || menuContext.isGroupedNode) {
+        if (menuContext.isRowGroupColumn ||
+            menuContext.isGroupedNode ||
+            !menuContext.isSingleSelectedCell) {
             return;
         }
         const isReadOnly = this.api.entitlementApi.getEntitlementAccessLevelForModule(this.moduleInfo.ModuleName) ===

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -642,7 +642,7 @@ export const scalarExpressionFunctions = {
         description: "Returns the percentage difference between a cell's current value and its previous value.",
         signatures: [
             'PERCENT_CHANGE( [colName], <INCREASE|DECREASE> )',
-            'PERCENT_CHANGE( COL(name: string), <INCREASE|DECREASE>)',
+            'PERCENT_CHANGE( COL(name: string), <INCREASE|DECREASE> )',
         ],
         examples: [
             'PERCENT_CHANGE([col1])',
@@ -662,11 +662,39 @@ export const scalarExpressionFunctions = {
                 throw new ExpressionEvaluationError('ABSOLUTE_CHANGE', 'First argument should be numeric');
             }
             const previousValue = context.dataChangedEvent.oldValue;
-            return currentValue - previousValue;
+            const increaseDecrease = args[1];
+            let result;
+            if (!increaseDecrease) {
+                result = sanitizeNumericResult(Math.abs(previousValue - currentValue));
+            }
+            else if (increaseDecrease === 'INCREASE') {
+                result =
+                    currentValue - previousValue > 0
+                        ? sanitizeNumericResult(currentValue - previousValue)
+                        : undefined;
+            }
+            else if (increaseDecrease === 'DECREASE') {
+                result =
+                    currentValue - previousValue < 0
+                        ? sanitizeNumericResult(previousValue - currentValue)
+                        : undefined;
+            }
+            else {
+                throw new ExpressionEvaluationError('ABSOLUTE_CHANGE', 'Optional second argument must be "INCREASE" or "DECREASE"');
+            }
+            return result;
         },
         description: "Returns the absolute difference between a cell's current value and its previous value.",
-        signatures: ['ABSOLUTE_CHANGE( [colName] )', 'ABSOLUTE_CHANGE( COL(name: string) )'],
-        examples: ['ABSOLUTE_CHANGE([col1])'],
+        signatures: [
+            'ABSOLUTE_CHANGE( [colName] )',
+            'ABSOLUTE_CHANGE( COL(name: string) )',
+            'ABSOLUTE_CHANGE( COL(name: string), <INCREASE|DECREASE> )',
+        ],
+        examples: [
+            'ABSOLUTE_CHANGE([col1])',
+            'ABSOLUTE_CHANGE([col1], "INCREASE")',
+            'ABSOLUTE_CHANGE([col1], "DECREASE")',
+        ],
         category: 'changes',
         returnType: 'number',
     },

package/src/Utilities/Services/ValidationService.js

@@ -81,6 +81,7 @@ export class ValidationService {
         const predicateDefHandlerContext = {
             value: dataChangedEvent.newValue,
             oldValue: dataChangedEvent.oldValue,
+            rawValue: dataChangedEvent.newValue,
             displayValue,
             node: dataChangedEvent.rowNode,
             column: dataChangedEvent.column,

package/src/Utilities/weightedAverage.d.ts

@@ -1,7 +1,7 @@
 import { IAggFuncParams } from 'ag-grid-enterprise';
 export declare const getNumericValue: (input: unknown) => number | null;
 export declare const weightedAverage: (params: IAggFuncParams, columnId: string, weightColumnId: string) => {
-    [x: string]: number | (() => number | "");
-    toString: () => number | "";
-    valueOf: () => number;
+    [x: string]: number | (() => string) | (() => number);
+    toString: () => string;
+    toNumber: () => number;
 };

package/src/Utilities/weightedAverage.js

@@ -6,12 +6,27 @@ export const getNumericValue = (input) => {
     const numericValue = toNumber(input);
     return isNaN(numericValue) ? null : numericValue;
 };
+function getWeightedAverageLeafNodes(gridApi, groupRowNode, filteredOnly) {
+    const nodeList = (filteredOnly ? groupRowNode.childrenAfterFilter : groupRowNode.childrenAfterGroup) ?? [];
+    let leafNodes = [];
+    nodeList.forEach((rowNode) => {
+        if (rowNode.group === true) {
+            // Recursively extract leaf nodes from group
+            leafNodes = leafNodes.concat(getWeightedAverageLeafNodes(gridApi, rowNode, filteredOnly));
+        }
+        else {
+            leafNodes.push(rowNode);
+        }
+    });
+    return leafNodes;
+}
 export const weightedAverage = (params, columnId, weightColumnId) => {
     const { api: gridApi, rowNode: groupRowNode } = params;
     let weightedColumnValueSum = 0;
     let columnValueSum = 0;
-    // TODO AFL: improve performance by using the intermediary aggregated values (for nested groups)
-    groupRowNode.allLeafChildren.forEach((rowNode) => {
+    const filteredOnly = !gridApi.getGridOption('suppressAggFilteredOnly');
+    const leafNodes = getWeightedAverageLeafNodes(gridApi, groupRowNode, filteredOnly);
+    leafNodes.forEach((rowNode) => {
         // when editing values might be converted to strings
         const rawColumnValue = gridApi.getCellValue({ colKey: columnId, rowNode });
         const columnValue = getNumericValue(rawColumnValue);
@@ -24,21 +39,19 @@ export const weightedAverage = (params, columnId, weightColumnId) => {
             columnValueSum += columnValue * weightedColumnValue;
         }
     });
+    let result = columnValueSum / weightedColumnValueSum;
+    // 0 / 0 = NaN
+    if (isNaN(result)) {
+        result = 0;
+    }
     return {
+        // the grid by default uses toString to render values for an object, so this
+        // is a trick to get the default cellRenderer to display the avg value
         toString: () => {
-            const result = columnValueSum / weightedColumnValueSum;
-            // 0 / 0 = NaN
-            if (isNaN(result)) {
-                return '';
-            }
-            return result;
+            return String(result);
         },
-        valueOf: () => {
-            const result = columnValueSum / weightedColumnValueSum;
-            // 0 / 0 = NaN
-            if (isNaN(result)) {
-                return 0;
-            }
+        // used for sorting
+        toNumber: function () {
             return result;
         },
         [columnId]: columnValueSum,

package/src/View/Alert/Wizard/AlertButtonsEditor.js

@@ -1,6 +1,5 @@
 import { Flex, Box, Text } from 'rebass';
 import * as React from 'react';
-import { sentenceCase } from 'sentence-case';
 import SimpleButton from '../../../components/SimpleButton';
 import Input from '../../../components/Input';
 import FormLayout, { FormRow } from '../../../components/FormLayout';
@@ -9,6 +8,26 @@ import { cloneObject } from '../../../Utilities/Helpers/Helper';
 import StringExtensions from '../../../Utilities/Extensions/StringExtensions';
 import { AdaptableIconSelector } from '../../Components/AdaptableIconSelector';
 import { Select } from '../../../components/Select';
+function renderCommand(command) {
+    switch (command) {
+        case 'highlight-cell':
+            return 'Highlight Cell';
+        case 'highlight-row':
+            return 'Highlight Row';
+        case 'jump-to-cell':
+            return 'Jump to Cell';
+        case 'jump-to-column':
+            return 'Jump to Column';
+        case 'jump-to-row':
+            return 'Jump to Row';
+        case 'suspend':
+            return 'Suspend';
+        case 'undo':
+            return 'Undo';
+        default:
+            return command;
+    }
+}
 const TONE_OPTIONS = [
     {
         label: 'Tone: Use Alert Tone',
@@ -73,6 +92,12 @@ export const AlertButtonsEditor = (props) => {
     if (hasSuspend) {
         buttonCommands.push('suspend');
     }
+    const commandHandlers = api.optionsApi.getAlertOptions().commandHandlers;
+    if (commandHandlers) {
+        commandHandlers.forEach((ch) => {
+            buttonCommands.push(ch.name);
+        });
+    }
     return (React.createElement(React.Fragment, null,
         React.createElement(Flex, { flexDirection: "row", alignItems: "center", justifyContent: "space-between" },
             React.createElement(Text, { fontSize: 2, mt: 3, mb: 2 }, "Add Buttons to the Alert Notification, and set Actions to perform when the Button is clicked"),
@@ -98,7 +123,7 @@ export const AlertButtonsEditor = (props) => {
                 btnCommands = button.Command;
             }
             // filter out the adaptable standard commands
-            const btnUserFunctions = btnCommands.filter((command) => !buttonCommands.includes(command));
+            // const btnUserFunctions = btnCommands.filter((command) => !buttonCommands.includes(command));
             const setVariant = (variant) => {
                 onChange(AlertButtons.map((btn, i) => {
                     if (i === index) {
@@ -197,19 +222,11 @@ export const AlertButtonsEditor = (props) => {
                             React.createElement(SimpleButton, { icon: "close", tone: "error", disabled: AlertButtons.length <= 1, marginLeft: 1, variant: "text", tooltip: AlertButtons.length <= 1 ? 'Cannot remove last button' : 'Remove button', onClick: () => {
                                     onChange(AlertButtons.filter((btn) => btn !== button));
                                 } }))),
-                    React.createElement(FormRow, { label: React.createElement(Text, { fontSize: 2 }, "Actions") },
-                        buttonCommands.map((commandName) => {
-                            return (React.createElement(CheckBox, { key: commandName, marginRight: 3, onChange: (checked) => handleCommandChange(checked, commandName), checked: button.Command === commandName ||
-                                    (Array.isArray(button.Command) && button.Command.includes(commandName)) },
-                                React.createElement(Text, { fontSize: 2 }, sentenceCase(commandName))));
-                        }),
-                        btnUserFunctions.length ? (React.createElement(CheckBox, { checked: true, disabled: true },
-                            React.createElement(Text, { fontSize: 2 },
-                                "User function",
-                                btnUserFunctions.length > 1 ? 's' : '',
-                                ":",
-                                ' ',
-                                btnUserFunctions.join(', ')))) : null),
+                    React.createElement(FormRow, { label: React.createElement(Text, { fontSize: 2 }, "Actions") }, buttonCommands.map((commandName) => {
+                        return (React.createElement(CheckBox, { key: commandName, marginRight: 3, onChange: (checked) => handleCommandChange(checked, commandName), checked: button.Command === commandName ||
+                                (Array.isArray(button.Command) && button.Command.includes(commandName)) },
+                            React.createElement(Text, { fontSize: 2 }, renderCommand(commandName))));
+                    })),
                     iconSelector && (React.createElement(FormRow, { label: React.createElement(Text, { fontSize: 2 }, "Icon") },
                         React.createElement(Box, null, iconSelector))))));
         })));

package/src/View/FormatColumn/Wizard/FormatColumnSettingsWizardSection.js

@@ -12,20 +12,20 @@ export const renderFormatColumnSettingsSummary = (data) => {
     return (React.createElement(Box, { padding: 2 },
         React.createElement(Text, null,
             "Cell alignment ",
-            React.createElement(Tag, null, data.CellAlignment ?? 'default')),
+            React.createElement(Tag, null, data.CellAlignment ?? 'Default')),
         React.createElement(Text, { mt: 3 },
             "Data Rows ",
-            React.createElement(Tag, null, data.RowScope?.ExcludeDataRows ? 'no' : 'yes')),
+            React.createElement(Tag, null, data.RowScope?.ExcludeDataRows ? 'No' : 'Yes')),
         ' ',
         React.createElement(Text, { mt: 3 },
             "Group Rows ",
-            React.createElement(Tag, null, data.RowScope?.ExcludeGroupRows ? 'no' : 'yes')),
+            React.createElement(Tag, null, data.RowScope?.ExcludeGroupRows ? 'No' : 'Yes')),
         React.createElement(Text, { mt: 3 },
             "Summary Rows ",
-            React.createElement(Tag, null, data.RowScope?.ExcludeSummaryRows ? 'no' : 'yes')),
+            React.createElement(Tag, null, data.RowScope?.ExcludeSummaryRows ? 'No' : 'Yes')),
         React.createElement(Text, { mt: 3 },
             "Total Rows ",
-            React.createElement(Tag, null, data.RowScope?.ExcludeTotalRows ? 'no' : 'yes')),
+            React.createElement(Tag, null, data.RowScope?.ExcludeTotalRows ? 'No' : 'Yes')),
         React.createElement(Text, { mt: 3 },
             "Apply on Column Groups:",
             ' ',

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

@@ -40,7 +40,8 @@ export const ColumnsSectionSummary = () => {
     const data = React.useMemo(() => {
         return ColumnIds.map((columnId) => {
             if (adaptable.api.columnApi.isPivotResultColumn(columnId) ||
-                adaptable.api.columnApi.isAutoRowGroupColumn(columnId)) {
+                adaptable.api.columnApi.isAutoRowGroupColumn(columnId) ||
+                adaptable.api.columnApi.isSelectionColumn(columnId)) {
                 return null;
             }
             const friendlyName = adaptable.api.columnApi.getFriendlyNameForColumnId(columnId, layout);

package/src/View/StateManagement/components/ExportDropdown.js

@@ -6,11 +6,11 @@ export const ExportDropdown = (props) => {
         switch (props.type) {
             case 'adaptableState':
                 const adaptableState = props.api.stateApi.getPersistentState();
-                handleExportState(destination, 'adaptableState', adaptableState);
+                handleExportState(destination, 'adaptableState', adaptableState, props.api);
                 break;
             case 'initialState':
                 const initialState = props.api.stateApi.getInitialState();
-                handleExportState(destination, 'initialState', initialState);
+                handleExportState(destination, 'initialState', initialState, props.api);
                 break;
         }
     };

package/src/View/StateManagement/handleExportState.d.ts

@@ -1 +1,2 @@
-export declare const handleExportState: (type: 'Clipboard' | 'Console' | 'JSON', name: 'adaptableState' | 'initialState', state: any) => void;
+import { AdaptableApi } from '../../types';
+export declare const handleExportState: (type: 'Clipboard' | 'Console' | 'JSON', name: 'adaptableState' | 'initialState', state: any, api: AdaptableApi) => void;

package/src/View/StateManagement/handleExportState.js

@@ -1,12 +1,12 @@
 import Helper from '../../Utilities/Helpers/Helper';
-export const handleExportState = (type, name, state) => {
+export const handleExportState = (type, name, state, api) => {
     switch (type) {
         case 'Clipboard':
             let stringifiedState = JSON.stringify(state);
             Helper.copyToClipboard(stringifiedState);
             break;
         case 'Console':
-            console.log('Adaptable State: ', state);
+            api.consoleLog('Adaptable State: ', state);
             break;
         case 'JSON':
             const jsonFileName = name + '.json';

package/src/agGrid/AdaptableAgGrid.js

@@ -1764,7 +1764,8 @@ You need to define at least one Layout!`);
         let _displayValue = defaults ? defaults.displayValue : undefined;
         let _normalisedValue = defaults ? defaults.normalisedValue : undefined;
         let _isRowGroupCell;
-        const _isPivotCell = this.api.columnApi.isPivotResultColumn(columnId);
+        const _isPivotCell = this.api.columnApi.isPivotResultColumn(columnId) ||
+            this.api.columnApi.isPivotAggColumnWithNoPivotColumns(columnId);
         const self = this;
         const api = this.api;
         const getRawValue = () => {