@adaptabletools/adaptable 22.0.0-canary.6 → 22.0.0-canary.8

package/src/View/Layout/TransposedPopup.js

@@ -5,72 +5,153 @@ import { useAdaptable } from '../AdaptableContext';
 import { ColumnSelector } from '../Components/Selectors/ColumnSelector';
 import { AdaptableAgGrid } from '../../agGrid/AdaptableAgGrid';
 import { Box, Flex } from '../../components/Flex';
-const adaptableContainerId = `transposed-adaptable-container`;
-const agGridContainerId = `transposed-adaptable-ag-grid-container`;
+import { ExportModuleId } from '../../Utilities/Constants/ModuleConstants';
+import StringExtensions from '../../Utilities/Extensions/StringExtensions';
+const ADAPTABLE_CONTAINER_ID = 'transposed-adaptable-container';
+const AG_GRID_CONTAINER_ID = 'transposed-adaptable-ag-grid-container';
+/** Field used for the first column in transposed grid (hidden, holds column id). */
+const TRANSPOSED_FIRST_COLUMN_FIELD = '_transposed_column_value';
+/** Header used for the first visible column in transposed grid (shows friendly name). */
+const TRANSPOSED_FIRST_COLUMN_HEADER = '_transposed_column_header';
+function buildTransposedAdaptableOptions({ hostOptions, transposedRowsAndColumns, currentTheme, }) {
+    return {
+        primaryKey: TRANSPOSED_FIRST_COLUMN_FIELD,
+        licenseKey: hostOptions.licenseKey,
+        userName: `${hostOptions.userName}`,
+        adaptableId: `${hostOptions.adaptableId}::TransposedView`,
+        containerOptions: {
+            adaptableContainer: ADAPTABLE_CONTAINER_ID,
+            agGridContainer: AG_GRID_CONTAINER_ID,
+        },
+        entitlementOptions: { defaultAccessLevel: 'Hidden' },
+        initialState: {
+            Layout: {
+                Revision: Date.now(),
+                CurrentLayout: 'TransposedView',
+                Layouts: [
+                    {
+                        Name: 'TransposedView',
+                        TableColumns: [
+                            TRANSPOSED_FIRST_COLUMN_HEADER,
+                            ...transposedRowsAndColumns.transposedColumns.map((c) => c.colId),
+                        ],
+                        ColumnPinning: { [TRANSPOSED_FIRST_COLUMN_HEADER]: 'left' },
+                        AutoSizeColumns: true,
+                    },
+                ],
+            },
+            Theme: { CurrentTheme: currentTheme },
+        },
+    };
+}
+function buildTransposedGridOptions({ transposedRowsAndColumns, elevatedColumnId, adaptableApi, }) {
+    const firstColumn = {
+        field: TRANSPOSED_FIRST_COLUMN_HEADER,
+        headerName: adaptableApi.columnApi.getFriendlyNameForColumnId(elevatedColumnId),
+    };
+    return {
+        loading: false,
+        defaultColDef: {
+            floatingFilter: false,
+            filter: false,
+            sortable: true,
+            resizable: true,
+            enableRowGroup: false,
+            editable: false,
+            enablePivot: false,
+            enableValue: false,
+            lockPinned: true,
+            menuTabs: [],
+            width: 120,
+        },
+        columnDefs: [
+            { field: TRANSPOSED_FIRST_COLUMN_FIELD, hide: true },
+            firstColumn,
+            ...transposedRowsAndColumns.transposedColumns.map((col) => ({ field: col.colId, headerName: col.header })),
+        ],
+        rowData: transposedRowsAndColumns.transposedRows,
+        sideBar: false,
+    };
+}
 export const TransposedPopup = (props) => {
     const adaptable = useAdaptable();
-    const { transposedColumnId, hideTransposedColumn, visibleColumns, visibleRows, autosize } = props.popupProps;
-    const rowNodes = React.useMemo(() => {
-        return props.popupProps.visibleRows
-            ? adaptable.api.gridApi.getVisibleRowNodes()
-            : adaptable.api.gridApi.getAllRowNodes();
-    }, [
-    // can be later triggered by tickng data
-    ]);
     const primaryKey = adaptable.api.optionsApi.getPrimaryKey();
-    const [syntheticTransposedByColumnId, doSetSyntheticTransposedByColumnId] = React.useState(transposedColumnId);
-    const setSyntheticTransposedByColumnId = (syntheticTransposedByColumnId) => {
+    const rawConfig = (props.popupProps ?? {});
+    const transposeConfig = {
+        transposedColumnId: rawConfig.transposedColumnId ?? primaryKey,
+        hideTransposedColumn: rawConfig.hideTransposedColumn ?? true,
+        autosize: rawConfig.autosize ?? true,
+        columnsToTranspose: rawConfig.columnsToTranspose,
+        rowsToTranspose: rawConfig.rowsToTranspose,
+    };
+    const rowNodes = React.useMemo(() => {
+        let transposableRowNodes = [];
+        const rowsToTranspose = transposeConfig.rowsToTranspose;
+        if (rowsToTranspose === 'VisibleOnly') {
+            return adaptable.api.gridApi.getVisibleRowNodes();
+        }
+        if (rowsToTranspose === 'All') {
+            return adaptable.api.gridApi.getAllRowNodes();
+        }
+        if (StringExtensions.IsNotNullOrEmpty(rowsToTranspose)) {
+            adaptable.api.gridApi.getAllRowNodes().forEach((rn) => {
+                const shouldTransposeRow = adaptable.api.internalApi
+                    .getQueryLanguageService()
+                    .evaluateBooleanExpression(rowsToTranspose, ExportModuleId, rn);
+                if (shouldTransposeRow) {
+                    transposableRowNodes.push(rn);
+                }
+            });
+            return transposableRowNodes;
+        }
+        return adaptable.api.gridApi.getAllRowNodes();
+    }, [transposeConfig.rowsToTranspose, adaptable.api]);
+    const [elevatedColumnId, setElevatedColumnIdState] = React.useState(() => transposeConfig.transposedColumnId ?? primaryKey);
+    const setElevatedColumnId = (newElevatedColumnId) => {
         transposedAdaptableApiRef.current?.destroy({ unmount: true, destroyAgGrid: true });
-        doSetSyntheticTransposedByColumnId(syntheticTransposedByColumnId);
+        setElevatedColumnIdState(newElevatedColumnId);
     };
     const transposedAdaptableApiRef = React.useRef(null);
     const columns = React.useMemo(() => {
-        // customisable
-        return visibleColumns
-            ? adaptable.api.columnApi.getVisibleColumns()
-            : adaptable.api.columnApi.getUIAvailableColumns();
-    }, []);
+        const allUIColumns = adaptable.api.columnApi.getUIAvailableColumns();
+        const columnsToTranspose = transposeConfig.columnsToTranspose;
+        if (!columnsToTranspose) {
+            return allUIColumns;
+        }
+        const columnIds = typeof columnsToTranspose === 'function'
+            ? columnsToTranspose({
+                ...adaptable.api.internalApi.buildBaseContext(),
+                columns: allUIColumns,
+            })
+            : columnsToTranspose;
+        return columnIds
+            .map((c) => adaptable.api.columnApi.getColumnWithColumnId(c))
+            .filter((col) => col != null);
+    }, [transposeConfig.columnsToTranspose, adaptable.api]);
     /**
-     * This is used as first field
+     * Build transposed structure: original rows become columns (colId = primaryKey value),
+     * original columns become rows. Each transposed row has the column id/header plus
+     * one cell per original row keyed by primaryKey value.
      */
-    const transposedFirstColumnField = '_transposed_column_value';
-    const transposedFirstColumnHeader = '_transposed_column_header';
     const transposedRowsAndColumns = React.useMemo(() => {
-        /**
-         * transposed column values become primaryKey of the new tarnsposed rows
-         * we build row by row, might be easer
-         */
         const transposedColumns = [];
         const transposedRows = [];
         for (const row of rowNodes) {
-            // we force the col-ids to be strings, easer to work with
-            //row[transposeByColumnId] + '';
             const colId = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, primaryKey) + '';
-            //row[synteticTransposedByColumnId] + '';
-            const header = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, syntheticTransposedByColumnId) +
-                '';
-            transposedColumns.push({
-                colId,
-                header,
-            });
+            const header = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, elevatedColumnId) + '';
+            transposedColumns.push({ colId, header });
         }
         for (const column of columns) {
-            /**
-             * We can hide the transposed column, if we want
-             */
-            if (hideTransposedColumn && column.columnId === syntheticTransposedByColumnId) {
+            if (transposeConfig.hideTransposedColumn &&
+                column.columnId === elevatedColumnId) {
                 continue;
             }
             const transposedRow = {
-                // [transposed-by-column-id]: [other column id],
-                // the value can be set to friendlyname
-                [transposedFirstColumnField]: column.columnId,
-                [transposedFirstColumnHeader]: column.friendlyName,
+                [TRANSPOSED_FIRST_COLUMN_FIELD]: column.columnId,
+                [TRANSPOSED_FIRST_COLUMN_HEADER]: column.friendlyName,
             };
-            for (let row of rowNodes) {
-                // [transposed-by-column-value[n]]: [other column value[n]]
+            for (const row of rowNodes) {
                 const key = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, primaryKey);
-                // row[column.field]
                 let value = adaptable.api.gridApi.getDisplayValueFromRowNode(row, column.columnId);
                 if (value instanceof Date) {
                     value = value.toLocaleString();
@@ -79,90 +160,25 @@ export const TransposedPopup = (props) => {
             }
             transposedRows.push(transposedRow);
         }
-        return {
-            transposedColumns,
-            transposedRows,
-        };
-    }, [rowNodes, primaryKey, syntheticTransposedByColumnId]);
+        return { transposedColumns, transposedRows };
+    }, [rowNodes, primaryKey, elevatedColumnId, columns, transposeConfig.hideTransposedColumn, adaptable.api]);
     React.useEffect(() => {
-        // Mounting in an effect, so the nodes are rendered/available
-        const hostAdaptableOptions = adaptable.adaptableOptions;
-        const adaptableOptions = {
-            primaryKey: transposedFirstColumnField,
-            licenseKey: hostAdaptableOptions.licenseKey,
-            userName: `${hostAdaptableOptions.userName}`,
-            adaptableId: `${hostAdaptableOptions.adaptableId}::TransposedView`,
-            containerOptions: {
-                adaptableContainer: adaptableContainerId,
-                agGridContainer: agGridContainerId,
-            },
-            entitlementOptions: {
-                defaultAccessLevel: 'Hidden',
-            },
-            initialState: {
-                Layout: {
-                    Revision: Date.now(),
-                    CurrentLayout: 'TransposedView',
-                    Layouts: [
-                        {
-                            Name: 'TransposedView',
-                            TableColumns: [
-                                transposedFirstColumnHeader,
-                                ...transposedRowsAndColumns.transposedColumns.map((c) => c.colId),
-                            ],
-                            ColumnPinning: {
-                                [transposedFirstColumnHeader]: 'left',
-                            },
-                            AutoSizeColumns: true,
-                        },
-                    ],
-                },
-                Theme: {
-                    CurrentTheme: adaptable.api.themeApi.getCurrentTheme(),
-                },
-            },
-        };
-        const firstColumn = {
-            field: transposedFirstColumnHeader, // use the column friendly name
-            headerName: adaptable.api.columnApi.getFriendlyNameForColumnId(syntheticTransposedByColumnId),
-        };
-        const agGridOptions = {
-            loading: false,
-            defaultColDef: {
-                floatingFilter: false,
-                filter: false,
-                sortable: true,
-                resizable: true,
-                enableRowGroup: false,
-                editable: false,
-                enablePivot: false,
-                enableValue: false,
-                lockPinned: true,
-                menuTabs: [],
-                width: 120,
-            },
-            columnDefs: [
-                {
-                    field: transposedFirstColumnField,
-                    hide: true,
-                },
-                firstColumn,
-                ...transposedRowsAndColumns.transposedColumns.map((col) => {
-                    return {
-                        field: col.colId,
-                        type: null,
-                        headerName: col.header,
-                    };
-                }),
-            ],
-            rowData: transposedRowsAndColumns.transposedRows,
-            sideBar: false,
-        };
+        const hostOptions = adaptable.adaptableOptions;
+        const adaptableOptions = buildTransposedAdaptableOptions({
+            hostOptions,
+            transposedRowsAndColumns,
+            currentTheme: adaptable.api.themeApi.getCurrentTheme(),
+        });
+        const gridOptions = buildTransposedGridOptions({
+            transposedRowsAndColumns,
+            elevatedColumnId,
+            adaptableApi: adaptable.api,
+        });
         const modules = adaptable.agGridModulesAdapter.getAgGridRegisteredModules();
         AdaptableAgGrid._initInternal({
             variant: 'vanilla',
             adaptableOptions,
-            gridOptions: agGridOptions,
+            gridOptions,
             modules,
         }).then((adaptableApi) => {
             transposedAdaptableApiRef.current = adaptableApi;
@@ -170,30 +186,20 @@ export const TransposedPopup = (props) => {
                 transposedAdaptableApiRef.current?.themeApi.loadTheme(typeof event.theme === 'object' ? event.theme.Name : event.theme);
             });
         });
-    }, [syntheticTransposedByColumnId]);
+    }, [elevatedColumnId, adaptable]);
     React.useEffect(() => {
-        // destroy when closing the popup
         return () => {
             requestAnimationFrame(() => {
                 transposedAdaptableApiRef.current?.destroy({ unmount: true, destroyAgGrid: true });
             });
         };
     }, []);
-    /**
-     * Need to get all data, manualy pivot the grid using the primary key.
-     *
-     * 1. get the data, and pivot using the primary key
-     * 2. create the col definitios, a col definition for each row
-     * 3. create the grid
-     */
     return (React.createElement(Flex, { flexDirection: "column", className: "twa:w-full twa:h-full" },
         React.createElement(Panel, null,
             React.createElement(FormLayout, null,
                 React.createElement(FormRow, { label: "Elevated Column" },
-                    React.createElement(ColumnSelector, { value: syntheticTransposedByColumnId, onChange: (colId) => {
-                            setSyntheticTransposedByColumnId(colId);
-                        } })))),
+                    React.createElement(ColumnSelector, { value: elevatedColumnId, onChange: setElevatedColumnId })))),
         React.createElement(Flex, { className: "twa:h-full" },
-            React.createElement(Box, { id: adaptableContainerId }),
-            React.createElement(Box, { className: "twa:h-full twa:w-full", id: agGridContainerId }))));
+            React.createElement(Box, { id: ADAPTABLE_CONTAINER_ID }),
+            React.createElement(Box, { className: "twa:h-full twa:w-full", id: AG_GRID_CONTAINER_ID }))));
 };

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

@@ -19,7 +19,7 @@ export const isAggregationsSectionValid = (data) => {
             AggFunc.type === 'weightedAverage')?.AggFunc
         : null;
     if (weightedAvg && !weightedAvg.weightedColumnId) {
-        return 'The Weighted Average Aggregation requires a Weighted Column';
+        return 'Weighted Average requires a weight column to be selected.';
     }
     return true;
 };

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

@@ -13,7 +13,7 @@ import { Box } from '../../../../components/Flex';
 export const isColumnFiltersValid = (layout) => {
     const invalidColumnFilters = (layout.ColumnFilters ?? [])?.filter((columnFilter) => !columnFilter?.Predicates[0]?.PredicateId);
     if (invalidColumnFilters.length > 0) {
-        return 'Please select a Predicate for each Column Filter';
+        return 'Please select a predicate for each column filter.';
     }
     return true;
 };

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

@@ -13,7 +13,7 @@ export const isGridFiltersValid = (layout, api) => {
         return true;
     }
     return (api.internalApi.getQueryLanguageService().validateBoolean(expression, GridFilterModuleId)
-        .isValid || 'Invalid Expression');
+        .isValid || 'The expression is not valid.');
 };
 export const GridFilterSectionSummary = () => {
     const { data: layout } = useOnePageAdaptableWizardContext();

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

@@ -216,7 +216,7 @@ export const isPivotAggregationsSectionValid = (data) => {
             .find((agg) => typeof agg === 'object' && agg.type === 'weightedAverage')
         : null;
     if (weightedAvg && !weightedAvg.weightedColumnId) {
-        return 'The Weighted Average Aggregation requires a Weighted Column';
+        return 'Weighted Average requires a weight column to be selected.';
     }
     return true;
 };
@@ -303,12 +303,12 @@ export const PivotAggregationsSection = (props) => {
         }
         const firstAggFuncName = getAggFuncName(aggregationColumns[0].AggFunc);
         if (layout.PivotAggregationColumns?.some((aggCol) => getAggFuncName(aggCol.AggFunc) !== firstAggFuncName)) {
-            return 'Requires identical aggregation on all columns';
+            return 'All columns must use the same aggregation function.';
         }
         // check that no Aggregation Total Column is enabled
         const hasAggregationTotalColumn = aggregationColumns.some((aggCol) => aggCol.Total !== false && aggCol.Total != null);
         if (hasAggregationTotalColumn) {
-            return 'Can only be enabled when no Aggregation Total Column is present';
+            return 'This option is not available when an Aggregation Total Column is present.';
         }
         return true;
     };

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

@@ -24,7 +24,7 @@ export const areSummaryRowsValid = (layout) => {
     layout.RowSummaries?.find((rowSummary) => {
         for (const [_, fn] of Object.entries(rowSummary.ColumnsMap ?? {})) {
             if (!fn) {
-                valid = 'All row summary columns must have an aggregation function.';
+                valid = 'Each row summary column requires an aggregation function.';
                 return true;
             }
         }

package/src/View/NamedQuery/Wizard/NamedQueryExpressionWizardSection.js

@@ -7,11 +7,11 @@ import { useOnePageAdaptableWizardContext } from '../../Wizard/OnePageAdaptableW
 import { Box } from '../../../components/Flex';
 export const isValidNamedQueryExpression = (data, api) => {
     if (!data.BooleanExpression) {
-        return 'Expression is empty';
+        return 'An expression is required.';
     }
     const valid = api.expressionApi.isValidBooleanExpression(data.BooleanExpression, NamedQueryModuleId);
     if (!valid) {
-        return 'Query is not a valid Boolean Query';
+        return 'The query is not a valid Boolean expression.';
     }
     return valid;
 };

package/src/View/PlusMinus/Wizard/PlusMinusSettingsWizardSection.js

@@ -24,16 +24,16 @@ export const PlusMinusSettingsSummary = (props) => {
 };
 export const isSettingsValid = (hasCondition) => (data, api, context) => {
     if (!data.Name?.trim()) {
-        return 'Name is required';
+        return 'A name is required.';
     }
     const allPlusMinusNudges = api.plusMinusApi.getAllPlusMinus();
     const isDuplicateName = allPlusMinusNudges.some((nudge) => nudge.Name === data.Name && nudge.Uuid !== data.Uuid);
     if (isDuplicateName) {
-        return 'A Plus Minus Nudge already exists with that name';
+        return 'A Plus/Minus Nudge with this name already exists.';
     }
     if (hasCondition) {
         if (!data?.Rule?.BooleanExpression) {
-            return 'No valid Rule is specified';
+            return 'A valid rule is required.';
         }
         const ruleValidation = isAdaptableRuleValid(data, api, context);
         if (typeof ruleValidation === 'string') {
@@ -41,10 +41,10 @@ export const isSettingsValid = (hasCondition) => (data, api, context) => {
         }
     }
     if (typeof data.NudgeValue !== 'number') {
-        return 'Nudge value is not specified';
+        return 'A nudge value is required.';
     }
     if (data.NudgeValue === 0) {
-        return 'Nudge value must be different than 0';
+        return 'Nudge value must not be zero.';
     }
     return true;
 };

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

@@ -53,7 +53,7 @@ export const ScheduleSettingsReminder = (props) => {
             React.createElement(Tabs.Content, null,
                 React.createElement(FormLayout, null,
                     React.createElement(FormRow, { label: "Name" },
-                        React.createElement(Input, { "data-name": "schedule-name", className: "twa:w-[300px]", onChange: handleNameChange, placeholder: "Enter Schedule Name", type: "string", value: props.reminderSchedule?.Name ?? '' })),
+                        React.createElement(Input, { "data-name": "schedule-name", className: "twa:w-[300px]", onChange: handleNameChange, placeholder: "Enter Reminder Name", type: "string", value: props.reminderSchedule?.Name ?? '' })),
                     React.createElement(FormRow, { label: "" },
                         React.createElement(Box, { className: "twa:h-2" })),
                     React.createElement(FormRow, { label: "Header" },

package/src/View/Schedule/Wizard/ScheduleSettingsWizard/isSettingsValid.d.ts

@@ -1,3 +1,3 @@
 import { AdaptableApi } from '../../../../Api/AdaptableApi';
 import { BaseSchedule } from '../../../../AdaptableState/Common/Schedule';
-export declare const isSettingsValid: (schedule: BaseSchedule, api: AdaptableApi) => true | "Name is required" | "A Schedule with this name already exists" | "Message type not selected" | "Reminder header not specified" | "Reminder message not specified" | "Report source not specified" | "Report format not selected" | "Report not selected" | "Report folder not selected" | "Report page not selected";
+export declare const isSettingsValid: (schedule: BaseSchedule, api: AdaptableApi) => true | "A name is required." | "A Schedule with this name already exists." | "Please select a message type." | "A reminder header is required." | "A reminder message is required." | "Please select a report." | "Please select a report format." | "Please select a report folder." | "Please select a report page.";

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

@@ -3,50 +3,50 @@ import StringExtensions from '../../../../Utilities/Extensions/StringExtensions'
 export const isSettingsValid = (schedule, api) => {
     // Validate Name - mandatory and unique
     if (!schedule.Name?.trim()) {
-        return 'Name is required';
+        return 'A name is required.';
     }
     const allSchedules = api.scheduleApi.getSchedules();
     const isDuplicateName = allSchedules.some((s) => s.Name === schedule.Name && s.Uuid !== schedule.Uuid);
     if (isDuplicateName) {
-        return 'A Schedule with this name already exists';
+        return 'A Schedule with this name already exists.';
     }
     if (schedule.ScheduleType === ScheduleType.Reminder) {
         const reminder = schedule;
         if (!reminder.MessageType) {
-            return 'Message type not selected';
+            return 'Please select a message type.';
         }
         if (StringExtensions.IsNullOrEmpty(reminder?.Header)) {
-            return 'Reminder header not specified';
+            return 'A reminder header is required.';
         }
         if (StringExtensions.IsNullOrEmpty(reminder?.Message)) {
-            return 'Reminder message not specified';
+            return 'A reminder message is required.';
         }
     }
     if (schedule.ScheduleType === ScheduleType.Report) {
         const report = schedule;
         if (StringExtensions.IsNullOrEmpty(report?.ReportName)) {
-            return 'Report source not specified';
+            return 'Please select a report.';
         }
         if (StringExtensions.IsNullOrEmpty(report?.ReportFormat)) {
-            return 'Report format not selected';
+            return 'Please select a report format.';
         }
     }
     if (schedule.ScheduleType === ScheduleType.ipushpull) {
         const ipushpull = schedule;
         if (StringExtensions.IsNullOrEmpty(ipushpull?.IPushPullReport?.ReportName)) {
-            return 'Report not selected';
+            return 'Please select a report.';
         }
         if (StringExtensions.IsNullOrEmpty(ipushpull?.IPushPullReport?.Folder)) {
-            return 'Report folder not selected';
+            return 'Please select a report folder.';
         }
         if (StringExtensions.IsNullOrEmpty(ipushpull?.IPushPullReport?.Page)) {
-            return 'Report page not selected';
+            return 'Please select a report page.';
         }
     }
     if (schedule.ScheduleType === ScheduleType.OpenFin) {
         const openfin = schedule;
         if (StringExtensions.IsNullOrEmpty(openfin?.OpenFinReport?.ReportName)) {
-            return 'Report not selected';
+            return 'Please select a report.';
         }
     }
     return true;

package/src/View/StateManagement/handleExportState.js

@@ -6,7 +6,7 @@ export const handleExportState = (type, name, state, api) => {
             Helper.copyToClipboard(stringifiedState);
             break;
         case 'Console':
-            api.consoleLog('Adaptable State: ', state);
+            api.consoleLog('Adaptable state:', state);
             break;
         case 'JSON':
             const jsonFileName = name + '.json';

package/src/View/StyledColumn/Wizard/StyledColumnWizardColumnSection.js

@@ -15,7 +15,7 @@ export const renderStyledColumnColumnSummary = (data) => {
 };
 export const isValidStyledColumnColumn = (data) => {
     if (!data.ColumnId) {
-        return 'You have to select a Column for Styled Column';
+        return 'Please select a column for the Styled Column.';
     }
     return true;
 };

package/src/View/UIHelper.d.ts

@@ -6,6 +6,7 @@ import { Schedule, Weekday } from '../AdaptableState/Common/Schedule';
 import { AdaptableColumnDataType, AdaptableSystemIconName, AdaptableOptions } from '../types';
 import { AdaptableAlert } from '../AdaptableState/Common/AdaptableAlert';
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
+import type { ContainerContext } from '../AdaptableOptions/ContainerOptions';
 export declare const BLACK: string;
 export declare const WHITE: string;
 export declare const LIGHT_GRAY: string;
@@ -31,7 +32,7 @@ export declare function getDefaultColors(): string[];
 export declare function getEmptyConfigState(): EditableConfigEntityState;
 export declare function getDescriptionForDataType(dataType: AdaptableColumnDataType): "text" | "number" | "date";
 export declare function getPlaceholderForDataType(dataType: AdaptableColumnDataType): "Enter Value" | "Enter Number" | "Enter Date";
-export declare function getModalContainer(adaptableOptions: AdaptableOptions, document: Document): HTMLElement;
+export declare function getModalContainer(adaptableOptions: AdaptableOptions, document: Document, context?: ContainerContext): HTMLElement;
 export declare function IsEmptyStyle(style: AdaptableStyle): boolean;
 export declare function IsNotEmptyStyle(style: AdaptableStyle): boolean;
 export declare function getMessageTypeByStatusColour(statusColour: StatusColour): AdaptableMessageType;

package/src/View/UIHelper.js

@@ -2,6 +2,7 @@ import { WizardStatus, } from './Components/SharedProps/EditableConfigEntityStat
 import { FontWeight, FontStyle, StatusColour } from '../AdaptableState/Common/Enums';
 import { StringExtensions } from '../Utilities/Extensions/StringExtensions';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
+import { resolveContainerElement } from '../Utilities/resolveContainerElement';
 export const BLACK = 'Black';
 export const WHITE = 'White';
 export const LIGHT_GRAY = 'LightGray';
@@ -120,19 +121,12 @@ export function getPlaceholderForDataType(dataType) {
             return 'Enter Date';
     }
 }
-export function getModalContainer(adaptableOptions, document) {
-    let modalContainer;
-    if (adaptableOptions.containerOptions.modalContainer) {
-        // this has been set, so we use the property
-        modalContainer =
-            typeof adaptableOptions.containerOptions.modalContainer === 'string'
-                ? document.getElementById(adaptableOptions.containerOptions.modalContainer)
-                : adaptableOptions.containerOptions.modalContainer;
-        if (modalContainer) {
-            const modalContainerClassName = ' modal-container';
-            if (!modalContainer.className.includes(modalContainerClassName)) {
-                modalContainer.className += modalContainerClassName;
-            }
+export function getModalContainer(adaptableOptions, document, context) {
+    let modalContainer = resolveContainerElement(adaptableOptions.containerOptions.modalContainer, context, document);
+    if (modalContainer) {
+        const modalContainerClassName = ' modal-container';
+        if (!modalContainer.className.includes(modalContainerClassName)) {
+            modalContainer.className += modalContainerClassName;
         }
     }
     if (!modalContainer) {
@@ -423,7 +417,7 @@ export function getAdaptableToolPanelWidth() {
     return getNumericCSSVariableValue(getCSSVariableValue('--ab-cmp-toolpanel__width'), 200);
 }
 export function getSimpleButtonPaddingWidth() {
-    return getNumericCSSVariableValue(getCSSVariableValue('--ab-space-1'), 4);
+    return getNumericCSSVariableValue(getCSSVariableValue('--ab-base-space'), 4);
 }
 export function getCSSVariableValue(cssVariable) {
     if (!isBrowserDocumentAvailable()) {