@adaptabletools/adaptable 18.1.0 → 18.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "18.1.0",
+  "version": "18.1.1",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableOptions/ColumnFilterOptions.d.ts

@@ -258,7 +258,13 @@ export interface ColumnFilterContext<TData = any> extends BaseContext {
  * Context used for setting whether a Row can be Column Filtered
  */
 export interface IsRowFilterableContext<TData = any> extends BaseContext {
+    /**
+     * The Row Node about to be evaluated
+     */
     rowNode: IRowNode;
+    /**
+     * The data in the Row Node
+     */
     data: TData;
 }
 /**

package/src/AdaptableOptions/ExportOptions.d.ts

@@ -211,7 +211,16 @@ export interface DataFormatTypeContext extends BaseContext {
  * Defines the Format Data Types for all Data Types
  */
 export interface DataFormatDataType {
+    /**
+     * Data Format type for String columns
+     */
     string?: DataFormatType;
+    /**
+     * Data Format type for Number columns
+     */
     number?: DataFormatType;
+    /**
+     * Data Format type for Date columns
+     */
     date?: DataFormatType;
 }

package/src/AdaptableOptions/ExpressionOptions.d.ts

@@ -2,7 +2,7 @@ import { AdaptablePredicate } from '../PredefinedConfig/Common/AdaptablePredicat
 import { AdaptableModule, AdaptableQLModule } from '../PredefinedConfig/Common/Types';
 import { BaseContext } from '../PredefinedConfig/Common/BaseContext';
 import { AdaptableColumn, AdaptableColumnBase } from '../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableObject, AggregatedBooleanFunctionName, AggregatedScalarExpressionFunction, AggregatedScalarFunctionName, BooleanFunctionName, ExpressionFunction, ObservableFunctionName, ScalarFunctionName, AdaptableField } from '../types';
+import { AdaptableObject, AggregatedBooleanFunctionName, AggregatedExpressionFunction, AggregatedScalarFunctionName, BooleanFunctionName, ExpressionFunction, ObservableFunctionName, ScalarFunctionName, AdaptableField } from '../types';
 /**
  * Options for managing Expressions in AdapTable's Query Language
  */
@@ -64,7 +64,7 @@ export interface ExpressionOptions<TData = any> {
     /**
      * Bespoke Aggregated Scalar functions - to complement those provided by AdapTable
      */
-    customAggregatedScalarFunctions?: Record<string, AggregatedScalarExpressionFunction> | ((context: GlobalExpressionFunctionsContext<string>) => Record<string, AggregatedScalarExpressionFunction>);
+    customAggregatedFunctions?: Record<string, AggregatedExpressionFunction> | ((context: GlobalExpressionFunctionsContext<string>) => Record<string, AggregatedExpressionFunction>);
     /**
      * Module-specific Expression Functions available
      *

package/src/Api/Internal/AlertInternalApi.js

@@ -662,8 +662,8 @@ export class AlertInternalApi extends ApiBase {
             (_a = (dataChangeTriggerMap[context.trigger] || rowChangeTriggerMap[context.trigger])) !== null && _a !== void 0 ? _a : context.trigger;
             text = this.replaceAll(text, '[trigger]', mappedTrigger);
         }
-        if ((context === null || context === void 0 ? void 0 : context.column) && (context === null || context === void 0 ? void 0 : context.rowNode)) {
-            text = this.replaceAll(text, '[column]', this.getGridApi().getRawValueFromRowNode(context.rowNode, context.column.columnId));
+        if (context === null || context === void 0 ? void 0 : context.column) {
+            text = this.replaceAll(text, '[column]', this.getColumnApi().getFriendlyNameForColumnId(context.column.columnId));
         }
         if (context === null || context === void 0 ? void 0 : context.rowNode) {
             const columns = this.extractColsFromText(text);

package/src/Utilities/Constants/DocumentationLinkConstants.d.ts

@@ -12,3 +12,4 @@ export declare const PrimaryKeyDocsLink: string;
 export declare const LicenseDocsLink: string;
 export declare const AdaptableOptionsDocsLink: string;
 export declare const AgGridModulesDocsLink: string;
+export declare const AlertMessageDocsLink: string;

package/src/Utilities/Constants/DocumentationLinkConstants.js

@@ -13,3 +13,4 @@ export const PrimaryKeyDocsLink = `${HOST_URL_DOCS}/guide/getting-started-primar
 export const LicenseDocsLink = `${HOST_URL_DOCS}/guide/licensing`;
 export const AdaptableOptionsDocsLink = `${HOST_URL_DOCS}/guide/reference-options-overview`;
 export const AgGridModulesDocsLink = `${HOST_URL_DOCS}/guide/dev-guide-aggrid-modules-overview`;
+export const AlertMessageDocsLink = `${HOST_URL_DOCS}/guide/handbook-alerting-message`;

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -358,7 +358,6 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
             if (gridCounter === counterLimit) {
                 // reset counter
                 counter = 0;
-                console.log('reset counter');
             }
             return gridCounter;
         }));

package/src/Utilities/Services/QueryLanguageService.js

@@ -332,7 +332,7 @@ export class QueryLanguageService {
     }
     getCustomAggregatedScalarFunctions() {
         var _a;
-        const customAggregatedScalarFunctions = (_a = this.adaptableApi.optionsApi.getExpressionOptions()) === null || _a === void 0 ? void 0 : _a.customAggregatedScalarFunctions;
+        const customAggregatedScalarFunctions = (_a = this.adaptableApi.optionsApi.getExpressionOptions()) === null || _a === void 0 ? void 0 : _a.customAggregatedFunctions;
         if (!customAggregatedScalarFunctions) {
             return {};
         }
@@ -351,21 +351,22 @@ export class QueryLanguageService {
         return Object.entries(aggregatedScalarFunctions).reduce((acc, [expressionName, customExpressionDefinition]) => {
             const expression = {
                 handler: (args, context) => {
-                    // There is built in support for column validation
-                    // TODO: change to extractParameters
-                    // { colArgs: { [colId]: value } }
                     const [aggColParam, ...restOfColParams] = extractColumnParameters(expressionName, args);
                     const aggColumnId = aggColParam === null || aggColParam === void 0 ? void 0 : aggColParam.value;
                     const groupByParameter = extractParameter(expressionName, 'operand', ['GROUP_BY'], args, {
                         isOptional: true,
                     });
-                    const preparedArgs = args.filter((arg) => {
+                    const groupByColumnIds = groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value;
+                    const contextArgs = args.filter((arg) => {
                         if (typeof arg === 'object' && arg.name === 'COL') {
-                            // filter out only first col
+                            // filter out aggregation column
                             return arg.value !== aggColumnId;
                         }
-                        // filter out all other objects, e.g. GROUP_BY
-                        return typeof arg !== 'object';
+                        if (typeof arg === 'object' && arg.name === 'GROUP_BY') {
+                            // filter out groupBy column
+                            return false;
+                        }
+                        return true;
                     });
                     const aggregationExpressionEvaluation = {
                         aggregationParams: {
@@ -375,18 +376,20 @@ export class QueryLanguageService {
                                     field: aggColumnId,
                                     initialValue: customExpressionDefinition.initialValue,
                                     reducer: (acc, value, rowNode, dataIndex) => {
-                                        const context = Object.assign({ rowNode, args: preparedArgs.map((arg) => {
+                                        const context = Object.assign({ rowNode, args: contextArgs.map((arg) => {
                                                 // if col, replace with value
                                                 if (typeof arg === 'object' && arg.name === 'COL') {
                                                     return getValueForColId(arg.value, rowNode);
                                                 }
                                                 return arg;
-                                            }), aggColumnId, getValueForColId: (colId) => getValueForColId(colId, rowNode) }, createBaseContext(this.adaptableApi));
+                                            }), aggColumnId,
+                                            groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) }, createBaseContext(this.adaptableApi));
                                         return customExpressionDefinition.reducer(acc, value, dataIndex, context);
                                     },
                                     done: (accValue, dataArray) => {
-                                        if (customExpressionDefinition.processReducerValue) {
-                                            return customExpressionDefinition.processReducerValue(accValue, dataArray, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { args }));
+                                        if (customExpressionDefinition.processAggregatedValue) {
+                                            return customExpressionDefinition.processAggregatedValue(accValue, dataArray, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { args: contextArgs, aggColumnId,
+                                                groupByColumnIds }));
                                         }
                                         return accValue;
                                     },
@@ -395,15 +398,28 @@ export class QueryLanguageService {
                         },
                         rowValueGetter: (rowNode, aggregationValue) => {
                             if (customExpressionDefinition.prepareRowValue) {
-                                return customExpressionDefinition.prepareRowValue(rowNode, aggregationValue, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { aggColumnId,
-                                    args, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
+                                return customExpressionDefinition.prepareRowValue(rowNode, aggregationValue, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { args: contextArgs.map((arg) => {
+                                        // if col, replace with value
+                                        if (typeof arg === 'object' && arg.name === 'COL') {
+                                            return getValueForColId(arg.value, rowNode);
+                                        }
+                                        return arg;
+                                    }), aggColumnId,
+                                    groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
                             }
                             return aggregationValue;
                         },
                         rowFilterFn: (rowNode) => {
                             var _a, _b;
                             if (customExpressionDefinition.rowFilter) {
-                                return customExpressionDefinition.rowFilter(rowNode, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { aggColumnId, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
+                                return customExpressionDefinition.rowFilter(rowNode, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { args: contextArgs.map((arg) => {
+                                        // if col, replace with value
+                                        if (typeof arg === 'object' && arg.name === 'COL') {
+                                            return getValueForColId(arg.value, rowNode);
+                                        }
+                                        return arg;
+                                    }), aggColumnId,
+                                    groupByColumnIds, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
                             }
                             return (_b = (_a = context === null || context === void 0 ? void 0 : context.filterFn) === null || _a === void 0 ? void 0 : _a.call(context, rowNode)) !== null && _b !== void 0 ? _b : true;
                         },

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

@@ -4,8 +4,11 @@ import Radio, { RadioGroup } from '../../../components/Radio';
 import { useOnePageAdaptableWizardContext } from '../../Wizard/OnePageAdaptableWizard';
 import { Text } from 'rebass';
 import { CodeBlock } from '../../../components/CodeBlock';
-import AdaptableInput from '../../Components/AdaptableInput';
 import FormLayout, { FormRow } from '../../../components/FormLayout';
+import { ButtonInfo } from '../../Components/Buttons/ButtonInfo';
+import { AlertMessageDocsLink } from '../../../Utilities/Constants/DocumentationLinkConstants';
+import Textarea from '../../../components/Textarea';
+import HelpBlock from '../../../components/HelpBlock';
 export const renderAlertMessageSummary = () => {
     const { data } = useOnePageAdaptableWizardContext();
     return (React.createElement(Text, { fontSize: 2 },
@@ -43,9 +46,15 @@ export const AlertMessageWizardSection = (props) => {
                 ' ',
                 React.createElement(FormLayout, null,
                     React.createElement(FormRow, { label: "Header" },
-                        React.createElement(AdaptableInput, { minWidth: 250, placeholder: "use defaults", marginTop: 2, type: 'text', autoFocus: false, value: messageHeader !== null && messageHeader !== void 0 ? messageHeader : '', 
+                        React.createElement(Textarea, { minWidth: 300, rows: 3, placeholder: "use defaults", marginTop: 2, type: 'text', autoFocus: false, value: messageHeader !== null && messageHeader !== void 0 ? messageHeader : '', 
                             // placeholder="defaults to column name"
                             onChange: (e) => onMessageHeaderChange(e) })),
                     React.createElement(FormRow, { label: "Message" },
-                        React.createElement(AdaptableInput, { minWidth: 250, marginTop: 2, type: 'text', autoFocus: false, value: messageText !== null && messageText !== void 0 ? messageText : '', onChange: (e) => onMessageTextChange(e) })))))));
+                        React.createElement(Textarea, { minWidth: 300, rows: 3, marginTop: 2, type: 'text', autoFocus: false, value: messageText !== null && messageText !== void 0 ? messageText : '', onChange: (e) => onMessageTextChange(e) }))),
+                React.createElement(HelpBlock, { "data-name": "alert-message-documentation", mt: 3, mb: 2, style: {
+                        fontSize: 'var(--ab-font-size-3)',
+                        padding: 0,
+                    } },
+                    React.createElement(ButtonInfo, { mr: 2, onClick: () => window.open(AlertMessageDocsLink, '_blank') }),
+                    "See Alert Message documentation for more details and examples")))));
 };

package/src/agGrid/AdaptableAgGrid.js

@@ -1365,7 +1365,7 @@ export class AdaptableAgGrid {
          */
         this.agGridAdapter.getAgGridApi().addEventListener(Events.EVENT_FIRST_DATA_RENDERED, (this.listenerFirstDataRendered = () => {
             if (this.initWithLazyData) {
-                this.updateColumnModelAndRefreshGrid();
+                this.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
                 this.api.calculatedColumnApi.refreshAggregatedCalculatedColumns();
                 this._emit('FirstDataRendered');
             }

package/src/agGrid/editors/AdaptableNumberEditor/index.d.ts

@@ -19,25 +19,7 @@ export interface AdaptableNumberCellEditorParams extends ICellEditorParams {
 }
 export declare const AdaptableReactNumberEditor: React.ForwardRefExoticComponent<AdaptableNumberCellEditorParams & React.RefAttributes<unknown>>;
 /**
- * Used by default for all `abColDefNumber` columns.
- *
- * You can configure it by specifying `cellEditorParams` in the colDef:
- *
- * colDef {
- *   field: 'stars',
- *   type: 'abColDefNumber',
- *   cellEditorParams: {
- *     emptyValue: 5, // defaults to ''
- *     showClearButton: false
- *   }
- * }
- *
- * For now, there are 2 editor params you can configure:
- *
- * cellEditorParams.showClearButton - defaults to `true` - whether to show the clear button. If `true`, it works together with `cellEditorParams.emptyValue`
- * cellEditorParams.emptyValue - defaults to `''` (empty string) - value to set for the cell, when the clear button is pressed.
- *
- * When the colDef has a `valueParser` provided as a function, it will be used before setting the value for the cell.
+ * Number Editor provided by AdapTable and used by default for all `abColDefNumber` columns
  */
 export declare class AdaptableNumberEditor implements ICellEditorComp {
     private value;

package/src/agGrid/editors/AdaptableNumberEditor/index.js

@@ -77,25 +77,7 @@ export const AdaptableReactNumberEditor = forwardRef((props, ref) => {
 });
 AdaptableReactNumberEditor.displayName = 'AdaptableReactNumberEditor';
 /**
- * Used by default for all `abColDefNumber` columns.
- *
- * You can configure it by specifying `cellEditorParams` in the colDef:
- *
- * colDef {
- *   field: 'stars',
- *   type: 'abColDefNumber',
- *   cellEditorParams: {
- *     emptyValue: 5, // defaults to ''
- *     showClearButton: false
- *   }
- * }
- *
- * For now, there are 2 editor params you can configure:
- *
- * cellEditorParams.showClearButton - defaults to `true` - whether to show the clear button. If `true`, it works together with `cellEditorParams.emptyValue`
- * cellEditorParams.emptyValue - defaults to `''` (empty string) - value to set for the cell, when the clear button is pressed.
- *
- * When the colDef has a `valueParser` provided as a function, it will be used before setting the value for the cell.
+ * Number Editor provided by AdapTable and used by default for all `abColDefNumber` columns
  */
 export class AdaptableNumberEditor {
     constructor() {

package/src/agGrid/editors/AdaptablePercentageEditor/InternalAdaptablePercentageEditor.d.ts

@@ -5,7 +5,7 @@ export type InternalAdaptablePercentageEditorApi = {
 };
 export type InternalAdaptablePercentageEditorProps = {
     /**
-     * Value to set when the x (when showClear: true) is pressed
+     * Value to set when the Clear button is clicked
      */
     emptyValue?: string | number;
     defaultValue?: string | number;
@@ -15,7 +15,7 @@ export type InternalAdaptablePercentageEditorProps = {
      */
     type?: string;
     /**
-     * Whether to show the clear button. Defaults to false
+     * Whether to show the Clear button; defaults to true
      */
     showClearButton?: boolean;
     onValueChange?: (value: string | number) => void;

package/src/agGrid/editors/AdaptablePercentageEditor/index.d.ts

@@ -2,31 +2,13 @@ import * as React from 'react';
 import { ICellEditorComp } from '@ag-grid-community/core';
 import { AdaptableNumberCellEditorParams } from '../AdaptableNumberEditor';
 /**
- * Adaptable percentage editor parameters extending the number editor params.
+ * AdapTablePercentageCellEditor parameters - extends AdaptableNumberCellEditorParams
  */
 export interface AdaptablePercentageCellEditorParams extends AdaptableNumberCellEditorParams {
 }
 export declare const AdaptableReactPercentageEditor: React.ForwardRefExoticComponent<AdaptablePercentageCellEditorParams & React.RefAttributes<unknown>>;
 /**
- * Used by default for all `abColDefNumber` columns.
- *
- * You can configure it by specifying `cellEditorParams` in the colDef:
- *
- * colDef {
- *   field: 'stars',
- *   type: 'abColDefNumber',
- *   cellEditorParams: {
- *     emptyValue: 5, // defaults to ''
- *     showClearButton: false
- *   }
- * }
- *
- * For now, there are 2 editor params you can configure:
- *
- * cellEditorParams.showClearButton - defaults to `true` - whether to show the clear button. If `true`, it works together with `cellEditorParams.emptyValue`
- * cellEditorParams.emptyValue - defaults to `''` (empty string) - value to set for the cell, when the clear button is pressed.
- *
- * When the colDef has a `valueParser` provided as a function, it will be used before setting the value for the cell.
+ * Used to edit percentage columns as percentages (similar to how its done in Excel)
  */
 export declare class AdaptablePercentageEditor implements ICellEditorComp {
     private value;

package/src/agGrid/editors/AdaptablePercentageEditor/index.js

@@ -62,25 +62,7 @@ export const AdaptableReactPercentageEditor = forwardRef((props, ref) => {
 });
 AdaptableReactPercentageEditor.displayName = 'AdaptableReactPercentageEditor';
 /**
- * Used by default for all `abColDefNumber` columns.
- *
- * You can configure it by specifying `cellEditorParams` in the colDef:
- *
- * colDef {
- *   field: 'stars',
- *   type: 'abColDefNumber',
- *   cellEditorParams: {
- *     emptyValue: 5, // defaults to ''
- *     showClearButton: false
- *   }
- * }
- *
- * For now, there are 2 editor params you can configure:
- *
- * cellEditorParams.showClearButton - defaults to `true` - whether to show the clear button. If `true`, it works together with `cellEditorParams.emptyValue`
- * cellEditorParams.emptyValue - defaults to `''` (empty string) - value to set for the cell, when the clear button is pressed.
- *
- * When the colDef has a `valueParser` provided as a function, it will be used before setting the value for the cell.
+ * Used to edit percentage columns as percentages (similar to how its done in Excel)
  */
 export class AdaptablePercentageEditor {
     constructor() {

package/src/components/ExpressionEditor/QueryBuilder/QueryBuilderInputs.js

@@ -161,7 +161,7 @@ export const PrimiteValueInput = (props) => {
         editor));
 };
 export const PrimitiveMultiValueInput = (props) => {
-    return (React.createElement(PermittedValuesSelector, { isMulti: true, allowNewValues: true, value: props.value, columnId: props.lefthandColumnIdParam, onChange: (value) => {
+    return (React.createElement(PermittedValuesSelector, { isMulti: true, allowNewValues: true, value: props.value, columnId: mapColumnExpressionToColumnId(props.lefthandColumnIdParam), onChange: (value) => {
             props.onChange(value);
         } }));
 };

package/src/components/ExpressionEditor/QueryBuilder/QueryPredicateBuilder.js

@@ -151,18 +151,18 @@ const PrimitiveFunctionEditor = (props) => {
                     }, value: props.predicate.operator })),
                 React.createElement(Flex, { flex: 1, ml: 2 }, restOfFunctionInputDataTypes.map((type, index) => {
                     var _a;
+                    const key = type + index;
                     const commonProps = {
-                        key: type + index,
                         lefthandColumnIdParam: columnOrFieldId,
                         inputType: type,
                     };
                     if (type.includes('[]')) {
-                        return (React.createElement(PrimitiveMultiValueInput, Object.assign({}, commonProps, { value: restOfArgs, onChange: (values) => {
+                        return (React.createElement(PrimitiveMultiValueInput, Object.assign({}, commonProps, { key: key, value: restOfArgs, onChange: (values) => {
                                 const args = [...props.predicate.args.slice(0, 1), ...values];
                                 props.onChange(Object.assign(Object.assign({}, props.predicate), { args }));
                             } })));
                     }
-                    return (React.createElement(PrimiteValueInput, Object.assign({}, commonProps, { value: (_a = restOfArgs[index]) !== null && _a !== void 0 ? _a : null, onChange: (value) => {
+                    return (React.createElement(PrimiteValueInput, Object.assign({}, commonProps, { key: key, value: (_a = restOfArgs[index]) !== null && _a !== void 0 ? _a : null, onChange: (value) => {
                             const args = [...props.predicate.args];
                             // +1 because col is the first argument
                             args[index + 1] = value;

package/src/env.js

@@ -1,5 +1,5 @@
 export default {
     INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1717156602322 || Date.now(),
-    VERSION: "18.1.0" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1718271522875 || Date.now(),
+    VERSION: "18.1.1" || '--current-version--',
 };

package/src/metamodel/adaptable.metamodel.d.ts

@@ -2623,6 +2623,13 @@ export declare const ADAPTABLE_METAMODEL: {
         name: string;
         kind: string;
         desc: string;
+        props: {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref: string;
+        }[];
     };
     DataFormatType: {
         name: string;
@@ -3791,6 +3798,17 @@ export declare const ADAPTABLE_METAMODEL: {
         name: string;
         kind: string;
         desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            ref: string;
+        })[];
     };
     Layout: {
         name: string;