@adaptabletools/adaptable 22.0.0-canary.0 → 22.0.0-canary.10

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/PivotColumnsSection.js

@@ -7,6 +7,7 @@ import { useOnePageAdaptableWizardContext } from '../../../Wizard/OnePageAdaptab
 import { columnFilter } from './Utilities';
 import ArrayExtensions from '../../../../Utilities/Extensions/ArrayExtensions';
 import { Box } from '../../../../components/Flex';
+import { CheckBox } from '../../../../components/CheckBox';
 export const PivotColumnsSectionSummary = () => {
     const adaptable = useAdaptable();
     const { data: layout } = useOnePageAdaptableWizardContext();
@@ -28,5 +29,12 @@ export const PivotColumnsSection = (props) => {
     return (React.createElement(Tabs, { className: "twa:h-full" },
         React.createElement(Tabs.Tab, null, "Pivot Columns"),
         React.createElement(Tabs.Content, null,
+            React.createElement(Box, { className: "twa:mb-3 twa:px-2" },
+                React.createElement(CheckBox, { checked: !!layout.PivotResultColumnsOrder, onChange: (checked) => {
+                        props.onChange({
+                            ...layout,
+                            PivotResultColumnsOrder: checked,
+                        });
+                    } }, "Persist Order of Pivot Result Columns")),
             React.createElement(ValueSelector, { showFilterInput: true, filter: columnFilter, toIdentifier: (option) => `${option.columnId}`, toLabel: (option) => option.friendlyName ?? option.columnId, options: sortedPivotColumns, value: layout.PivotColumns ?? [], allowReorder: true, onChange: handleColumnsChange }))));
 };

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

@@ -1,6 +1,5 @@
 import * as React from 'react';
 import Input from '../../../components/Input';
-import Radio from '../../../components/Radio';
 import FormLayout, { FormRow } from '../../../components/FormLayout';
 import { Tabs } from '../../../components/Tabs';
 import { useOnePageAdaptableWizardContext, } from '../../Wizard/OnePageAdaptableWizard';
@@ -12,15 +11,29 @@ import { Flex } from '../../../components/Flex';
 export const PlusMinusSettingsSummary = (props) => {
     const { data } = useOnePageAdaptableWizardContext();
     return (React.createElement(React.Fragment, null,
+        React.createElement(SummaryText, null,
+            "Name ",
+            React.createElement(Tag, null, data.Name || 'Not specified')),
         React.createElement(SummaryText, null,
             "Nudge Value ",
             React.createElement(Tag, null, data.NudgeValue ?? 'Not selected')),
+        React.createElement(SummaryText, null,
+            "Nudge Type ",
+            React.createElement(Tag, null, props.hasCondition ? 'Conditional' : 'Always Apply')),
         props.hasCondition && React.createElement(PlusMinusRuleSummary, null)));
 };
 export const isSettingsValid = (hasCondition) => (data, api, context) => {
+    if (!data.Name?.trim()) {
+        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 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') {
@@ -28,15 +41,21 @@ 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;
 };
 export const PlusMinusSettingsWizardSection = (props) => {
     const { data } = useOnePageAdaptableWizardContext();
+    const handleNameChange = (event) => {
+        props.onChange({
+            ...data,
+            Name: event.target.value,
+        });
+    };
     const handleNudgeValueChange = (event) => {
         const newValue = parseFloat(event.target.value);
         props.onChange({
@@ -45,15 +64,19 @@ export const PlusMinusSettingsWizardSection = (props) => {
         });
     };
     return (React.createElement(Flex, { flexDirection: "column", "data-name": "plus-minus-column-settings", className: "twa:h-full" },
-        React.createElement(Tabs, { autoFocus: false, className: "twa:p-2" },
-            React.createElement(Tabs.Tab, null, "Plus Minus Settings"),
+        React.createElement(Tabs, { className: "twa:p-2" },
+            React.createElement(Tabs.Tab, null, "Settings"),
             React.createElement(Tabs.Content, null,
                 React.createElement(FormLayout, null,
+                    React.createElement(FormRow, { label: "Name" },
+                        React.createElement(Input, { "data-name": "plus-minus-name", className: "twa:flex-1 twa:mr-3", onChange: handleNameChange, placeholder: "Enter Name", value: data.Name ?? '' })),
                     React.createElement(FormRow, { label: "Nudge Value" },
-                        React.createElement(Input, { "data-name": "nudge-value", className: "twa:flex-1 twa:mr-3", onChange: handleNudgeValueChange, placeholder: "Enter Number", type: "number", value: data.NudgeValue ?? '' })),
-                    React.createElement(FormRow, { label: "Nudge Type" },
-                        React.createElement(Flex, null,
-                            React.createElement(Radio, { "data-name": "nudge-type-always", value: "Always", checked: !props.hasCondition, onChange: () => props.onConditionChange(false) }, "Always Apply Nudge"),
-                            React.createElement(Radio, { "data-name": "nudge-type-condition", className: "twa:ml-3", value: "Expression", checked: props.hasCondition, onChange: () => props.onConditionChange(true) }, "Create a Rule")))))),
-        props.hasCondition && (React.createElement(PlusMinusRuleWizardSection, { defaultPredicateId: "NonBlanks", onChange: props.onChange }))));
+                        React.createElement(Input, { "data-name": "nudge-value", className: "twa:flex-1 twa:mr-3", onChange: handleNudgeValueChange, placeholder: "Enter Number", type: "number", value: data.NudgeValue ?? '' }))))),
+        React.createElement(Tabs, { className: "twa:p-2", selectedIndex: props.hasCondition ? 1 : 0, onSelectedIndexChange: (index) => props.onConditionChange(index === 1) },
+            React.createElement(Tabs.Tab, { "data-name": "nudge-type-always" }, "Always Apply"),
+            React.createElement(Tabs.Tab, { "data-name": "nudge-type-condition" }, "Conditional"),
+            React.createElement(Tabs.Content, null,
+                React.createElement(Flex, { className: "twa:text-2 twa:py-2" }, "The nudge value is always applied when using Plus/Minus")),
+            React.createElement(Tabs.Content, { className: "twa:p-0" },
+                React.createElement(PlusMinusRuleWizardSection, { defaultPredicateId: "NonBlanks", onChange: props.onChange })))));
 };

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

@@ -9,7 +9,7 @@ import * as PlusMinusRedux from '../../../Redux/ActionsReducers/PlusMinusRedux';
 import { ObjectTagsWizardSection, renderObjectTagsSummary, } from '../../Wizard/ObjectTagsWizardSection';
 import { Box } from '../../../components/Flex';
 export const PlusMinusWizard = (props) => {
-    const [plusMinus, setPlusMinus] = React.useState(() => {
+    const [plusMinus, doSetPlusMinus] = React.useState(() => {
         const newPlusMinus = {
             ...(props.data ? props.data : ObjectFactory.CreateEmptyPlusMinusNudge()),
             Scope: props?.data?.Scope ?? { All: true },
@@ -22,19 +22,24 @@ export const PlusMinusWizard = (props) => {
         }
         return newPlusMinus;
     });
+    const setPlusMinus = React.useCallback((data) => {
+        doSetPlusMinus(data);
+    }, []);
     const [hasCondition, setHasCondition] = React.useState(() => {
         // true if on edit and it has a condition
         return Boolean(props?.data?.Rule);
     });
     React.useEffect(() => {
-        const preparedData = { ...plusMinus };
-        if (hasCondition) {
-            preparedData.Rule = preparedData.Rule ?? { BooleanExpression: '' };
-        }
-        else {
-            delete preparedData.Rule;
-        }
-        setPlusMinus(preparedData);
+        doSetPlusMinus((prev) => {
+            const preparedData = { ...prev };
+            if (hasCondition) {
+                preparedData.Rule = preparedData.Rule ?? { BooleanExpression: '' };
+            }
+            else {
+                delete preparedData.Rule;
+            }
+            return preparedData;
+        });
     }, [hasCondition]);
     const dispatch = useDispatch();
     const handleFinish = () => {
@@ -47,6 +52,12 @@ export const PlusMinusWizard = (props) => {
         props.onFinishWizard(plusMinus);
     };
     return (React.createElement(OnePageAdaptableWizard, { defaultCurrentSectionName: props.defaultCurrentSectionName, moduleInfo: props.moduleInfo, data: plusMinus, onHide: props.onCloseWizard, onFinish: handleFinish, sections: [
+            {
+                title: 'Settings',
+                isValid: isSettingsValid(hasCondition),
+                renderSummary: () => React.createElement(PlusMinusSettingsSummary, { hasCondition: hasCondition }),
+                render: () => (React.createElement(PlusMinusSettingsWizardSection, { hasCondition: hasCondition, onConditionChange: setHasCondition, onChange: setPlusMinus })),
+            },
             {
                 title: 'Target',
                 isValid: isScopeValid,
@@ -59,12 +70,6 @@ export const PlusMinusWizard = (props) => {
                 render: () => (React.createElement(Box, { className: "twa:p-2" },
                     React.createElement(PlusMinusScopeWizardSection, { onChange: setPlusMinus }))),
             },
-            {
-                title: 'Settings',
-                isValid: isSettingsValid(hasCondition),
-                renderSummary: () => React.createElement(PlusMinusSettingsSummary, { hasCondition: hasCondition }),
-                render: () => (React.createElement(PlusMinusSettingsWizardSection, { hasCondition: hasCondition, onConditionChange: setHasCondition, onChange: setPlusMinus })),
-            },
             {
                 details: 'Select Plus/Minus Tags',
                 title: 'Tags',

package/src/View/QuickSearch/QuickSearchPopup.js

@@ -35,7 +35,10 @@ const QuickSearchPopupComponent = (props) => {
             React.createElement(Card, null,
                 React.createElement(Card.Title, null, "Behaviour"),
                 React.createElement(Card.Body, { className: "twa:p-1", gap: 2 },
-                    React.createElement(HelpBlock, { className: "twa:text-2 twa:w-fit" }, "Filters the Grid to only show rows with matching cells; use with care as can cause performance issues"),
+                    React.createElement(HelpBlock, { className: "twa:text-2 twa:w-fit" },
+                        "Filter Grid when searching to only show rows with matching cells; ",
+                        React.createElement("b", null, "use with care"),
+                        " as can cause performance issues"),
                     React.createElement(CheckBox, { "data-name": "filter-quick-search-results", value: "existing", checked: state.RunQueryAfterQuickSearch, disabled: StringExtensions.IsNotNullOrEmpty(searchText), onChange: onQuickSearchBehaviourChange }, "Filter using Quick Search Results"))),
             React.createElement(Card.Title, { border: false, className: "twa:pt-3" }, "Cell Matching Style"),
             React.createElement(Card, null,

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

@@ -1,11 +1,18 @@
 import * as React from 'react';
 import { Tabs } from '../../../../components/Tabs';
 import FormLayout, { FormRow } from '../../../../components/FormLayout';
+import Input from '../../../../components/Input';
 import Radio from '../../../../components/Radio';
 import DropdownButton from '../../../../components/DropdownButton';
 import { FormDescriptionText } from '../../../Wizard/OnePageAdaptableWizard';
 import { Box } from '../../../../components/Flex';
 export const ScheduleSettingsIPushPull = (props) => {
+    const handleNameChange = (event) => {
+        props.onChange({
+            ...props.iPushPull,
+            Name: event.target.value,
+        });
+    };
     const reportOptions = props.allReports.map((report) => ({
         label: report.Name,
         value: report.Name,
@@ -45,9 +52,13 @@ export const ScheduleSettingsIPushPull = (props) => {
     });
     return (React.createElement(Box, { "data-name": "schedule-settings-ipushpull" },
         React.createElement(Tabs, { autoFocus: false },
-            React.createElement(Tabs.Tab, null, "Ipushpull Schedule Settings"),
+            React.createElement(Tabs.Tab, null, "Settings"),
             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.iPushPull?.Name ?? '' })),
+                    React.createElement(FormRow, { label: "" },
+                        React.createElement(Box, { className: "twa:h-2" })),
                     React.createElement(FormRow, { label: "Select Report" },
                         React.createElement(DropdownButton, { "data-name": "report-name", disabled: props.allReports.length == 0, items: reportOptions, className: "twa:w-[300px]" }, props?.iPushPull?.IPushPullReport?.ReportName || 'Select Report')),
                     React.createElement(FormRow, { label: "Select Folder" },