@adaptabletools/adaptable 16.1.1-canary.1 → 16.2.0-canary.0

package/src/Strategy/AlertModule.js

@@ -7,7 +7,6 @@ const SystemRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/Syste
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
-const ObjectFactory_1 = tslib_1.__importDefault(require("../Utilities/ObjectFactory"));
 const AlertWizard_1 = require("../View/Alert/Wizard/AlertWizard");
 const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
 const getRuleViewItems_1 = require("./Utilities/getRuleViewItems");
@@ -154,41 +153,25 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
     }
     handleGridDataChanged(gridDataChangedInfo) {
-        const internalAlertApi = this.api.alertApi.internalApi;
         const alertDefinitions = this.getAlertDefinitionsForGridDataChange(gridDataChangedInfo);
-        const rowAdded = gridDataChangedInfo.rowTrigger === 'Add';
-        const numberOfChangedRows = gridDataChangedInfo.rowNodes.length;
-        const actionName = rowAdded ? 'Added' : 'Removed';
-        const alertHeader = numberOfChangedRows > 1 ? `${actionName} Rows` : `${actionName} Row `;
-        const defaultMessage = numberOfChangedRows > 1
-            ? `${numberOfChangedRows} rows were ${actionName.toLowerCase()}`
-            : `${numberOfChangedRows} row was ${actionName.toLowerCase()}`;
-        alertDefinitions === null || alertDefinitions === void 0 ? void 0 : alertDefinitions.forEach((alertDefinition) => {
-            if (internalAlertApi.shouldFireAlertOnClient(alertDefinition)) {
-                const customMessage = internalAlertApi.getCustomAlertDescription(alertDefinition, {
-                    gridDataChangedInfo,
-                });
-                const customHeader = internalAlertApi.getCustomAlertMessageHeader(alertDefinition, {
-                    gridDataChangedInfo,
-                });
-                const alertMessage = alertDefinition.MessageText
-                    ? alertDefinition.MessageText
-                    : customMessage !== null && customMessage !== void 0 ? customMessage : defaultMessage;
-                const alert = ObjectFactory_1.default.CreateRowChangedAlert(customHeader !== null && customHeader !== void 0 ? customHeader : alertHeader, alertMessage, alertDefinition, gridDataChangedInfo);
-                this.api.alertApi.showAdaptableAlert(alert);
-            }
-        });
+        this.api.alertApi.internalApi.showAlertsForGridDataChanges(gridDataChangedInfo, alertDefinitions);
     }
     handleReactiveAlertTriggered(reactiveAlertInfo) {
         // TODO  - suppress Notification if alert is not relevant for layout
         var _a;
-        // the row node data is most probably stale because the reactive queries buffer the changed data
-        // so we have to refresh it
-        reactiveAlertInfo.dataChangeLogEntry.rowNode = this.api.gridApi.getRowNodeForPrimaryKey(reactiveAlertInfo.dataChangeLogEntry.primaryKeyValue);
-        reactiveAlertInfo.dataChangeLogEntry.rowData =
-            (_a = reactiveAlertInfo.dataChangeLogEntry.rowNode) === null || _a === void 0 ? void 0 : _a.data;
-        if (reactiveAlertInfo.type === 'alert') {
-            this.api.alertApi.internalApi.showAlertForDefinitions(reactiveAlertInfo.dataChangeLogEntry, [
+        if (reactiveAlertInfo.type === 'cellDataChangedAlert') {
+            // the row node data is most probably stale because the reactive queries buffer the changed data
+            // so we have to refresh it
+            reactiveAlertInfo.cellChangeLogEntry.rowNode = this.api.gridApi.getRowNodeForPrimaryKey(reactiveAlertInfo.cellChangeLogEntry.primaryKeyValue);
+            reactiveAlertInfo.cellChangeLogEntry.rowData =
+                (_a = reactiveAlertInfo.cellChangeLogEntry.rowNode) === null || _a === void 0 ? void 0 : _a.data;
+            this.api.alertApi.internalApi.showAlertForDefinitions(reactiveAlertInfo.cellChangeLogEntry, [
+                reactiveAlertInfo.alertDefinition,
+            ]);
+        }
+        else {
+            // reactiveAlertInfo.type === gridDataChangedAlert'
+            this.api.alertApi.internalApi.showAlertForDefinitions(reactiveAlertInfo.gridChangeLogEntry, [
                 reactiveAlertInfo.alertDefinition,
             ]);
         }

package/src/Utilities/Defaults/DefaultAdaptableOptions.js

@@ -40,7 +40,9 @@ exports.DefaultAdaptableOptions = {
         showSystemStatusMessageNotifications: false,
         maxSystemMessagesInStore: 100,
     },
-    dataImportOptions: {},
+    dataImportOptions: {
+        fileHandlers: undefined,
+    },
     flashingCellOptions: {
         defaultFlashDuration: 500,
         defaultFlashTarget: 'cell',

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.d.ts

@@ -2,6 +2,7 @@ import { ExpressionContext } from '../../parser/src/types';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { Observable } from 'rxjs';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridDataChangedInfo } from '../../types';
 export interface BaseParameter<T = string, N = string> {
     type: T;
     name: N;
@@ -13,6 +14,7 @@ export declare const getStringValues: (context: ExpressionContext, ...stringArgu
 export declare const getStringValue: (context: ExpressionContext, stringArgument: string) => string;
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
+export declare const getGridChangeLog$: (context: ExpressionContext, gridChangeType: GridDataChangedInfo['rowTrigger']) => Observable<GridDataChangedInfo>;
 export declare const handleWhereFunction: (args: ExpressionNode[], context: ExpressionContext) => any;
 export declare type ExpressionNode = any;
 export declare const evaluateExpressionNode: (expressionNode: ExpressionNode, context: ExpressionContext, filterFn?: (item: any) => boolean) => any;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.evaluateExpressionNode = exports.handleWhereFunction = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
+exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.evaluateExpressionNode = exports.handleWhereFunction = exports.getGridChangeLog$ = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
 const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
@@ -29,11 +29,23 @@ const getDataChangeLog$ = (context, columnNameFilter) => {
     dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
     // filter based on the WHERE clause
     if (context.filterFn) {
-        dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((value) => context.filterFn(value.rowNode)));
+        dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((value) => {
+            return context.filterFn(value.rowNode);
+        }));
     }
     return dataChangeLog$;
 };
 exports.getDataChangeLog$ = getDataChangeLog$;
+const getGridChangeLog$ = (context, gridChangeType) => {
+    const gridChangeLog$ = context.adaptableApi.internalApi.getDataService().gridChangeLog$;
+    let gridChangeStream$ = gridChangeLog$.pipe((0, operators_1.filter)((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
+    // filter based on the WHERE clause
+    if (context.filterFn) {
+        gridChangeStream$ = gridChangeStream$.pipe((0, operators_1.filter)((value) => value.rowNodes.some((node) => context.filterFn(node))));
+    }
+    return gridChangeStream$;
+};
+exports.getGridChangeLog$ = getGridChangeLog$;
 const handleWhereFunction = (args, context) => {
     const reactiveExpressionNode = args[0];
     const whereClauseExpressionNode = args[1];

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.d.ts

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Observable Functions available in AdaptableQL
  */
-export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | 'ROW_CHANGE' | 'GRID_CHANGE' | 'MAX' | 'MIN' | 'NONE' | 'COUNT';
+export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | 'ROW_CHANGE' | 'ROW_ADDED' | 'GRID_CHANGE' | 'ROW_REMOVED' | 'MAX' | 'MIN' | 'NONE' | 'COUNT';
 export declare const observableExpressionFunctions: Record<ObservableFunctionName, ExpressionFunction>;
 export declare const observableExpressionFunctionNames: ObservableFunctionName[];

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -91,7 +91,7 @@ exports.observableExpressionFunctions = {
                     (0, operators_1.debounceTime)(timeframeParameter.value), 
                     // completing the observable (ex. alert deletion) will also fire the NONE event
                     // takeUntil takes care of this, ignoring any emissions as soon as the source completes
-                    // (count() result is irrelevant here, the main thing is that it emits an source completion)
+                    // (count() result is irrelevant here, the main thing is that it emits a source completion)
                     (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
                 }
             }
@@ -105,6 +105,48 @@ exports.observableExpressionFunctions = {
         ],
         category: 'observable',
     },
+    ROW_ADDED: {
+        handler(args, context) {
+            const gridChangeLog$ = (0, expressionFunctionUtils_1.getGridChangeLog$)(context, 'Add');
+            return handleGridRowAddedOrRemoved(args, gridChangeLog$, 'ROW_ADDED', context);
+        },
+        returnType: 'boolean',
+        description: 'Observes added rows in the grid',
+        signatures: [
+            'ROW_ADDED()',
+            'ROW_ADDED(rowCount: number)',
+            'ROW_ADDED(timeframe:TIMEFRAME)',
+            'ROW_ADDED(rowCount: number, timeframe:TIMEFRAME)',
+        ],
+        examples: [
+            'ROW_ADDED()',
+            'ROW_ADDED(2)',
+            "ROW_ADDED(TIMEFRAME('20s'))",
+            "ROW_ADDED(2, TIMEFRAME('20s'))",
+        ],
+        category: 'observable',
+    },
+    ROW_REMOVED: {
+        handler(args, context) {
+            const gridChangeLog$ = (0, expressionFunctionUtils_1.getGridChangeLog$)(context, 'Delete');
+            return handleGridRowAddedOrRemoved(args, gridChangeLog$, 'ROW_REMOVED', context);
+        },
+        returnType: 'boolean',
+        description: 'Observes removed rows in the grid',
+        signatures: [
+            'ROW_REMOVED()',
+            'ROW_REMOVED(rowCount: number)',
+            'ROW_REMOVED(timeframe:TIMEFRAME)',
+            'ROW_REMOVED(rowCount: number, timeframe:TIMEFRAME)',
+        ],
+        examples: [
+            'ROW_REMOVED()',
+            'ROW_REMOVED(2)',
+            "ROW_REMOVED(TIMEFRAME('20s'))",
+            "ROW_REMOVED(2, TIMEFRAME('20s'))",
+        ],
+        category: 'observable',
+    },
     COL: {
         handler(args, context) {
             return (0, expressionFunctionUtils_1.handleColumnFunction)(args, context);
@@ -320,6 +362,7 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
             if (gridCounter === counterLimit) {
                 // reset counter
                 counter = 0;
+                console.log('reset counter');
             }
             return gridCounter;
         }));
@@ -434,3 +477,52 @@ const getMaxTimeframeSize = (expressionValue, context) => {
     }
     return expressionValue > maxTimeframeSize ? maxTimeframeSize : expressionValue;
 };
+const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, context) => {
+    let countValue = args.find((arg) => typeof arg === 'number');
+    if (countValue < 0) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, 'supports only zero or a positive number as argument');
+    }
+    let timeframeParameter = (0, expressionFunctionUtils_1.extractParameter)(consumingFunction, 'config', ['TIMEFRAME'], args, { isOptional: true });
+    if (countValue === 0 && timeframeParameter == null) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, 'requires a TIMEFRAME parameter when observing for no changes');
+    }
+    if (countValue == null && timeframeParameter == null) {
+        // default - return all new rows
+        return gridChangeLog$;
+    }
+    if (countValue == null) {
+        // default count value of 1
+        countValue = 1;
+    }
+    if (timeframeParameter == null) {
+        // default time parameter of max
+        timeframeParameter = {
+            name: 'TIMEFRAME',
+            type: 'config',
+            value: SYSTEM_MAX_TIMEFRAME_SIZE,
+        };
+    }
+    if (countValue === 0) {
+        // handle special case when observing NO changes
+        const gridDataChangeInfoStub = {
+            rowTrigger: consumingFunction === 'ROW_ADDED' ? 'Add' : 'Delete',
+            rowNodes: [],
+            dataRows: [],
+            changedAt: Date.now(),
+            adaptableId: context.adaptableId,
+            adaptableApi: context.adaptableApi,
+            userName: context.userName,
+        };
+        return gridChangeLog$.pipe(
+        // add a synthetic first value to ensure the grid is observed even when there are no changes
+        (0, operators_1.startWith)(gridDataChangeInfoStub), 
+        // wait for the given time
+        (0, operators_1.debounceTime)(timeframeParameter.value), 
+        // completing the observable (ex. alert deletion) will also fire the NONE event
+        // takeUntil takes care of this, ignoring any emissions as soon as the source completes
+        // (count() result is irrelevant here, the main thing is that it emits a source completion)
+        (0, operators_1.takeUntil)(gridChangeLog$.pipe((0, operators_1.count)())));
+    }
+    const timeframeChange$ = getTrailingGridCountChange$(gridChangeLog$, timeframeParameter.value, countValue);
+    return getDataChangeCount$(gridChangeLog$, timeframeChange$, countValue);
+};

package/src/Utilities/Services/AlertService.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlertService = void 0;
 const tslib_1 = require("tslib");
+const IAlertService_1 = require("./Interface/IAlertService");
 const Emitter_1 = tslib_1.__importDefault(require("../Emitter"));
 const rxjs_1 = require("rxjs");
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
@@ -36,12 +37,18 @@ class AlertService {
         const reactiveAlertSubscription = (0, rxjs_1.combineLatest)([
             (0, rxjs_1.of)(alertDefinition),
             reactiveExpressionObservable,
-        ]).subscribe(([alertDefinition, dataChangeLogEntry]) => {
-            const reactiveAlertInfo = {
-                alertDefinition: alertDefinition,
-                dataChangeLogEntry,
-                type: 'alert',
-            };
+        ]).subscribe(([alertDefinition, changeLogEntry]) => {
+            const reactiveAlertInfo = (0, IAlertService_1.isGridDataChangedInfo)(changeLogEntry)
+                ? {
+                    alertDefinition,
+                    type: 'gridDataChangedAlert',
+                    gridChangeLogEntry: changeLogEntry,
+                }
+                : {
+                    alertDefinition,
+                    type: 'cellDataChangedAlert',
+                    cellChangeLogEntry: changeLogEntry,
+                };
             this.emitter.emitSync('ReactiveAlertTriggered', reactiveAlertInfo);
         });
         this.reactiveAlertsMap.set(alertDefinition.Uuid, {

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

@@ -3,11 +3,14 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { EmitterCallback } from '../../Utilities/Emitter';
 import { Observable } from 'rxjs';
+import { GridDataChangedInfo } from '../../types';
 export declare class DataService implements IDataService {
     private adaptable;
     private emitter;
     private dataChangeLogSubject$;
     dataChangeLog$: Observable<CellDataChangedInfo>;
+    private gridChangeLogSubject$;
+    gridChangeLog$: Observable<GridDataChangedInfo>;
     private undoChangeLog;
     private undoChangeTimers;
     constructor(adaptable: IAdaptable);
@@ -15,9 +18,9 @@ export declare class DataService implements IDataService {
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     emit: (eventName: string, data?: any) => Promise<any>;
     CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    CreateGridChangedEvent(gridDataChangedInfo: GridDataChangedInfo): void;
     logUndoChange(change: CellDataChangedInfo): void;
     extractUndoChange(change: CellDataChangedInfo): CellDataChangedInfo | undefined;
     private getUndoChangeKey;
-    private logDataChange;
     private extractDataChangeLogEntry;
 }

package/src/Utilities/Services/DataService.js

@@ -16,6 +16,8 @@ class DataService {
         this.emitter = new Emitter_1.default();
         this.dataChangeLogSubject$ = new rxjs_1.Subject();
         this.dataChangeLog$ = this.dataChangeLogSubject$.asObservable();
+        this.gridChangeLogSubject$ = new rxjs_1.Subject();
+        this.gridChangeLog$ = this.gridChangeLogSubject$.asObservable();
         this.undoChangeLog = new Map();
         this.undoChangeTimers = new Map();
     }
@@ -25,6 +27,9 @@ class DataService {
         this.dataChangeLogSubject$.complete();
         this.dataChangeLogSubject$ = null;
         this.dataChangeLog$ = null;
+        this.gridChangeLogSubject$.complete();
+        this.gridChangeLogSubject$ = null;
+        this.gridChangeLog$ = null;
         this.undoChangeLog.clear();
         this.undoChangeLog = null;
         this.undoChangeTimers.clear();
@@ -34,9 +39,13 @@ class DataService {
         if (cellDataChangedInfo.newValue != cellDataChangedInfo.oldValue) {
             this.emitter.emitSync('CellDataChanged', cellDataChangedInfo);
             this.adaptable.api.gridApi.internalApi.fireCellChangedEvent(cellDataChangedInfo);
-            this.logDataChange(cellDataChangedInfo);
+            const dataChangeLogEntry = this.extractDataChangeLogEntry(cellDataChangedInfo);
+            this.dataChangeLogSubject$.next(dataChangeLogEntry);
         }
     }
+    CreateGridChangedEvent(gridDataChangedInfo) {
+        this.gridChangeLogSubject$.next(gridDataChangedInfo);
+    }
     // we need this temporary "shared memory" because the value change and the AG Grid cellChanged event are asynchronous
     // in the first phase we keep the undone change
     logUndoChange(change) {
@@ -75,10 +84,6 @@ class DataService {
             newValue,
         });
     }
-    logDataChange(cellDataChangedInfo) {
-        const dataChangeLogEntry = this.extractDataChangeLogEntry(cellDataChangedInfo);
-        this.dataChangeLogSubject$.next(dataChangeLogEntry);
-    }
     extractDataChangeLogEntry(cellDataChangedInfo) {
         // create rowData snapshot
         const rowData = cellDataChangedInfo.rowData

package/src/Utilities/Services/Interface/IAlertService.d.ts

@@ -1,10 +1,17 @@
 import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
 import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridDataChangedInfo } from '../../../types';
 import { IAdaptableService } from './IAdaptableService';
-export declare type ReactiveAlertInfo = {
+export declare type ReactiveAlertInfo = ReactiveGridDataChangedAlertInfo | ReactiveCellDataChangedAlertInfo;
+export declare type ReactiveGridDataChangedAlertInfo = {
+    type: 'gridDataChangedAlert';
     alertDefinition: AlertDefinition;
-    type: 'alert';
-    dataChangeLogEntry: CellDataChangedInfo;
+    gridChangeLogEntry: GridDataChangedInfo;
+};
+export declare type ReactiveCellDataChangedAlertInfo = {
+    type: 'cellDataChangedAlert';
+    alertDefinition: AlertDefinition;
+    cellChangeLogEntry: CellDataChangedInfo;
 };
 export interface IAlertService extends IAdaptableService {
     createReactiveAlert(alertDefinition: AlertDefinition): void;
@@ -13,3 +20,5 @@ export interface IAlertService extends IAdaptableService {
     getReactiveActiveAlerts(): AlertDefinition[];
     isReactiveAlertActive(alertDefinition: AlertDefinition): boolean;
 }
+export declare const isGridDataChangedInfo: (value: CellDataChangedInfo | GridDataChangedInfo) => value is GridDataChangedInfo<any>;
+export declare const isCellDataChangedInfo: (value: CellDataChangedInfo | GridDataChangedInfo) => value is CellDataChangedInfo<any>;

package/src/Utilities/Services/Interface/IAlertService.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCellDataChangedInfo = exports.isGridDataChangedInfo = void 0;
+const isGridDataChangedInfo = (value) => {
+    return typeof value.rowTrigger === 'string';
+};
+exports.isGridDataChangedInfo = isGridDataChangedInfo;
+const isCellDataChangedInfo = (value) => {
+    return !(0, exports.isGridDataChangedInfo)(value);
+};
+exports.isCellDataChangedInfo = isCellDataChangedInfo;

package/src/Utilities/Services/Interface/IDataService.d.ts

@@ -1,10 +1,13 @@
 import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
+import { GridDataChangedInfo } from '../../../types';
 export interface IDataService extends IAdaptableService {
     CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    CreateGridChangedEvent(gridDataChangedInfo: GridDataChangedInfo): void;
     on(eventName: 'CellDataChanged', callback: (cellDataChangedInfo: CellDataChangedInfo) => void): () => void;
     readonly dataChangeLog$: Observable<CellDataChangedInfo>;
+    readonly gridChangeLog$: Observable<GridDataChangedInfo>;
     logUndoChange(undoChange: CellDataChangedInfo): void;
     extractUndoChange(undoChange: CellDataChangedInfo): CellDataChangedInfo | undefined;
 }

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -9,10 +9,11 @@ import { BooleanFunctionName } from '../../ExpressionFunctions/booleanExpression
 import { ScalarFunctionName } from '../../ExpressionFunctions/scalarExpressionFunctions';
 import { ObservableFunctionName } from '../../ExpressionFunctions/observableExpressionFunctions';
 import { ExpressionFunctionMap } from '../../../parser/src/types';
+import { GridDataChangedInfo } from '../../../types';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
-    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): BooleanAggregationParameter;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {

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

@@ -4,7 +4,7 @@ import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChang
 import { IRowNode } from '@ag-grid-community/core';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { ScalarAggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
-import { AdaptableApi } from '../../../types';
+import { AdaptableApi, GridDataChangedInfo } from '../../../types';
 import { BooleanAggregationParameter } from '../ExpressionFunctions/aggregatedBooleanExpressionFunctions';
 export declare class QueryLanguageService implements IQueryLanguageService {
     private adaptableApi;
@@ -17,7 +17,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
-    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | GridDataChangedInfo>;
     evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): BooleanAggregationParameter;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;

package/src/View/Components/Selectors/ColumnSelector.js

@@ -13,11 +13,6 @@ class ColumnSelector extends React.Component {
         var _a;
         const sortedColumns = ArrayExtensions_1.ArrayExtensions.sortArrayWithProperty(Enums_1.SortOrder.Asc, this.props.ColumnList, 'friendlyName');
         const selectedColumnIds = this.props.SelectedColumnIds.filter((x) => StringExtensions_1.StringExtensions.IsNotNullOrEmpty(x));
-        const placeHolder = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.props.placeHolder)
-            ? this.props.placeHolder.toString()
-            : this.props.SelectionMode == Enums_1.SelectionMode.Single
-                ? 'Select a column'
-                : 'Select columns';
         const isEmptySelectedColumnIds = this.props.SelectedColumnIds.filter((x) => StringExtensions_1.StringExtensions.IsNotNullOrEmpty(x)).length == 0;
         let sortedColumnOptions = sortedColumns.map((column) => {
             return {

package/src/View/Dashboard/{CustomToolbarWrapper.d.ts → CustomToolbar.d.ts}

@@ -4,5 +4,6 @@ interface CustomToolbarWrapperProps {
     customToolbar: CustomToolbar;
     dashboardRevision: number;
 }
+export declare const CustomToolbarCmp: (props: CustomToolbarWrapperProps) => JSX.Element;
 export declare const CustomToolbarWrapper: (props: CustomToolbarWrapperProps) => JSX.Element;
 export {};

package/src/View/Dashboard/{CustomToolbarWrapper.js → CustomToolbar.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomToolbarWrapper = void 0;
+exports.CustomToolbarWrapper = exports.CustomToolbarCmp = void 0;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const react_1 = require("react");
-const PanelDashboard_1 = require("../Components/Panels/PanelDashboard");
 const AdaptableContext_1 = require("../AdaptableContext");
 const AdaptableButton_1 = require("../Components/AdaptableButton");
-const CustomToolbarWrapper = (props) => {
+const PanelDashboard_1 = require("../Components/Panels/PanelDashboard");
+const CustomToolbarCmp = (props) => {
     let contentsDivId = 'ab-CustomToolbar__' + props.customToolbar.name + '__contents';
     let buttonsDivId = 'ab-CustomToolbar__' + props.customToolbar.name + '__buttons';
     const [contentsHTML, setContentsHTML] = (0, react_1.useState)('');
@@ -63,6 +63,38 @@ const CustomToolbarWrapper = (props) => {
             }
         };
     }, []);
+    return (React.createElement(React.Fragment, null,
+        contentsHTML && (React.createElement("div", { id: contentsDivId, ref: contentsDivRef, className: "CustomToolBarContents ab-CustomToolbar__contents ab-CustomToolbar__contents--render", style: { minHeight: 22 }, dangerouslySetInnerHTML: { __html: contentsHTML } })),
+        props.customToolbar.toolbarButtons && (React.createElement("div", { id: buttonsDivId, className: "ab-CustomToolbar__buttons", style: { minHeight: 22 } }, props.customToolbar.toolbarButtons.map((button, index) => {
+            const dashboardContext = {
+                customToolbar: props.customToolbar,
+                adaptableApi: api,
+                userName: api.optionsApi.getUserName(),
+                adaptableId: api.optionsApi.getAdaptableId(),
+                dashboardState: api.dashboardApi.getDashboardState(),
+            };
+            const buttonIcon = api.internalApi.getIconForButton(button, dashboardContext);
+            let buttonStyle = api.internalApi.getStyleForButton(button, dashboardContext);
+            let buttonLabel = api.internalApi.getLabelForButton(button, dashboardContext);
+            let buttonTooltip = api.internalApi.getTooltipForButton(button, dashboardContext);
+            if (button.hidden && button.hidden(button, dashboardContext)) {
+                return null;
+            }
+            const disabled = button.disabled && button.disabled(button, dashboardContext);
+            let buttonVariant = buttonStyle && buttonStyle.variant ? buttonStyle.variant : 'outlined';
+            let buttonTone = buttonStyle && buttonStyle.tone ? buttonStyle.tone : 'neutral';
+            return (React.createElement(AdaptableButton_1.AdaptableButtonComponent, { style: { marginLeft: index ? 'var(--ab-space-1)' : 0 }, key: index, disabled: disabled, tooltip: buttonTooltip, icon: buttonIcon, variant: buttonVariant, tone: buttonTone, className: (buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className) || '', onClick: () => {
+                    button.onClick ? button.onClick(button, dashboardContext) : null;
+                    setTimeout(() => {
+                        // mutate state to force a re-rendering
+                        setComponentRevision(componentRevision + 1);
+                    }, 16);
+                } }, buttonLabel));
+        })))));
+};
+exports.CustomToolbarCmp = CustomToolbarCmp;
+const CustomToolbarWrapper = (props) => {
+    const { api } = (0, AdaptableContext_1.useAdaptable)();
     return (React.createElement(PanelDashboard_1.PanelDashboard, { className: `ab-CustomToolbar ab-DashboardToolbar__${props.customToolbar.name}`, "data-name": `ab-CustomToolbar ab-DashboardToolbar__${props.customToolbar.name}`, headerText: props.customToolbar.title ? props.customToolbar.title : '', showConfigureButton: props.customToolbar.showConfigureButton != null &&
             props.customToolbar.showConfigureButton == true, showCloseButton: props.customToolbar.showCloseButton != null && props.customToolbar.showCloseButton == true, onConfigure: () => {
             const customToolbarConfiguredInfo = {
@@ -75,35 +107,6 @@ const CustomToolbarWrapper = (props) => {
         }, accessLevel: api.internalApi
             .getEntitlementService()
             .getEntitlementAccessLevelForModule('Dashboard') },
-        React.createElement("div", { id: contentsDivId, ref: contentsDivRef, className: "CustomToolBarContents ab-CustomToolbar__contents ab-CustomToolbar__contents--render", style: { minHeight: 22 }, dangerouslySetInnerHTML: { __html: contentsHTML } }),
-        React.createElement("div", { id: buttonsDivId, className: "ab-CustomToolbar__buttons", style: { minHeight: 22 } }, props.customToolbar.toolbarButtons &&
-            props.customToolbar.toolbarButtons.map((button, index) => {
-                // TODO: variants of this mapping are present in several places (just search for api.internalApi.getStyleForButton() usages)
-                // with the next opportunity we should abstract it
-                const dashboardContext = {
-                    customToolbar: props.customToolbar,
-                    adaptableApi: api,
-                    userName: api.optionsApi.getUserName(),
-                    adaptableId: api.optionsApi.getAdaptableId(),
-                    dashboardState: api.dashboardApi.getDashboardState(),
-                };
-                const buttonIcon = api.internalApi.getIconForButton(button, dashboardContext);
-                let buttonStyle = api.internalApi.getStyleForButton(button, dashboardContext);
-                let buttonLabel = api.internalApi.getLabelForButton(button, dashboardContext);
-                let buttonTooltip = api.internalApi.getTooltipForButton(button, dashboardContext);
-                if (button.hidden && button.hidden(button, dashboardContext)) {
-                    return null;
-                }
-                const disabled = button.disabled && button.disabled(button, dashboardContext);
-                let buttonVariant = buttonStyle && buttonStyle.variant ? buttonStyle.variant : 'outlined';
-                let buttonTone = buttonStyle && buttonStyle.tone ? buttonStyle.tone : 'neutral';
-                return (React.createElement(AdaptableButton_1.AdaptableButtonComponent, { style: { marginLeft: index ? 'var(--ab-space-1)' : 0 }, key: index, disabled: disabled, tooltip: buttonTooltip, icon: buttonIcon, variant: buttonVariant, tone: buttonTone, className: (buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className) || '', onClick: () => {
-                        button.onClick ? button.onClick(button, dashboardContext) : null;
-                        setTimeout(() => {
-                            // mutate state to force a re-rendering
-                            setComponentRevision(componentRevision + 1);
-                        }, 16);
-                    } }, buttonLabel));
-            }))));
+        React.createElement(exports.CustomToolbarCmp, Object.assign({}, props))));
 };
 exports.CustomToolbarWrapper = CustomToolbarWrapper;

package/src/View/Dashboard/Dashboard.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="react" />
 import * as Redux from 'redux';
-import { ModuleViewPopupProps } from '../Components/SharedProps/ModuleViewPopupProps';
+import { SystemStatusMessageInfo } from '../../PredefinedConfig/Common/SystemStatusMessageInfo';
 import { AdaptableCoordinate, DashboardState } from '../../PredefinedConfig/DashboardState';
 import { GridState } from '../../PredefinedConfig/GridState';
 import * as DashboardRedux from '../../Redux/ActionsReducers/DashboardRedux';
 import * as PopupRedux from '../../Redux/ActionsReducers/PopupRedux';
 import * as QuickSearchRedux from '../../Redux/ActionsReducers/QuickSearchRedux';
-import { SystemStatusMessageInfo } from '../../PredefinedConfig/Common/SystemStatusMessageInfo';
+import { ModuleViewPopupProps } from '../Components/SharedProps/ModuleViewPopupProps';
 interface DashboardComponentProps extends ModuleViewPopupProps<any> {
     DashboardRevision: number;
     DashboardState: DashboardState;