@adaptabletools/adaptable-cjs 22.0.0-canary.5 → 22.0.0-canary.7

package/src/Utilities/Services/ThemeService.js

@@ -73,15 +73,11 @@ class ThemeService {
             return val;
         });
         if (abLoaded !== '777') {
-            logger.consoleError('Please import Adaptable styles from "@adaptabletools/adaptable/index.css"');
+            logger.consoleError('Adaptable styles not detected. Please import "@adaptabletools/adaptable/index.css".');
         }
         const isCustomUserTheme = !this.api.themeApi.internalApi.isSystemTheme(themeName);
         if (!isCustomUserTheme && abThemeLoaded !== themeName) {
-            logger.consoleWarn(`Theme "${themeName}" doesn't seem to be loaded! Make sure you import the css file for the "${themeName}" theme!
-
-If it's an AdapTable system theme, try
-
-import "@adaptabletools/adaptable/themes/${themeName}.css"`);
+            logger.consoleWarn(`Theme "${themeName}" does not appear to be loaded. Ensure the CSS file is imported, e.g.: import "@adaptabletools/adaptable/themes/${themeName}.css".`);
         }
     }
     // prefers-color-scheme

package/src/Utilities/Services/ValidationService.js

@@ -57,7 +57,7 @@ class ValidationService {
             let alert = {
                 alertType: 'cellChanged',
                 header: 'Alert',
-                message: 'Perform Edit Alert Fired',
+                message: 'A validation rule was triggered for this edit.',
                 alertDefinition: failedRules[0],
                 cellDataChangedInfo: cellDataChangedInfo,
             };

package/src/Utilities/logDeprecation.js

@@ -14,16 +14,15 @@ const doOnce = (func, key) => {
 };
 const logDeprecation = (logger, typeName, oldProp, newProp, message) => {
     const newPropMsg = newProp ? `Please use '${typeName}.${newProp}()' instead. ` : '';
-    doOnce(() => logger.consoleWarn(`'${typeName}.${oldProp}()' is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
+    doOnce(() => logger.consoleWarn(`${typeName}.${oldProp}() is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
 };
 exports.logDeprecation = logDeprecation;
 const logDeprecationExternal = (logger, oldTypeName, oldProp, newTypeName, newProp, message) => {
     const newPropMsg = newProp ? `Please use '${newTypeName}.${newProp}()' instead. ` : '';
-    doOnce(() => logger.consoleWarn(`'${oldTypeName}.${oldProp}()' is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
+    doOnce(() => logger.consoleWarn(`${oldTypeName}.${oldProp}() is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
 };
 exports.logDeprecationExternal = logDeprecationExternal;
 const logDeprecationInternal = (logger, typeName, oldProp) => {
-    doOnce(() => logger.consoleWarn(`'${typeName}.${oldProp}()' is deprecated. The method will be removed in the next major release.
-        Please contact support if you need the missing functionality.`), `Deprecated_${oldProp}`);
+    doOnce(() => logger.consoleWarn(`${typeName}.${oldProp}() is deprecated and will be removed in the next major release. Contact support if you need this functionality.`), `Deprecated_${oldProp}`);
 };
 exports.logDeprecationInternal = logDeprecationInternal;

package/src/View/Alert/Utilities/getDefaultAlertDefinition.d.ts

@@ -6,6 +6,7 @@ import { AlertType } from './getAlertType';
  */
 export declare const getDefaultAlertDefinition: (alertDefinition: AlertDefinition, type: AlertType) => {
     Uuid: string;
+    Name: string;
     Scope: import("../../../types").ColumnScope;
     Rule: import("../../../types").AlertRule;
     MessageType: import("../../../types").AdaptableMessageType;
@@ -13,11 +14,10 @@ export declare const getDefaultAlertDefinition: (alertDefinition: AlertDefinitio
     MessageText?: string;
     AlertProperties?: import("../../../types").AlertProperties;
     AlertForm?: string | import("../../../types").AlertButtonForm;
-    Name: string;
+    IsSuspended?: boolean;
     Source?: "InitialState" | "User";
     AdaptableVersion?: import("../../../types").AdaptableVersion;
     IsReadOnly?: boolean;
     Tags?: import("../../../types").AdaptableObjectTag[];
     Metadata?: any;
-    IsSuspended?: boolean;
 };

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

@@ -7,7 +7,7 @@ const isValidAlertRules = (alert, api, context) => {
         !alert.Rule.BooleanExpression &&
         !alert.Rule.ObservableExpression &&
         !alert.Rule.AggregatedBooleanExpression) {
-        return 'No Rule defined for Alert';
+        return 'A rule is required for the Alert.';
     }
     const isRuleValid = (0, Utilities_1.isAdaptableRuleValid)(alert, api, context);
     if (typeof isRuleValid === 'string') {

package/src/View/CalculatedColumn/Wizard/CalculatedColumnDefinitionWizardSection.js

@@ -26,11 +26,11 @@ exports.renderCalculatedColumnDefinitionSummary = renderCalculatedColumnDefiniti
 const isValidCalculatedColumnDefinition = (data, api) => {
     const columns = api.columnApi.getColumns();
     if (!data.ColumnId) {
-        return 'Column Id cannot be empty';
+        return 'A Column ID is required.';
     }
     const columnsWithSameIdCount = columns.filter((c) => c.columnId === data.ColumnId).length;
     const hasAlreadyExistingId = data.Uuid ? columnsWithSameIdCount > 1 : columnsWithSameIdCount > 0;
-    return hasAlreadyExistingId ? 'A Column already exists with that id' : true;
+    return hasAlreadyExistingId ? 'A column with this ID already exists.' : true;
 };
 exports.isValidCalculatedColumnDefinition = isValidCalculatedColumnDefinition;
 const CalculatedColumnDefinitionWizardSection = (props) => {

package/src/View/CalculatedColumn/Wizard/CalculatedColumnExpressionWizardSection.js

@@ -22,11 +22,11 @@ const isValidCalculatedColumnExpression = (data, api) => {
     const calculatedColumnExpressionService = api.internalApi.getCalculatedColumnExpressionService();
     const expression = api.expressionApi.getAdaptableQueryExpression(data.Query)?.trim();
     if (!expression) {
-        return 'Calculated Column Expression cannot be empty';
+        return 'An expression is required for the Calculated Column.';
     }
     const isValid = calculatedColumnExpressionService.isCalculatedColumnQueryValid(data.Query);
     if (!isValid) {
-        return 'Calculated Column Expression is not valid';
+        return 'The Calculated Column expression is not valid.';
     }
     return true;
 };

package/src/View/CalculatedColumn/Wizard/CalculatedColumnSettingsWizardSection.js

@@ -21,7 +21,7 @@ const renderCalculatedColumnSettingsSummary = (data) => {
 exports.renderCalculatedColumnSettingsSummary = renderCalculatedColumnSettingsSummary;
 const isValidCalculatedColumnSettings = (data) => {
     if (!data.CalculatedColumnSettings?.DataType) {
-        return 'No data type is specified and it could not be inferred from the defined expression';
+        return 'A data type is required. It could not be inferred from the expression.';
     }
     return true;
 };

package/src/View/Charting/ChartingWizard/AgChargingWizard/SettingsSection.js

@@ -9,12 +9,12 @@ const FormLayout_1 = tslib_1.__importStar(require("../../../../components/FormLa
 const AdaptableInput_1 = tslib_1.__importDefault(require("../../../Components/AdaptableInput"));
 const isSettingsValid = (chartDefinition, api) => {
     if (!chartDefinition.Name) {
-        return 'Name is mandatory';
+        return 'A name is required.';
     }
     const allChartDefinitions = api.chartingApi.getChartDefinitions();
     if (allChartDefinitions.some((chartDefinitionLoopItem) => chartDefinitionLoopItem.Uuid !== chartDefinition.Uuid &&
         chartDefinitionLoopItem.Name === chartDefinition.Name)) {
-        return 'There is already a chart with this name';
+        return 'A Chart with this name already exists.';
     }
     return true;
 };

package/src/View/Charting/ChartingWizard/ExternalChartingWizard/SettingsSection.js

@@ -7,12 +7,12 @@ const FormLayout_1 = tslib_1.__importStar(require("../../../../components/FormLa
 const AdaptableInput_1 = tslib_1.__importDefault(require("../../../Components/AdaptableInput"));
 const isSettingsValid = (chartDefinition, api) => {
     if (!chartDefinition.Name) {
-        return 'Name is mandatory';
+        return 'A name is required.';
     }
     const allChartDefinitions = api.chartingApi.getExternalChartDefinitions();
     if (allChartDefinitions.some((chartDefinitionLoopItem) => chartDefinitionLoopItem.Uuid !== chartDefinition.Uuid &&
         chartDefinitionLoopItem.Name === chartDefinition.Name)) {
-        return 'There is already a chart with this name';
+        return 'A Chart with this name already exists.';
     }
     return true;
 };

package/src/View/Components/CellPopup/index.js

@@ -36,7 +36,7 @@ exports.CellPopup = React.forwardRef((props, ref) => {
         const cellSelector = `[row-id="${props.primaryKeyValue}"] [col-id="${props.columnId}"]`;
         const alignTo = document.querySelector(cellSelector);
         if (!alignTo) {
-            adaptable.logger.consoleError(`Could not find cell with selector ${cellSelector} to show popup`);
+            adaptable.logger.consoleError(`Cell not found for selector "${cellSelector}". Unable to display popup.`);
             return;
         }
         const showOverlayOptions = {

package/src/View/Components/ColumnFilter/FloatingFilter.js

@@ -41,11 +41,19 @@ const FloatingFilter = (props) => {
     const handleClear = () => props.onClear?.();
     const showEvent = 'click';
     const hideEvent = 'blur';
+    const [overlayVisible, setOverlayVisible] = React.useState(false);
     let filterDropdown = null;
-    let filterDropdownButton = (React.createElement(SimpleButton_1.default, { variant: "text", "data-name": "floating-filter-button", "data-value": props.predicate?.args[0]?.operator, onClick: () => {
+    const filterDropdownButton = (React.createElement(SimpleButton_1.default, { variant: "text", "data-name": "floating-filter-button", onBlur: () => {
+            if (isInlineEditable) {
+                setOverlayVisible(false);
+            }
+        }, "data-value": props.predicate?.args[0]?.operator, onClick: () => {
             if (!isInlineEditable) {
                 adaptable.api.filterApi.columnFilterApi.internalApi.openColumnFilterPopup(props.columnId);
             }
+            else {
+                setOverlayVisible(true);
+            }
         }, style: {
             textAlign: 'left',
             marginRight: 1, // just so that the focus outline is not cut off
@@ -59,9 +67,10 @@ const FloatingFilter = (props) => {
         React.createElement(Flex_1.Box, null, !isManualApply && singleFilterPredicateDef?.icon ? (singleFilterPredicateDef?.icon) : (React.createElement(AdaptableIconComponent_1.AdaptableIconComponent, { icon: { name: 'filter' } }))),
         showLabel && (React.createElement(Flex_1.Box, { className: "ab-FloatingFilter-label twa:ml-2 twa:flex-1", title: label }, label))));
     if (isInlineEditable) {
-        filterDropdown = showQuickFilterDropdown && (React.createElement(OverlayTrigger_1.default, { className: "ab-FloatingFilter-overlay", showEvent: showEvent, hideEvent: hideEvent, preventPortalEventPropagation: showEvent === 'click', targetOffset: 10, hideDelay: 50, "data-name": "floating-filter-overlay", render: () => {
+        filterDropdown = showQuickFilterDropdown && (React.createElement(OverlayTrigger_1.default, { className: "ab-FloatingFilter-overlay", showEvent: showEvent, hideEvent: hideEvent, visible: overlayVisible, onVisibleChange: setOverlayVisible, preventPortalEventPropagation: showEvent === 'click', targetOffset: 10, hideDelay: 50, "data-name": "floating-filter-overlay", render: () => {
                 // we render this only for single filter
                 return (React.createElement(ColumnFilterMenu_1.ColumnFilterMenu, { columnId: props.columnId, disabled: props.disabled, predicate: props.predicate.args[0], predicateDefs: props.predicateDefs, onPredicateChange: (predicate) => {
+                        setOverlayVisible(false);
                         props.onPredicateChange({
                             operator: props.predicate.operator,
                             args: [predicate],
@@ -72,7 +81,36 @@ const FloatingFilter = (props) => {
     else {
         filterDropdown = filterDropdownButton;
     }
-    return (React.createElement(Flex_1.Flex, { className: "ab-FloatingFilter twa:w-full" },
+    return (React.createElement(Flex_1.Flex, { className: "ab-FloatingFilter twa:w-full", onKeyDownCapture: (e) => {
+            // AG Grid's header keyboard navigation intercepts Tab and calls preventDefault(),
+            // which prevents focus from moving between elements inside the floating filter.
+            // We handle Tab manually in the capture phase (before AG Grid's handlers).
+            if (e.key === 'Tab') {
+                const target = e.target;
+                const wrapper = e.currentTarget;
+                if (!e.shiftKey) {
+                    // Tab forward: from filter button → select input
+                    if (target.getAttribute('data-name') === 'floating-filter-button') {
+                        const selectInput = wrapper.querySelector('[data-name="Select Values"] input');
+                        if (selectInput) {
+                            e.preventDefault();
+                            e.nativeEvent.stopImmediatePropagation();
+                            selectInput.focus();
+                            // When the DummyInput gets focus, react-select sets isFocused=true,
+                            // triggering a React re-render. During this re-render, unstable component
+                            // references in selectComponents can cause the DummyInput to be removed
+                            // from DOM and recreated, losing focus. We restore focus after the re-render.
+                            requestAnimationFrame(() => {
+                                if (document.activeElement === document.body || document.activeElement === null) {
+                                    const newInput = wrapper.querySelector('[data-name="Select Values"] input');
+                                    newInput?.focus();
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        } },
         filterDropdown,
         isInlineEditable && (React.createElement(Flex_1.Flex, { className: "twa:flex-1 twa:min-w-0" },
             React.createElement(FloatingFilterInputList_1.FloatingFilterInputList, { onKeyDown: props.onKeydown, columnId: props.columnId, disabled: props.disabled, 

package/src/View/Components/ColumnFilter/components/ColumnFilterMenu.js

@@ -6,17 +6,69 @@ const React = tslib_1.__importStar(require("react"));
 const Panel_1 = tslib_1.__importDefault(require("../../../../components/Panel"));
 const SimpleButton_1 = tslib_1.__importDefault(require("../../../../components/SimpleButton"));
 const Flex_1 = require("../../../../components/Flex");
+const clsx_1 = tslib_1.__importDefault(require("clsx"));
+const react_1 = require("react");
 const ColumnFilterMenuItem = ({ active, onClick, icon, label, }) => {
     return (React.createElement(SimpleButton_1.default, { className: "twa:p-1 twa:w-full", variant: "text", tone: active ? 'info' : 'none', onClick: onClick },
         React.createElement(Flex_1.Box, { className: "twa:mr-2" }, icon),
         React.createElement(Flex_1.Box, { className: "twa:text-2" }, label)));
 };
 const ColumnFilterMenu = (props) => {
+    const [activeIndex, setActiveIndex] = React.useState(() => {
+        const index = props.predicateDefs.findIndex((predicateDef) => predicateDef.operator === props.predicate.operator);
+        return index === -1 ? 0 : index;
+    });
+    const activeIndexRef = React.useRef(activeIndex);
+    const onPredicateChangeRef = React.useRef(props.onPredicateChange);
+    const predicateDefsRef = React.useRef(props.predicateDefs);
+    (0, react_1.useLayoutEffect)(() => {
+        activeIndexRef.current = activeIndex;
+        onPredicateChangeRef.current = props.onPredicateChange;
+        predicateDefsRef.current = props.predicateDefs;
+    });
+    const confirm = React.useCallback((predicateDef) => {
+        onPredicateChangeRef.current({ operator: predicateDef.operator, args: [] });
+    }, []);
+    (0, react_1.useEffect)(() => {
+        const onKeyDown = (e) => {
+            // Only handle arrow keys and Enter - let other keys (like Tab) pass through
+            if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp' && e.key !== 'Enter') {
+                return;
+            }
+            const activeIndex = activeIndexRef.current;
+            const predicateDefs = predicateDefsRef.current;
+            if (e.key === 'Enter') {
+                const predicateDef = predicateDefs[activeIndex];
+                if (predicateDef) {
+                    confirm(predicateDef);
+                }
+            }
+            e.stopPropagation();
+            e.preventDefault();
+            const dir = e.key === 'ArrowDown' ? 1 : e.key === 'ArrowUp' ? -1 : 0;
+            if (dir) {
+                let nextIndex = activeIndex + dir;
+                if (nextIndex < 0) {
+                    nextIndex = predicateDefs.length - 1;
+                }
+                else if (nextIndex >= predicateDefs.length) {
+                    nextIndex = 0;
+                }
+                setActiveIndex(nextIndex);
+            }
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => {
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [confirm]);
     return (React.createElement(Panel_1.default, { className: "twa:min-w-max" }, props.predicateDefs?.map((predicateDef, index) => {
-        return (React.createElement(Flex_1.Flex, { className: "twa:mb-1", key: index, onMouseDownCapture: (e) => {
+        const active = activeIndex === index;
+        return (React.createElement(Flex_1.Flex, { className: (0, clsx_1.default)("twa:mb-1", active && "twa:bg-primarylight"), key: index, onMouseDownCapture: (e) => {
                 e.stopPropagation();
+                e.preventDefault();
             } },
-            React.createElement(ColumnFilterMenuItem, { onClick: () => props.onPredicateChange({ operator: predicateDef.operator, args: [] }), icon: predicateDef.icon, label: predicateDef.label, active: props.predicate.operator === predicateDef.operator })));
+            React.createElement(ColumnFilterMenuItem, { onClick: () => confirm(predicateDef), icon: predicateDef.icon, label: predicateDef.label, active: active })));
     })));
 };
 exports.ColumnFilterMenu = ColumnFilterMenu;

package/src/View/Components/EntityRulesEditor/Utilities.js

@@ -4,28 +4,28 @@ exports.isAdaptableRuleValid = void 0;
 const isAdaptableRuleValid = (abObject, api, context) => {
     if (abObject?.Rule?.Predicates?.length) {
         if (!api.predicateApi.isEveryPredicateValid(abObject?.Rule?.Predicates)) {
-            return `The Predicate${abObject?.Rule?.Predicates?.length === 1 ? ' is' : 's are'} not valid`;
+            return `The predicate${abObject?.Rule?.Predicates?.length === 1 ? ' is' : 's are'} not valid.`;
         }
     }
     if (abObject?.Rule?.BooleanExpression) {
         if (!api.expressionApi.isValidBooleanExpression(abObject?.Rule?.BooleanExpression, context.moduleInfo.ModuleName)) {
-            return 'The Expression is not a valid Boolean Expression';
+            return 'The Boolean expression is not valid.';
         }
     }
     if (abObject?.Rule?.ObservableExpression) {
         if (!api.expressionApi.isValidObservableExpression(abObject?.Rule?.ObservableExpression, context.moduleInfo.ModuleName)) {
-            return 'The Expression is not a valid Observable Expression';
+            return 'The Observable expression is not valid.';
         }
     }
     if (abObject?.Rule?.AggregatedBooleanExpression) {
         if (!api.expressionApi.isValidAggregatedBooleanExpression(abObject?.Rule?.AggregatedBooleanExpression, context.moduleInfo.ModuleName)) {
-            return 'The Expression is not a valid Aggregated Boolean Expression';
+            return 'The Aggregated Boolean expression is not valid.';
         }
     }
     if (abObject?.Rule?.Predicates?.length) {
         const isAPredicateWithInvalidColumnId = abObject?.Rule?.Predicates?.some((predicate) => predicate.ColumnId !== undefined && predicate.ColumnId === '');
         if (isAPredicateWithInvalidColumnId) {
-            return 'Predicates with custom scope need a valid column';
+            return 'Predicates with a custom scope require a valid column.';
         }
     }
     return true;

package/src/View/Components/NewScopeComponent.js

@@ -18,13 +18,13 @@ const Tag_1 = require("../../components/Tag/Tag");
 const isScopeValid = ({ Scope }) => {
     const result = [];
     if (!Scope) {
-        return 'No scope specified or scope is empty';
+        return 'A scope is required.';
     }
     if (Scope && 'ColumnIds' in Scope && Scope.ColumnIds.length === 0) {
-        result.push('No Columns selected in Scope');
+        result.push('Please select at least one column for the scope.');
     }
     if (Scope && 'DataTypes' in Scope && Scope.DataTypes.length === 0) {
-        result.push('No Data Types selected in Scope');
+        result.push('Please select at least one data type for the scope.');
     }
     return result.length ? result.join(', ') : true;
 };

package/src/View/Components/Popups/AdaptablePopupConfirmation.js

@@ -55,7 +55,7 @@ const AdaptablePopupConfirmation = (props) => {
                             setDisableDeleteConfirmation(!disableDeleteConfirmation);
                         } }, "Do not show this again")),
                 props.showInputBox && (React.createElement(Flex_1.Box, { className: "twa:p-2", "data-name": "body" },
-                    React.createElement("p", null, "Please enter a comment to confirm"),
+                    React.createElement("p", null, "Please enter a comment to confirm."),
                     React.createElement(Input_1.default, { className: "twa:mt-2 twa:w-full", value: promptText, type: "string", placeholder: "Enter text", onChange: (e) => changeContent(e) }))),
                 React.createElement(Flex_1.Flex, { className: "twa:mt-3 twa:p-2", "data-name": "footer", justifyContent: "space-between" },
                     props.cancelButtonText != null ? (React.createElement(SimpleButton_1.default, { "data-name": "cancel", tone: "neutral", variant: "raised", onClick: () => onCancelForm() }, props.cancelButtonText)) : (React.createElement("div", null)),

package/src/View/CustomSort/Wizard/CustomSortColumnWizardSection.js

@@ -23,13 +23,13 @@ const renderCustomSortColumn = (data) => {
 exports.renderCustomSortColumn = renderCustomSortColumn;
 const isValidCustomSortColumn = (data, allCustomSorts) => {
     if (!data.Name) {
-        return 'Custom Sort Name cannot be blank';
+        return 'A name is required.';
     }
     if (allCustomSorts.some((customSort) => customSort.Name === data.Name && customSort.Uuid !== data.Uuid)) {
-        return 'A Custom Sort already exists with that name';
+        return 'A Custom Sort with this name already exists.';
     }
     if (!data.ColumnId) {
-        return 'You have to select a Column for Custom Sort';
+        return 'Please select a column for the Custom Sort.';
     }
     return true;
 };

package/src/View/CustomSort/Wizard/CustomSortValuesWizardSection.js

@@ -15,7 +15,7 @@ const DateHelper_1 = require("../../../Utilities/Helpers/DateHelper");
 const Tag_1 = require("../../../components/Tag");
 const isValidCustomSortOrder = (data) => {
     if (!data.SortedValues || !data.SortedValues.length) {
-        return 'You have to specify at least one value for Custom Sort order';
+        return 'At least one value is required for the Custom Sort order.';
     }
     return true;
 };

package/src/View/FlashingCell/Wizard/isValidFlashingCellRules.js

@@ -4,7 +4,7 @@ exports.isValidFlashingCellRules = void 0;
 const Utilities_1 = require("../../Components/EntityRulesEditor/Utilities");
 const isValidFlashingCellRules = (flashingCell, api, context) => {
     if (!flashingCell.Rule?.Predicates?.length && !flashingCell.Rule.BooleanExpression) {
-        return 'No Rule defined for Flashing Cell';
+        return 'A rule is required for the Flashing Cell.';
     }
     const isRuleValid = (0, Utilities_1.isAdaptableRuleValid)(flashingCell, api, context);
     if (typeof isRuleValid === 'string') {

package/src/View/FreeTextColumn/Wizard/FreeTextColumnSettingsWizardSection.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { FreeTextColumn } from '../../../AdaptableState/FreeTextColumnState';
 import { AdaptableApi } from '../../../Api/AdaptableApi';
 export declare const renderFreeTextColumnSummary: (data: FreeTextColumn) => React.JSX.Element;
-export declare const isValidFreeTextColumn: (data: FreeTextColumn, api: AdaptableApi) => true | "Column Id cannot be empty" | "A Column already exists with that id" | "No data type specified for column";
+export declare const isValidFreeTextColumn: (data: FreeTextColumn, api: AdaptableApi) => true | "A Column ID is required." | "A column with this ID already exists." | "A data type is required for the column.";
 export type FreeTextColumnSettingsWizardSectionProps = {
     onChange: (data: FreeTextColumn) => void;
     isEdit: boolean;

package/src/View/FreeTextColumn/Wizard/FreeTextColumnSettingsWizardSection.js

@@ -45,15 +45,15 @@ exports.renderFreeTextColumnSummary = renderFreeTextColumnSummary;
 const isValidFreeTextColumn = (data, api) => {
     const columns = api.columnApi.getUIAvailableColumns();
     if (!data.ColumnId) {
-        return 'Column Id cannot be empty';
+        return 'A Column ID is required.';
     }
     const columnsWithSameIdCount = columns.filter((c) => c.columnId === data.ColumnId).length;
     const hasAlreadyExistingId = data.Uuid ? columnsWithSameIdCount > 1 : columnsWithSameIdCount > 0;
     if (hasAlreadyExistingId) {
-        return 'A Column already exists with that id';
+        return 'A column with this ID already exists.';
     }
     if (!data.FreeTextColumnSettings.DataType) {
-        return 'No data type specified for column';
+        return 'A data type is required for the column.';
     }
     return true;
 };

package/src/View/Layout/LayoutViewPanel.js

@@ -83,7 +83,7 @@ function mapDispatchToProps(dispatch) {
         showMissingLayoutsError: () => {
             dispatch(PopupRedux.PopupShowConfirmation({
                 Header: 'Missing Layouts',
-                Msg: 'You have not defined any Layout! See the console for more details.',
+                Msg: 'No Layouts have been defined. Please check the console for details.',
                 ConfirmAction: null,
                 ConfirmButtonText: 'OK',
                 CancelButtonText: null,

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

@@ -23,7 +23,7 @@ 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

@@ -17,7 +17,7 @@ const Flex_1 = require("../../../../components/Flex");
 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

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

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

@@ -220,7 +220,7 @@ 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;
 };
@@ -309,12 +309,12 @@ const PivotAggregationsSection = (props) => {
         }
         const firstAggFuncName = (0, AggregationColumns_1.getAggFuncName)(aggregationColumns[0].AggFunc);
         if (layout.PivotAggregationColumns?.some((aggCol) => (0, AggregationColumns_1.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

@@ -28,7 +28,7 @@ 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

@@ -11,11 +11,11 @@ const OnePageAdaptableWizard_1 = require("../../Wizard/OnePageAdaptableWizard");
 const Flex_1 = require("../../../components/Flex");
 const isValidNamedQueryExpression = (data, api) => {
     if (!data.BooleanExpression) {
-        return 'Expression is empty';
+        return 'An expression is required.';
     }
     const valid = api.expressionApi.isValidBooleanExpression(data.BooleanExpression, ModuleConstants_1.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

@@ -29,16 +29,16 @@ const PlusMinusSettingsSummary = (props) => {
 exports.PlusMinusSettingsSummary = PlusMinusSettingsSummary;
 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 = (0, Utilities_1.isAdaptableRuleValid)(data, api, context);
         if (typeof ruleValidation === 'string') {
@@ -46,10 +46,10 @@ 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/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.";