@adaptabletools/adaptable 13.0.0-canary.8 → 13.0.0

package/src/Utilities/Services/ModuleService.js

@@ -87,8 +87,6 @@ class ModuleService {
                 return learnUrl + 'handbook-calculated-column';
             case 'CellSummary':
                 return learnUrl + 'handbook-summarising#cell-summary-information';
-            case 'ConditionalStyle':
-                return learnUrl + 'handbook-conditional-styling';
             case 'CustomSort':
                 return learnUrl + 'handbook-sorting';
             case 'Dashboard':
@@ -141,6 +139,8 @@ class ModuleService {
                 return learnUrl + 'integrations-ipushpull';
             case 'OpenFin':
                 return learnUrl + 'integrations-openfin';
+            case 'StyledColumn':
+                return learnUrl + 'handbook-styled-column-overview';
             default:
                 return 'good';
         }

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -43,9 +43,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     isCumulativeAggregate(input: string): boolean;
     getExpressionWithColumnFriendlyNames(expression?: string): string;
     getModuleExpressionFunctionsMap(module: AdaptableModule): ModuleExpressionFunctionsMap;
-    private getFunctionNames;
-    private extractDefaultExpressionFunctions;
-    private mapFunctionsDefinitionToMap;
+    private extractMappedExpressionFunctions;
     evaluateCustomQueryVariable(functionName: string, args?: any[]): any;
     private getBooleanAndScalarFunctions;
     private getExpressionCacheKey;

package/src/Utilities/Services/QueryLanguageService.js

@@ -185,7 +185,7 @@ class QueryLanguageService {
             if (evaluationResult.type !== 'aggregationBoolean') {
                 const result = {
                     isValid: false,
-                    errorMessage: 'provided AggregatedBBoolean expression does not evaluate to a supported aggregation',
+                    errorMessage: 'provided AggregatedBoolean expression does not evaluate to a supported aggregation',
                 };
                 this.cacheAggregatedBooleanValidation.set(cacheKey, result);
                 return result;
@@ -275,7 +275,7 @@ class QueryLanguageService {
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
     getModuleExpressionFunctionsMap(module) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c;
         const expressionOptions = this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions;
         if (module) {
             let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
@@ -283,19 +283,19 @@ class QueryLanguageService {
                 return cachedResult;
             }
         }
-        const defaultBooleanExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultBooleanFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions);
-        const defaultScalarExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultScalarFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions);
-        const defaultObservableExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultObservableFunctions, observableExpressionFunctions_1.observableExpressionFunctions);
-        const defaultAggregatedBooleanFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions);
-        const defaultAggregatedScalarFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions);
+        const generalBooleanExpressionFunctions = this.extractMappedExpressionFunctions(booleanExpressionFunctions_1.booleanExpressionFunctions, expressionOptions.systemBooleanFunctions, expressionOptions.customBooleanFunctions);
+        const generalScalarExpressionFunctions = this.extractMappedExpressionFunctions(scalarExpressionFunctions_1.scalarExpressionFunctions, expressionOptions.systemScalarFunctions, expressionOptions.customScalarFunctions);
+        const generalObservableExpressionFunctions = this.extractMappedExpressionFunctions(observableExpressionFunctions_1.observableExpressionFunctions, expressionOptions.systemObservableFunctions);
+        const generalAggregatedBooleanExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions, expressionOptions.systemAggregatedBooleanFunctions);
+        const generalAggregatedScalarExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions, expressionOptions.systemAggregatedScalarFunctions);
         if (!module) {
             (0, LoggingHelper_1.LogAdaptableInfo)(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
-                booleanFunctions: this.mapFunctionsDefinitionToMap(defaultBooleanExpressionFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions),
-                scalarFunctions: this.mapFunctionsDefinitionToMap(defaultScalarExpressionFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions),
-                observableFunctions: this.mapFunctionsDefinitionToMap(defaultObservableExpressionFunctions, observableExpressionFunctions_1.observableExpressionFunctions),
-                aggregatedBooleanFunctions: this.mapFunctionsDefinitionToMap(defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions),
-                aggregatedScalarFunctions: this.mapFunctionsDefinitionToMap(defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions),
+                booleanFunctions: generalBooleanExpressionFunctions,
+                scalarFunctions: generalScalarExpressionFunctions,
+                observableFunctions: generalObservableExpressionFunctions,
+                aggregatedBooleanFunctions: generalAggregatedBooleanExpressionFunctions,
+                aggregatedScalarFunctions: generalAggregatedScalarExpressionFunctions,
             };
         }
         let moduleExpressionFunctions;
@@ -303,11 +303,11 @@ class QueryLanguageService {
             const context = {
                 adaptableApi: this.adaptableApi,
                 module,
-                defaultBooleanFunctionNames: this.getFunctionNames(defaultBooleanExpressionFunctions),
-                defaultScalarFunctionNames: this.getFunctionNames(defaultScalarExpressionFunctions),
-                defaultObservableFunctionNames: this.getFunctionNames(defaultObservableExpressionFunctions),
-                defaultAggregatedBooleanFunctionNames: this.getFunctionNames(defaultAggregatedBooleanFunctions),
-                defaultAggregatedScalarFunctionNames: this.getFunctionNames(defaultAggregatedScalarFunctions),
+                availableBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalBooleanExpressionFunctions),
+                availableScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalScalarExpressionFunctions),
+                availableObservableFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalObservableExpressionFunctions),
+                availableAggregatedBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedBooleanExpressionFunctions),
+                availableAggregatedScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedScalarExpressionFunctions),
             };
             moduleExpressionFunctions = (_a = expressionOptions.moduleExpressionFunctions(context)) !== null && _a !== void 0 ? _a : {};
         }
@@ -315,49 +315,45 @@ class QueryLanguageService {
             moduleExpressionFunctions = (_c = (_b = expressionOptions.moduleExpressionFunctions) === null || _b === void 0 ? void 0 : _b[module]) !== null && _c !== void 0 ? _c : {};
         }
         const moduleExpressionFunctionsMap = {
-            booleanFunctions: this.mapFunctionsDefinitionToMap((_d = moduleExpressionFunctions.booleanFunctions) !== null && _d !== void 0 ? _d : defaultBooleanExpressionFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions),
-            scalarFunctions: this.mapFunctionsDefinitionToMap((_e = moduleExpressionFunctions.scalarFunctions) !== null && _e !== void 0 ? _e : defaultScalarExpressionFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions),
-            observableFunctions: this.mapFunctionsDefinitionToMap((_f = moduleExpressionFunctions.observableFunctions) !== null && _f !== void 0 ? _f : defaultObservableExpressionFunctions, observableExpressionFunctions_1.observableExpressionFunctions),
-            aggregatedBooleanFunctions: this.mapFunctionsDefinitionToMap((_g = moduleExpressionFunctions.aggregatedBooleanFunctions) !== null && _g !== void 0 ? _g : defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions),
-            aggregatedScalarFunctions: this.mapFunctionsDefinitionToMap((_h = moduleExpressionFunctions.aggregatedScalarFunctions) !== null && _h !== void 0 ? _h : defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions),
+            booleanFunctions: this.extractMappedExpressionFunctions(generalBooleanExpressionFunctions, moduleExpressionFunctions.systemBooleanFunctions, moduleExpressionFunctions.customBooleanFunctions),
+            scalarFunctions: this.extractMappedExpressionFunctions(generalScalarExpressionFunctions, moduleExpressionFunctions.systemScalarFunctions, moduleExpressionFunctions.customScalarFunctions),
+            observableFunctions: this.extractMappedExpressionFunctions(generalObservableExpressionFunctions, moduleExpressionFunctions.systemObservableFunctions),
+            aggregatedBooleanFunctions: this.extractMappedExpressionFunctions(generalAggregatedBooleanExpressionFunctions, moduleExpressionFunctions.systemAggregatedBooleanFunctions),
+            aggregatedScalarFunctions: this.extractMappedExpressionFunctions(generalAggregatedScalarExpressionFunctions, moduleExpressionFunctions.systemAggregatedScalarFunctions),
         };
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleExpressionFunctionsMap);
         return moduleExpressionFunctionsMap;
     }
-    getFunctionNames(definitions) {
-        return definitions.flatMap((definition) => {
-            if (typeof definition === 'string') {
-                return definition;
-            }
-            else {
-                return (0, TypeExtensions_1.getTypedKeys)(definition);
-            }
-        });
-    }
-    extractDefaultExpressionFunctions(defaultOptions, availableExpressionFunctions) {
-        if (typeof defaultOptions === 'function') {
-            const context = {
+    extractMappedExpressionFunctions(availableExpressionFunctions, systemFunctions, customFunctions) {
+        const systemFunctionNames = typeof systemFunctions === 'function'
+            ? systemFunctions({
                 adaptableApi: this.adaptableApi,
                 availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(availableExpressionFunctions),
-            };
-            return defaultOptions(context);
+            })
+            : systemFunctions;
+        let generalExpressionFunctions = {};
+        // add system functions
+        if (Array.isArray(systemFunctionNames)) {
+            // add only system functions specified by user
+            systemFunctionNames.forEach((systemFunctionName) => {
+                generalExpressionFunctions[systemFunctionName] =
+                    availableExpressionFunctions[systemFunctionName];
+            });
         }
-        return defaultOptions;
-    }
-    mapFunctionsDefinitionToMap(functionsDefinition, internalExpressionFunctions) {
-        let resultMap = {};
-        functionsDefinition.forEach((definition) => {
-            if (typeof definition === 'string') {
-                const internalFunction = internalExpressionFunctions[definition];
-                if (internalFunction) {
-                    resultMap[definition] = internalFunction;
-                }
-            }
-            else {
-                resultMap = Object.assign(Object.assign({}, resultMap), definition);
-            }
-        });
-        return resultMap;
+        else {
+            // add ALL system functions
+            generalExpressionFunctions = Object.assign({}, availableExpressionFunctions);
+        }
+        const customFunctionDefinitions = typeof customFunctions === 'function'
+            ? customFunctions({
+                adaptableApi: this.adaptableApi,
+                availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalExpressionFunctions),
+            })
+            : customFunctions;
+        if (customFunctionDefinitions) {
+            generalExpressionFunctions = Object.assign(Object.assign({}, generalExpressionFunctions), customFunctionDefinitions);
+        }
+        return generalExpressionFunctions;
     }
     evaluateCustomQueryVariable(functionName, args) {
         var _a, _b, _c;

package/src/Utilities/Services/ReportService.js

@@ -91,7 +91,7 @@ class ReportService {
     }
     GetReportColumnScopeShortDescription(report) {
         var _a, _b;
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return ['[Custom Columns]'];
         }
         switch (report.ReportColumnScope) {
@@ -109,7 +109,7 @@ class ReportService {
         }
     }
     GetReportColumnScopeLongDescription(report) {
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return '[Custom Columns]';
         }
         switch (report.ReportColumnScope) {
@@ -124,7 +124,7 @@ class ReportService {
         }
     }
     GetReportExpressionDescription(report, cols) {
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return '[Custom Data]';
         }
         if (this.IsSystemReport(report.Name)) {
@@ -160,7 +160,7 @@ class ReportService {
     GetReportColumnsForReport(report, includePrimaryKey = false) {
         let reportColumns = [];
         let gridColumns = this.adaptableApi.columnApi.getColumns();
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return reportColumns;
         }
         // first get the cols depending on the Column Scope
@@ -204,8 +204,8 @@ class ReportService {
             friendlyName: column.friendlyName,
             dataType: column.dataType,
         }));
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
-            return this.adaptableApi.exportApi.runCustomReport(report.Name);
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
+            return this.adaptableApi.exportApi.runServerReport(report.Name);
         }
         if (ArrayExtensions_1.default.IsNullOrEmpty(columns)) {
             return { columns: [], rows: [] };

package/src/View/AdaptablePopover/index.js

@@ -36,7 +36,7 @@ class AdaptablePopover extends React.Component {
         return (React.createElement(rebass_1.Flex, { alignItems: "center", className: this.props.className },
             React.createElement(OverlayTrigger_1.default, { showTriangle: true, render: () => popoverClickRootClose, showEvent: (this.props.showEvent || 'mouseenter'), hideEvent: (this.props.hideEvent || 'mouseleave'), style: {
                     overflow: 'visible',
-                }, defaultZIndex: 100000 }, useButton ? (React.createElement(ButtonInfo_1.ButtonInfo, { style: iconStyle, onClick: () => null, icon: showIcon && icon, tooltip: this.props.tooltipText }, this.props.children)) : (React.createElement("div", { title: this.props.tooltipText, tabIndex: 0, style: { cursor: 'pointer', display: 'inline-block' } },
+                }, defaultZIndex: 100000 }, useButton ? (React.createElement(ButtonInfo_1.ButtonInfo, { style: iconStyle, variant: "text", onClick: () => null, icon: showIcon && icon, tooltip: this.props.tooltipText }, this.props.children)) : (React.createElement("div", { title: this.props.tooltipText, tabIndex: 0, style: { cursor: 'pointer', display: 'inline-block' } },
                 this.props.children,
                 showIcon && React.createElement(icons_1.Icon, { name: icon }))))));
     }

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

@@ -32,15 +32,14 @@ const HighlightStyle = (props) => {
             },
         },
     ];
-    return (React.createElement(React.Fragment, null,
+    return (React.createElement(rebass_1.Box, { "data-name": props.dataName },
         React.createElement(rebass_1.Flex, null,
             React.createElement(CheckBox_1.CheckBox, { mr: 2, style: { alignItems: 'flex-start' }, checked: Boolean(props.highlight), onChange: (checked) => {
                     props.onChange(checked);
                 } }, props.label),
             Boolean(props.highlight) && (React.createElement(DropdownButton_1.default, { items: options, columns: ['label'] }, typeof props.highlight === 'boolean' ? (React.createElement(rebass_1.Text, { fontSize: 2, mt: 1 },
-                "Use Message Type's",
-                ' ',
-                (0, AdaptableContext_1.useAdaptable)().api.internalApi.getCorrectEnglishVariant('Colour'))) : (React.createElement(rebass_1.Text, { fontSize: 2, mt: 1 }, "Create a Custom Style"))))),
+                "Use Message Type's ",
+                adaptable.api.internalApi.getCorrectEnglishVariant('Colour'))) : (React.createElement(rebass_1.Text, { fontSize: 2, mt: 1 }, "Create a Custom Style"))))),
         typeof props.highlight === 'object' && (React.createElement(Panel_1.default, { margin: 2 },
             React.createElement(rebass_1.Box, { paddingLeft: 3 },
                 React.createElement(StyleComponent_1.StyleComponent, { headless: true, api: adaptable.api, Style: props.highlight, UpdateStyle: (style) => {
@@ -93,41 +92,43 @@ const AlertBehaviourWizardSection = (props) => {
     const rowAddedAlert = api.internalApi.isAlertDefinitionForAddedRowChangeEvent(data);
     const rowRemovedAlert = api.internalApi.isAlertDefinitionForRemovedRowChangeEvent(data);
     const cellChangedAlert = !rowAddedAlert && !rowRemovedAlert;
+    const hasPreventCellEdit = cellChangedAlert;
+    const hasHighlightCell = cellChangedAlert;
+    const hasHighlightRow = cellChangedAlert || rowAddedAlert;
+    const hasJumpToCell = cellChangedAlert;
+    const hasJumpToRow = cellChangedAlert || rowAddedAlert;
     const onChange = (AlertProperties) => {
         props.onChange(Object.assign(Object.assign({}, data), { AlertProperties: Object.assign(Object.assign({}, data.AlertProperties), AlertProperties) }));
     };
     return (React.createElement(Tabs_1.Tabs, null,
         React.createElement(Tabs_1.Tabs.Tab, null, api.internalApi.getCorrectEnglishVariant('Behaviour')),
         React.createElement(Tabs_1.Tabs.Content, null,
-            cellChangedAlert && (React.createElement(CheckBox_1.CheckBox, { style: { alignItems: 'flex-start' }, checked: AlertProperties.PreventEdit, onChange: (PreventEdit) => {
+            hasPreventCellEdit && (React.createElement(CheckBox_1.CheckBox, { "data-name": "prevent-cell-edit", style: { alignItems: 'flex-start' }, checked: AlertProperties.PreventEdit, onChange: (PreventEdit) => {
                     onChange({
                         PreventEdit,
                     });
                 } },
                 "Prevent Cell Edit",
                 React.createElement(rebass_1.Text, { fontSize: 2, mt: 1 }, "(automatically undo data change which triggered Alert)"))),
-            cellChangedAlert && (React.createElement(HighlightStyle, { highlight: AlertProperties.HighlightCell, label: "Highlight Cell", onChange: (HighlightCell) => {
+            hasHighlightCell && (React.createElement(HighlightStyle, { dataName: "highlight-cell", highlight: AlertProperties.HighlightCell, label: "Highlight Cell", onChange: (HighlightCell) => {
                     onChange({ HighlightCell });
                 } })),
-            cellChangedAlert && (React.createElement(HighlightStyle, { highlight: AlertProperties.HighlightRow, label: "Highlight Row", onChange: (HighlightRow) => {
+            hasHighlightRow && (React.createElement(HighlightStyle, { dataName: "highlight-row", highlight: AlertProperties.HighlightRow, label: "Highlight Row", onChange: (HighlightRow) => {
                     onChange({ HighlightRow });
                 } })),
-            rowAddedAlert && (React.createElement(HighlightStyle, { highlight: AlertProperties.HighlightRow, label: "Highlight Row", onChange: (HighlightRow) => {
-                    onChange({ HighlightRow });
-                } })),
-            cellChangedAlert && (React.createElement(CheckBox_1.CheckBox, { checked: AlertProperties.JumpToCell, onChange: (JumpToCell) => {
+            hasJumpToCell && (React.createElement(CheckBox_1.CheckBox, { "data-name": "jump-to-cell", checked: AlertProperties.JumpToCell, onChange: (JumpToCell) => {
                     onChange({ JumpToCell });
                 } }, "Jump To Cell")),
-            rowAddedAlert && (React.createElement(CheckBox_1.CheckBox, { checked: AlertProperties.JumpToRow, onChange: (JumpToRow) => {
+            hasJumpToRow && (React.createElement(CheckBox_1.CheckBox, { "data-name": "jump-to-row", checked: AlertProperties.JumpToRow, onChange: (JumpToRow) => {
                     onChange({ JumpToRow });
                 } }, "Jump To Row")),
-            React.createElement(CheckBox_1.CheckBox, { checked: AlertProperties.ShowInDiv, onChange: (ShowInDiv) => {
+            React.createElement(CheckBox_1.CheckBox, { "data-name": "show-in-div", checked: AlertProperties.ShowInDiv, onChange: (ShowInDiv) => {
                     onChange({ ShowInDiv });
                 } },
                 "Show in separate ",
                 React.createElement(CodeBlock_1.CodeBlock, null, `<div />`),
                 " element"),
-            React.createElement(CheckBox_1.CheckBox, { checked: AlertProperties.LogToConsole, onChange: (LogToConsole) => {
+            React.createElement(CheckBox_1.CheckBox, { "data-name": "log-to-console", checked: AlertProperties.LogToConsole, onChange: (LogToConsole) => {
                     onChange({ LogToConsole });
                 } }, "Log To Console"))));
 };

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

@@ -17,9 +17,32 @@ const AlertButtonsEditor = (props) => {
     const onChange = (newButtons) => {
         props.onChange(newButtons);
     };
+    const alertDefinition = adaptableAlert.alertDefinition;
+    const rowAddedAlert = api.internalApi.isAlertDefinitionForAddedRowChangeEvent(alertDefinition);
+    const rowRemovedAlert = api.internalApi.isAlertDefinitionForRemovedRowChangeEvent(alertDefinition);
+    const cellChangedAlert = !rowAddedAlert && !rowRemovedAlert;
+    const hasHighlightCell = cellChangedAlert;
+    const hasHighlightRow = cellChangedAlert || rowAddedAlert;
+    const hasJumpToCell = cellChangedAlert;
+    const hasJumpToRow = cellChangedAlert || rowAddedAlert;
+    const hasUndo = cellChangedAlert;
     const AlertButtons = (0, Helper_1.cloneObject)(props.AlertButtons || []) || [];
     const buttonActions = [];
-    buttonActions.push('highlight-row', 'jump-to-row', 'highlight-cell', 'jump-to-cell', 'undo');
+    if (hasHighlightRow) {
+        buttonActions.push('highlight-row');
+    }
+    if (hasJumpToRow) {
+        buttonActions.push('jump-to-row');
+    }
+    if (hasHighlightCell) {
+        buttonActions.push('highlight-cell');
+    }
+    if (hasJumpToCell) {
+        buttonActions.push('jump-to-cell');
+    }
+    if (hasUndo) {
+        buttonActions.push('undo');
+    }
     buttonActions.push('suspend');
     return (React.createElement(React.Fragment, null,
         React.createElement(rebass_1.Flex, { flexDirection: "row", alignItems: "center", justifyContent: "space-between" },

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

@@ -12,6 +12,7 @@ const AdaptablePopupAlert_1 = require("../../Components/Popups/AdaptablePopupAle
 const AlertButtonsEditor_1 = require("./AlertButtonsEditor");
 const CodeBlock_1 = require("../../../components/CodeBlock");
 const AdaptableInput_1 = tslib_1.__importDefault(require("../../Components/AdaptableInput"));
+const join_1 = tslib_1.__importDefault(require("../../../components/utils/join"));
 const DEFAULT_BUTTONS = [
     {
         Label: 'OK',
@@ -53,7 +54,7 @@ const AlertPreview = (_a) => {
         };
         return result;
     }, [alertDefinition]);
-    return (React.createElement(rebass_1.Box, Object.assign({}, boxProps, { style: Object.assign({ border: '1px solid var(--ab-color-inputborder)' }, boxProps.style) }),
+    return (React.createElement(rebass_1.Box, Object.assign({}, boxProps, { className: (0, join_1.default)(boxProps.className, 'ab-AlertPreview'), style: Object.assign({ border: '1px solid var(--ab-color-inputborder)' }, boxProps.style) }),
         React.createElement(AdaptablePopupAlert_1.AdaptablePopupAlert, { headless: true, focusFirstButton: focusFirstButton, adaptableAlert: alertToPreview, onClose: () => { } })));
 };
 exports.AlertPreview = AlertPreview;
@@ -73,7 +74,7 @@ const AlertDisplayWizardSection = (props) => {
         props.onChange(Object.assign(Object.assign({}, data), { MessageText: value }));
     };
     return (React.createElement(React.Fragment, null,
-        React.createElement(Tabs_1.Tabs, null,
+        React.createElement(Tabs_1.Tabs, { "data-name": "message-type" },
             React.createElement(Tabs_1.Tabs.Tab, null, "Message Type"),
             React.createElement(Tabs_1.Tabs.Content, null,
                 React.createElement(Radio_1.RadioGroup, { value: messageType, name: "messageType", orientation: "horizontal", onRadioChange: (MessageType) => {
@@ -83,7 +84,7 @@ const AlertDisplayWizardSection = (props) => {
                     React.createElement(Radio_1.default, { marginLeft: 4, value: "Success" }, "Success"),
                     React.createElement(Radio_1.default, { marginLeft: 4, value: "Warning" }, "Warning"),
                     React.createElement(Radio_1.default, { marginLeft: 4, value: "Error" }, "Error")))),
-        React.createElement(Tabs_1.Tabs, { mt: 2, mb: 3, autoFocus: false },
+        React.createElement(Tabs_1.Tabs, { "data-name": "message-text", mt: 2, mb: 3, autoFocus: false },
             React.createElement(Tabs_1.Tabs.Tab, null, "Message Text"),
             React.createElement(Tabs_1.Tabs.Content, null,
                 React.createElement(rebass_1.Text, { fontSize: 2, mt: 3, mb: 2 }, "The text to display as the Alert Message (leave blank to show automated Message based on Trigger and Condition)"),
@@ -91,7 +92,7 @@ const AlertDisplayWizardSection = (props) => {
                 React.createElement(AdaptableInput_1.default, { marginTop: 2, type: 'text', autoFocus: false, value: messageText, 
                     // onChange={(e: any) => onPredicateInputChange(e, index)}
                     onChange: (e) => onMessageTextChange(e) }))),
-        React.createElement(Tabs_1.Tabs, { mt: 2, mb: 3, autoFocus: false },
+        React.createElement(Tabs_1.Tabs, { "data-name": "display-options", mt: 2, mb: 3, autoFocus: false },
             React.createElement(Tabs_1.Tabs.Tab, null, "Display options"),
             React.createElement(Tabs_1.Tabs.Content, null,
                 React.createElement(CheckBox_1.CheckBox, { checked: (_a = data.AlertProperties) === null || _a === void 0 ? void 0 : _a.DisplayNotification, onChange: (DisplayNotification) => {
@@ -104,7 +105,7 @@ const AlertDisplayWizardSection = (props) => {
                 ((_b = data.AlertProperties) === null || _b === void 0 ? void 0 : _b.DisplayNotification) ? (typeof data.AlertForm === 'string' ? (React.createElement(rebass_1.Text, { fontSize: 2 }, "Alert buttons cannot be customized because form is dynamically driven")) : (React.createElement(AlertButtonsEditor_1.AlertButtonsEditor, { AlertButtons: ((_c = data.AlertForm) === null || _c === void 0 ? void 0 : _c.Buttons) || DEFAULT_BUTTONS, api: api, adaptableAlert: adaptableAlert, onChange: (buttons) => {
                         props.onChange(Object.assign(Object.assign({}, data), { AlertForm: Object.assign(Object.assign({}, data.AlertForm), { Buttons: buttons }) }));
                     } }))) : null)),
-        ((_d = data.AlertProperties) === null || _d === void 0 ? void 0 : _d.DisplayNotification) ? (React.createElement(Tabs_1.Tabs, { autoFocus: false },
+        ((_d = data.AlertProperties) === null || _d === void 0 ? void 0 : _d.DisplayNotification) ? (React.createElement(Tabs_1.Tabs, { "data-name": "alert-preview", autoFocus: false },
             React.createElement(Tabs_1.Tabs.Tab, null, "Alert preview"),
             React.createElement(Tabs_1.Tabs.Content, null, typeof data.AlertForm === 'string' ? (React.createElement(rebass_1.Text, { fontSize: 2 }, "Preview not available because form is dynamically driven")) : (React.createElement(exports.AlertPreview, { alertDefinition: data, api: api }))))) : null));
 };

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

@@ -14,15 +14,15 @@ const BaseAlertRulesWizardSection = (props) => {
             useBooleanQuery: (React.createElement(React.Fragment, null,
                 "Use an BooleanQuery if ",
                 React.createElement("i", null, "Scope"),
-                " is 'Whole Row' - so any data change may be evaluated in a complex BooleanExpression")),
+                " is 'All Columns' - so any data change may be evaluated in a complex BooleanExpression")),
             useObservableQuery: (React.createElement(React.Fragment, null,
                 "Use an ObservableQuery if ",
                 React.createElement("i", null, "Scope"),
-                " is 'Whole Row' - so any data change may be evaluated in a complex ObservableExpression")),
+                " is 'All Columns' - so any data change may be evaluated in a complex ObservableExpression")),
             useAggregationQuery: (React.createElement(React.Fragment, null,
                 "Use an AggregatedBooleanQuery if ",
                 React.createElement("i", null, "Scope"),
-                " is 'Whole Row' - so any data change may be evaluated in a complex AggregatedBooleanExpression")),
+                " is 'All Columns' - so any data change may be evaluated in a complex AggregatedBooleanExpression")),
         } }));
 };
 exports.BaseAlertRulesWizardSection = BaseAlertRulesWizardSection;

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

@@ -11,8 +11,8 @@ const BaseAlertScopeWizardSection = (props) => {
     const { data, api } = (0, OnePageAdaptableWizard_1.useOnePageAdaptableWizardContext)();
     return (React.createElement(rebass_1.Flex, { flexDirection: "column", style: { height: '100%' }, padding: 2 },
         React.createElement(NewScopeComponent_1.NewScopeComponent, { descriptions: {
-                rowScope: 'Changes anywhere in the row will trigger an alert',
-                columnScope: 'Changes in selected columns will trigger an alert',
+                rowScope: 'Changes in any Column in the row will trigger an Alert',
+                columnScope: 'Changes in selected Columns will trigger an Alert',
             }, scope: data.Scope, updateScope: (Scope) => {
                 const newData = Object.assign(Object.assign({}, data), { Scope });
                 if (newData.Rule.Predicate) {
@@ -47,7 +47,7 @@ const renderBaseAlertScopeSummary = (data) => {
     return (React.createElement(React.Fragment, null,
         React.createElement(rebass_1.Box, null,
             React.createElement(rebass_1.Text, { fontSize: 2 }, scopeApi.scopeIsAll(data.Scope)
-                ? 'Changes anywhere in the row will trigger an alert'
+                ? 'Changes to any Column in the row will trigger an Alert'
                 : null)),
         React.createElement(rebass_1.Box, { style: { overflow: 'hidden' } }, 'ColumnIds' in data.Scope ? (React.createElement(React.Fragment, null,
             React.createElement(rebass_1.Text, { fontSize: 2, mb: columnsInScope.length ? 2 : 0 }, "Changes in selected columns will trigger an alert"),

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

@@ -38,7 +38,7 @@ const isValidAlertRules = (alert, api, context) => {
     if (valid && alert.Rule.AggregatedBooleanExpression) {
         valid = api.queryLanguageApi.isValidAggregatedBooleanExpression(alert.Rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
         if (!valid) {
-            return 'The Expression is not a valid Aggregation Expression';
+            return 'The Expression is not a valid AggregatedBoolean Expression';
         }
     }
     return true;

package/src/View/BulkUpdate/BulkUpdatePopup.js

@@ -56,7 +56,7 @@ class BulkUpdatePopupComponent extends React.Component {
                         ' ',
                         "Select from existing column values")),
                 React.createElement(rebass_1.Flex, { padding: 2, flexDirection: "row", alignItems: "center" },
-                    React.createElement(rebass_1.Flex, { alignItems: "center", flexDirection: "row", flex: 1, marginRight: 2 }, this.state.useSelector ? (React.createElement(ColumnValueSelector_1.ColumnValueSelector, { selectedGridCells: this.props.SelectedGridCells, selectedColumnValue: this.props.BulkUpdateValue, selectedColumn: col, api: this.props.api, onColumnValueChange: (values) => this.onColumnValueSelectedChanged(values), allowNew: false, style: { width: '100%', maxWidth: 'inherit' } })) : (React.createElement(AdaptableInput_1.default, { style: { width: '100%' }, value: String(this.props.BulkUpdateValue), type: UIHelper_1.UIHelper.getDescriptionForDataType(col.dataType), placeholder: UIHelper_1.UIHelper.getPlaceHolderforDataType(col.dataType), onChange: (e) => this.onBulkUpdateValueChange(e) }))),
+                    React.createElement(rebass_1.Flex, { alignItems: "center", flexDirection: "row", flex: 1, marginRight: 2 }, this.state.useSelector ? (React.createElement(ColumnValueSelector_1.ColumnValueSelector, { selectedGridCells: this.props.SelectedGridCells, selectedColumnValue: this.props.BulkUpdateValue, selectedColumn: col, api: this.props.api, onColumnValueChange: (values) => this.onColumnValueSelectedChanged(values), allowNew: false, style: { width: '100%', maxWidth: 'inherit' } })) : (React.createElement(AdaptableInput_1.default, { "data-name": "bulk-update", style: { width: '100%' }, value: String(this.props.BulkUpdateValue), type: UIHelper_1.UIHelper.getDescriptionForDataType(col.dataType), placeholder: UIHelper_1.UIHelper.getPlaceHolderforDataType(col.dataType), onChange: (e) => this.onBulkUpdateValueChange(e) }))),
                     React.createElement(SimpleButton_1.default, { disabled: StringExtensions_1.StringExtensions.IsNullOrEmpty(this.props.BulkUpdateValue) ||
                             this.props.PreviewInfo.previewValidationSummary.validationResult == 'All', onClick: () => {
                             this.onApplyClick();

package/src/View/CalculatedColumn/CalculatedColumnSummary.d.ts

@@ -15,4 +15,4 @@ export declare class CalculatedColumnSummaryComponent extends React.Component<Ca
     onCloseWizard(): void;
     onFinishWizard: (calculatedColumn: CalculatedColumn) => void;
 }
-export declare let CalculatedColumnSummary: import("react-redux").ConnectedComponent<typeof CalculatedColumnSummaryComponent, import("react-redux").Omit<React.ClassAttributes<CalculatedColumnSummaryComponent> & CalculatedColumnSummaryProps, "key" | "ref" | "onSuspend" | "api" | "CalculatedColumns" | "modalContainer" | "moduleInfo" | "accessLevel" | "popupParams" | "onClearPopupParams" | "teamSharingActivated" | "onClosePopup" | "onUnSuspend" | "onShare" | "onEdit" | "summarisedColumn" | "onDeleteConfirm">>;
+export declare let CalculatedColumnSummary: import("react-redux").ConnectedComponent<typeof CalculatedColumnSummaryComponent, import("react-redux").Omit<React.ClassAttributes<CalculatedColumnSummaryComponent> & CalculatedColumnSummaryProps, "key" | "ref" | "onSuspend" | "api" | "accessLevel" | "modalContainer" | "CalculatedColumns" | "moduleInfo" | "onShare" | "onUnSuspend" | "teamSharingActivated" | "popupParams" | "onClearPopupParams" | "onClosePopup" | "onEdit" | "summarisedColumn" | "onDeleteConfirm">>;

package/src/View/Components/AdaptableObjectList/AdaptableObjectList.js

@@ -31,7 +31,7 @@ const AdaptableObjectListItemView = (props) => {
             return (React.createElement(rebass_1.Flex, { "data-name": tag.name, key: `${index}-${tag.name}`, mb: 2, className: `${baseClassName}__row` },
                 React.createElement(rebass_1.Box, { className: `${baseClassName}__label`, mr: 3 },
                     labelEl,
-                    props.showEditButton && (React.createElement(SimpleButton_1.default, { accessLevel: props.accessLevel, className: `${baseClassName}__edit-property`, ml: 1, icon: "edit", tooltip: "edit", iconSize: 18, variant: "text", onClick: () => {
+                    props.showEditButton && (React.createElement(SimpleButton_1.default, { "data-name": `${tag.name}-edit-button`, accessLevel: props.accessLevel, className: `${baseClassName}__edit-property`, ml: 1, icon: "edit", tooltip: "edit", iconSize: 18, variant: "text", onClick: () => {
                             props.handleOnEdit(tag.name);
                         } }))),
                 React.createElement(rebass_1.Box, { flex: 1, className: `${baseClassName}__values` },

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

@@ -8,12 +8,7 @@ const rebass_1 = require("rebass");
 const join_1 = tslib_1.__importDefault(require("../../../components/utils/join"));
 class AdaptableObjectRow extends React.Component {
     render() {
-        const colItems = this.props.colItems.map((colItem, index) => (React.createElement(rebass_1.Text, { key: index, fontSize: 'var(--ab-font-size-3)', title: typeof colItem.Content === 'string' ? colItem.Content : undefined, style: {
-                flex: colItem.Size,
-                whiteSpace: 'nowrap',
-                textOverflow: 'ellipsis',
-                overflow: 'hidden',
-            }, "data-name": "list-group-cell", paddingLeft: 1, paddingRight: 1 }, colItem.Content)));
+        const colItems = this.props.colItems.map((colItem, index) => (React.createElement(rebass_1.Text, { className: "ab-AdaptableObjectRow__cell", "data-name": "list-group-cell", key: index, title: typeof colItem.Content === 'string' ? colItem.Content : undefined, flex: colItem.Size, paddingLeft: 1, paddingRight: 1 }, colItem.Content)));
         const className = (0, join_1.default)('ab-AdaptableObjectRow', this.props.isSuspended && 'ab-AdaptableObjectRow--is-suspended');
         return (React.createElement(rebass_1.Flex, { className: className, onClick: this.props.onClick, style: this.props.style }, colItems));
     }

package/src/View/Components/Buttons/ButtonInfo.d.ts

@@ -4,6 +4,4 @@ export interface InfoButtonProps extends SimpleButtonProps {
     glyph?: string;
     tooltip?: string;
 }
-export declare class ButtonInfo extends React.Component<InfoButtonProps, {}> {
-    render(): JSX.Element;
-}
+export declare const ButtonInfo: React.FunctionComponent<InfoButtonProps>;

package/src/View/Components/Buttons/ButtonInfo.js

@@ -4,9 +4,7 @@ exports.ButtonInfo = void 0;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const SimpleButton_1 = tslib_1.__importDefault(require("../../../components/SimpleButton"));
-class ButtonInfo extends React.Component {
-    render() {
-        return (React.createElement(SimpleButton_1.default, Object.assign({ "data-name": "info", iconSize: 20, icon: "info", variant: "text" }, this.props)));
-    }
-}
+const ButtonInfo = (props) => {
+    return (React.createElement(SimpleButton_1.default, Object.assign({ "data-name": "info", iconSize: 20, icon: "info", variant: "raised", tone: "accent" }, props)));
+};
 exports.ButtonInfo = ButtonInfo;

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

@@ -161,7 +161,8 @@ const EntityRulesEditor = (props) => {
     };
     const initialData = (0, react_1.useMemo)(() => api.internalApi.getQueryPreviewData(), []);
     const showDocumentationLinks = api.internalApi.isDocumentationLinksDisplayed();
-    return (React.createElement(rebass_1.Flex, Object.assign({ flexDirection: "column", padding: 2, pt: 0, pl: 0 }, flexProps, { style: Object.assign({ height: '100%' }, flexProps === null || flexProps === void 0 ? void 0 : flexProps.style) }),
+    const baseClassName = 'ab-EntityRulesEditor';
+    return (React.createElement(rebass_1.Flex, Object.assign({ className: baseClassName, flexDirection: "column", padding: 2, pt: 0, pl: 0 }, flexProps, { style: Object.assign({ height: '100%' }, flexProps === null || flexProps === void 0 ? void 0 : flexProps.style) }),
         children,
         React.createElement(Tabs_1.Tabs, { onValueChange: setType, value: selectedTab, pt: 2, pl: 2, style: { flex: 1, overflow: 'auto' } },
             showNoRule ? (React.createElement(Tabs_1.Tabs.Tab, { value: 'NoRule', style: { flex: 1 } },
@@ -170,15 +171,9 @@ const EntityRulesEditor = (props) => {
                 React.createElement(rebass_1.Text, { fontSize: 2, mb: 2 }, 'Format Column is always applied'))) : null,
             showPredicate ? (React.createElement(Tabs_1.Tabs.Tab, { value: 'Predicate', style: { flex: 1 } },
                 React.createElement(Radio_1.default, { tabIndex: -1, margin: 0, checked: type === 'Predicate' }, "Predicate"))) : null,
-            showPredicate ? (React.createElement(Tabs_1.Tabs.Content, { value: "Predicate" },
+            showPredicate ? (React.createElement(Tabs_1.Tabs.Content, { "data-name": "Predicate", value: "Predicate" },
                 React.createElement(rebass_1.Text, { fontSize: 2, mb: 2 }, descriptions.selectPredicate),
-                React.createElement(DropdownButton_1.default, { style: {
-                        minWidth: '15rem',
-                        whiteSpace: 'nowrap',
-                        overflow: 'hidden',
-                        textOverflow: 'ellipsis',
-                        maxWidth: 'inherit',
-                    }, placeholder: "Select Rule", showClearButton: !!((_e = data.Rule) === null || _e === void 0 ? void 0 : _e.Predicate), onClear: clearPredicate, items: predicateDefsOptions, columns: ['label'] }, currentPredicateDef ? currentPredicateDef.label : 'Select Rule'), (_f = currentPredicateDef === null || currentPredicateDef === void 0 ? void 0 : currentPredicateDef.inputs) === null || _f === void 0 ? void 0 :
+                React.createElement(DropdownButton_1.default, { "data-name": "entity-rules-editor-predicate-dropdown", className: `${baseClassName}__predicate-dropdown`, placeholder: "Select Rule", showClearButton: !!((_e = data.Rule) === null || _e === void 0 ? void 0 : _e.Predicate), onClear: clearPredicate, items: predicateDefsOptions, columns: ['label'] }, currentPredicateDef ? currentPredicateDef.label : 'Select Rule'), (_f = currentPredicateDef === null || currentPredicateDef === void 0 ? void 0 : currentPredicateDef.inputs) === null || _f === void 0 ? void 0 :
                 _f.map((predicateDefInput, index) => (React.createElement(rebass_1.Flex, { key: predicateId + index, flexDirection: "column" },
                     index > 0 && React.createElement(HelpBlock_1.default, { marginTop: 2 }, "AND"),
                     React.createElement(AdaptableInput_1.default, { marginTop: 2, type: predicateDefInput.type, autoFocus: index === 0, value: predicateInputs[index], onChange: (e) => onPredicateInputChange(e, index) })))),
@@ -189,20 +184,16 @@ const EntityRulesEditor = (props) => {
                         fontSize: 'var(--ab-font-size-3)',
                         padding: 0,
                     } },
-                    React.createElement(ButtonInfo_1.ButtonInfo, { mr: 2, style: {
-                            color: 'var(--ab-color-text-on-add)',
-                            fill: 'var(--ab-color-text-on-add)',
-                            background: 'var(--ab-color-action-add)',
-                        }, onClick: () => window.open(DocumentationLinkConstants_1.PredicateDocsLink, '_blank') }),
+                    React.createElement(ButtonInfo_1.ButtonInfo, { mr: 2, onClick: () => window.open(DocumentationLinkConstants_1.PredicateDocsLink, '_blank') }),
                     "See Predicate documentation for more details and examples")))) : null,
             showBoolean ? React.createElement(QueryTab, { value: "BooleanExpression", type: type, label: "Boolean" }) : null,
-            showBoolean ? (React.createElement(Tabs_1.Tabs.Content, { value: 'BooleanExpression', paddingLeft: 0 },
+            showBoolean ? (React.createElement(Tabs_1.Tabs.Content, { "data-name": "BooleanExpression", value: 'BooleanExpression', paddingLeft: 0 },
                 React.createElement(ExpressionEditor_1.ExpressionEditor, { type: 'boolean', module: module, value: (_h = data.Rule) === null || _h === void 0 ? void 0 : _h.BooleanExpression, onChange: setBooleanExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.queryApi.getAllNamedQuery(), api: api }))) : null,
             showObservable ? (React.createElement(QueryTab, { value: "ObservableExpression", type: type, label: "Observable" })) : null,
-            showObservable ? (React.createElement(Tabs_1.Tabs.Content, { value: 'ObservableExpression', paddingLeft: 0 },
+            showObservable ? (React.createElement(Tabs_1.Tabs.Content, { "data-name": "ObservableExpression", value: 'ObservableExpression', paddingLeft: 0 },
                 React.createElement(ExpressionEditor_1.ExpressionEditor, { type: 'observable', module: module, value: (_j = data.Rule) === null || _j === void 0 ? void 0 : _j.ObservableExpression, onChange: setReactiveExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.queryApi.getAllNamedQuery(), api: api }))) : null,
             showAggregation ? (React.createElement(QueryTab, { value: "AggregatedBooleanExpression", type: type, label: "Aggregated Boolean" })) : null,
-            showAggregation ? (React.createElement(Tabs_1.Tabs.Content, { value: 'AggregatedBooleanExpression', paddingLeft: 0 },
+            showAggregation ? (React.createElement(Tabs_1.Tabs.Content, { "data-name": "AggregatedBooleanExpression", value: 'AggregatedBooleanExpression', paddingLeft: 0 },
                 React.createElement(ExpressionEditor_1.ExpressionEditor, { type: 'aggregatedBoolean', module: module, value: (_k = data.Rule) === null || _k === void 0 ? void 0 : _k.AggregatedBooleanExpression, onChange: setAggregationExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.queryApi.getAllNamedQuery(), api: api }))) : null)));
 };
 exports.EntityRulesEditor = EntityRulesEditor;