@adaptabletools/adaptable 11.0.0-canary.6 → 11.0.0-canary.7

package/index.css

@@ -3254,7 +3254,7 @@ input[type='number'].ab-Input:hover::-webkit-inner-spin-button:active {
   position: relative;
   display: inline-block;
   min-width: 40px;
-  width: 87px;
+  width: 77px;
   height: 32px; }
 
 .ab-ToggleButton:hover:not(.ab-ToggleButton--disabled) {
@@ -3292,7 +3292,7 @@ input[type='number'].ab-Input:hover::-webkit-inner-spin-button:active {
     background-color: var(--ab-cmp-toggle-button--active__background); }
 
 .ab-ToggleButton__input:checked + .ab-ToggleButton__slider:before {
-    transform: translateX(54px); }
+    transform: translateX(45px); }
 
 .ab-ToggleButton__input:focus + .ab-ToggleButton__slider {
     box-shadow: var(--ab-focus__box-shadow); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "11.0.0-canary.6",
+  "version": "11.0.0-canary.7",
   "description": "Powerful data-agnostic HTML5 datagrid add-on that sits on top of an underlying grid component and provides all the rich functionality that advanced users expect from their DataGrids and Data Tables",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1645166555862;
+declare const _default: 1645536652959;
 export default _default;

package/publishTimestamp.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 1645166555862;
+exports.default = 1645536652959;

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -158,6 +158,7 @@ export interface IAdaptable {
     getDataRowFromRowNode(rowNode: RowNode): any;
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): RowNode[];
     getRowNodeForPrimaryKey(primaryKeyValue: any): RowNode;
+    getRowNodeByIndex(index: number): RowNode;
     forPlugins(callback: (plugin: AdaptablePlugin) => any): void;
     lookupPlugins(propertyName: string, ...args: any): any;
     getPluginProperty(pluginId: string, propertyName: string, ...args: any): any;

package/src/AdaptableOptions/AdaptableOptions.d.ts

@@ -16,12 +16,12 @@ import { NotificationsOptions } from './NotificationsOptions';
 import { DashboardOptions } from './DashboardOptions';
 import { ToolPanelOptions } from './ToolPanelOptions';
 import { FilterOptions } from './FilterOptions';
-import { QueryLanguageOptions } from './QueryLanguageOptions';
 import { DataChangeHistoryOptions } from './DataChangeHistoryOptions';
 import { SettingsPanelOptions } from './SettingsPanelOptions';
 import { GridOptions, Module } from '@ag-grid-community/all-modules';
 import { FlashingCellOptions } from './FlashingCellOptions';
 import { AlertOptions } from './AlertOptions';
+import { AdaptableQLOptions } from './AdaptableQLOptions';
 /**
  * Group of property options enabling developers to set up AdapTable at design time to fit precise requirements - provides AG Grid, Predefined Config and other information required to ensure a full, rich user experience
  */
@@ -180,11 +180,9 @@ export interface AdaptableOptions {
      */
     toolPanelOptions?: ToolPanelOptions;
     /**
-     * Options for managing queries in AdapTableQL
-     *
-     * @gridInfoContainer
+     * Options for managing AdapTableQL
      */
-    queryLanguageOptions?: QueryLanguageOptions;
+    adaptableQLOptions?: AdaptableQLOptions;
     /**
      * Options to manage Data Change History Module which provides an overview of all data changes
      *

package/src/AdaptableOptions/{QueryLanguageOptions.d.ts → AdaptableQLOptions.d.ts}

@@ -1,9 +1,30 @@
 import { ExpressionFunctionMap } from '../parser/src/types';
-import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+import { AdaptableModule, AdaptableQLModules } from '../PredefinedConfig/Common/Types';
+export interface AdaptableQLOptions {
+    /**
+     * Perform case-sensitive text comparisons in all search and filter operations: QuickSearch, Filters, Query, Predicates
+     *
+     * @defaultValue false
+     * @gridInfoItem
+     */
+    caseSensitiveTextComparisons?: boolean;
+    /**
+     * Which searching and filtering options should take place on server
+     *
+     * @defaultValue undefined
+     * @gridInfoItem
+     */
+    externallyEvaluatedModules?: AdaptableQLModules;
+    /**
+     * Options for managing Expressions in AdapTableQL
+     *
+     */
+    expressionOptions?: ExpressionOptions;
+}
 /**
  * Options for managing Expressions using AdapTableQL
  */
-export interface QueryLanguageOptions {
+export interface ExpressionOptions {
     /**
      * Boolean Expression Functions available in AdapTableQL
      *
@@ -32,6 +53,13 @@ export interface QueryLanguageOptions {
      * @gridInfoItem
      */
     defaultAggregatedBooleanFunctions?: ExpressionFunctionMap;
+    /**
+     * Aggregated Scalar Expression Functions available in AdapTableQL
+     *
+     * @defaultValue null (sets all)
+     * @gridInfoItem
+     */
+    defaultAggregatedScalarFunctions?: ExpressionFunctionMap;
     /**
      * Module specific ExpressionFunctions; if not defined, it falls back to the defined default values
      *
@@ -71,4 +99,5 @@ export interface ModuleExpressionFunctions {
     scalarFunctions?: ExpressionFunctionMap;
     observableFunctions?: ExpressionFunctionMap;
     aggregatedBooleanFunctions?: ExpressionFunctionMap;
+    aggregatedScalarFunctions?: ExpressionFunctionMap;
 }

package/src/AdaptableOptions/GeneralOptions.d.ts

@@ -70,13 +70,6 @@ export interface GeneralOptions {
      * CustomSort column comparer functions
      */
     customSortComparers?: ColumnValuesComparer[];
-    /**
-     * Perform case-sensitive text comparisons in all search and filter operations: QuickSearch, Filters, Query, Predicates
-     *
-     * @defaultValue false
-     * @gridInfoItem
-     */
-    caseSensitiveTextComparisons?: boolean;
 }
 /**
  * Comparer object for Column Values - used for custom sorting

package/src/AdaptableOptions/SearchOptions.d.ts

@@ -16,13 +16,6 @@ export interface SearchOptions {
      * @gridInfoItem
      */
     quickSearchPlaceholder?: string;
-    /**
-     * Which searching and filtering options, if any, should take place on server
-     *
-     * @defaultValue undefined
-     * @gridInfoItem
-     */
-    serverSearchOptions?: ServerSearchOptions;
     /**
      * Clears saved searches when AdapTable loads
      *
@@ -38,5 +31,3 @@ export interface SearchOptions {
      */
     filterResultsAfterQuickSearch?: boolean;
 }
-export declare type ServerSearchOptions = ServerSearchOption[];
-export declare type ServerSearchOption = 'Query' | 'Filter' | 'Sort';

package/src/AdaptableOptions/StateOptions.d.ts

@@ -1,30 +1,30 @@
 import { AdaptableState } from '../PredefinedConfig/AdaptableState';
 /**
- * Options related to state hydration/dehydration - allows users to intercept state persistence and state loading with custom functionality.
+ * Options related to Adaptable State hydration/dehydration - allows users to intercept state persistence and state loading with custom functionality
  */
 export interface StateOptions {
     /**
-     * Allows the customization of state persistence.
+     * Allows the customization of state persistence
      */
     persistState?: AdaptablePersistStateFunction;
     /**
-     * Allows the customization of state loading.
+     * Allows the customization of Adaptable State loading
      */
     loadState?: AdaptableLoadStateFunction;
     /**
-     * Allows the customization of the state that is going to be persisted
+     * Allows the customization of the Adaptable State that is going to be persisted
      */
     saveState?: AdaptableSaveStateFunction;
     /**
-     * Allows hooking into AdaptableState hydration
+     * Allows hooking into Adaptable State hydration
      */
     applyState?: (state: any) => any;
     /**
-     * Allows clearing of remote state.
+     * Allows clearing of remote Adaptable State
      */
     clearState?: AdaptableClearStateFunction;
     /**
-     * Delay (in ms) to debounce saveState/persistState calls enabling grouping multiple sequential calls in single one (e.g. elevator doors)
+     * Delay (in ms) to debounce `saveState` / `persistState` calls enabling grouping multiple sequential calls in single one (e.g. elevator doors)
      *
      * **Defaults to: 400**. Also, the wait will be max 1000ms, at which point the save/persist calls will happen anyway.
      *

package/src/Api/CalculatedColumnApi.d.ts

@@ -12,8 +12,8 @@ export interface CalculatedColumnApi {
      */
     getAllCalculatedColumn(): CalculatedColumn[];
     /**
-     * Retrieves Calculated column by id
-     * @param id Calculated column id
+     * Retrieves Calculated Column by the unique identifier of the Adaptable Object in the CalculatedColumnState
+     * @param id - Calculated Column state unique identifier
      * @returns calculated column
      */
     getCalculatedColumnById(id: CalculatedColumn['Uuid']): CalculatedColumn;
@@ -41,13 +41,6 @@ export interface CalculatedColumnApi {
      * @returns calculated columns
      */
     editCalculatedColumns(calcColumns: CalculatedColumn[]): CalculatedColumn[];
-    /**
-     * Replaces Expression in given Calculated Column with new value
-     * @param calcColumn Calculated Column for which Expression should change
-     * @param columnExpression New Expression for Calculated Column
-     * @returns calculated columns
-     */
-    editCalculatedColumnExpression(calcColumn: string, columnExpression: string): CalculatedColumn;
     /**
      * Removes Calculated Column from State
      *

package/src/Api/GridApi.d.ts

@@ -143,6 +143,16 @@ export interface GridApi {
      * @param clearSelection Whether to clear current selection in grid
      */
     deSelectNode(rowNode: RowNode, clearSelection: boolean): void;
+    /**
+     * Selects a Column in AG Grid
+     * @param columnId Id of Column to Select
+     */
+    selectColumn(columnId: string): void;
+    /**
+     * Selects Columns in AG Grid
+     * @param columnIds Ids of Columns to Select
+     */
+    selectColumns(columnIds: string[]): void;
     /**
      * AG Grid Row Nodes in AdapTable
      * @param rowNodes Nodes to DeSelect
@@ -174,7 +184,7 @@ export interface GridApi {
      */
     deSelectRows(primaryKeyValues: any[], clearSelection: boolean): void;
     /**
-     * Selects a group of cells in a given range
+     * Selects a group of cells in a given range - provide either primary keys or row indexes
      * @param gridCellRange range to select
      */
     selectCellRange(gridCellRange: GridCellRange): void;

package/src/Api/Implementation/ApiBase.d.ts

@@ -11,7 +11,7 @@ import { ContainerOptions, DashboardOptions, EditOptions, FilterOptions, General
 import { NotificationsOptions } from '../../AdaptableOptions/NotificationsOptions';
 import { ToolPanelOptions } from '../../AdaptableOptions/ToolPanelOptions';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
-import { QueryLanguageOptions } from '../../AdaptableOptions/QueryLanguageOptions';
+import { AdaptableQLOptions, ExpressionOptions } from '../../AdaptableOptions/AdaptableQLOptions';
 import { AlertOptions } from '../../AdaptableOptions/AlertOptions';
 export declare abstract class ApiBase {
     protected adaptable: IAdaptable;
@@ -55,11 +55,12 @@ export declare abstract class ApiBase {
     protected getLayoutOptions(): LayoutOptions;
     protected getMenuOptions(): MenuOptions;
     protected getFilterOptions(): FilterOptions;
+    protected getAdaptableQLOptions(): AdaptableQLOptions;
     protected getSearchOptions(): SearchOptions;
     protected getStateOptions(): StateOptions;
     protected getTeamSharingOptions(): TeamSharingOptions;
     protected getUserInterfaceOptions(): UserInterfaceOptions;
     protected getToolPanelOptions(): ToolPanelOptions;
-    protected getQueryLanguageOptions(): QueryLanguageOptions;
+    protected getExpressionOptions(): ExpressionOptions;
     protected getAdaptableApi(): AdaptableApi;
 }

package/src/Api/Implementation/ApiBase.js

@@ -101,6 +101,9 @@ class ApiBase {
     getFilterOptions() {
         return this.getOptions().filterOptions;
     }
+    getAdaptableQLOptions() {
+        return this.getOptions().adaptableQLOptions;
+    }
     getSearchOptions() {
         return this.getOptions().searchOptions;
     }
@@ -116,8 +119,8 @@ class ApiBase {
     getToolPanelOptions() {
         return this.getOptions().toolPanelOptions;
     }
-    getQueryLanguageOptions() {
-        return this.getOptions().queryLanguageOptions;
+    getExpressionOptions() {
+        return this.getAdaptableQLOptions().expressionOptions;
     }
     getAdaptableApi() {
         return this.adaptable.api;

package/src/Api/Implementation/CalculatedColumnApiImpl.js

@@ -29,6 +29,7 @@ class CalculatedColumnApiImpl extends ApiBase_1.ApiBase {
         return this.getCalculatedColumnById(calculatedColumn.Uuid);
     }
     editCalculatedColumns(calculatedColumns) {
+        // FIXME AFL extend Redux to handle all the edits in one run
         calculatedColumns.forEach((cc) => {
             this.editCalculatedColumn(cc);
         });
@@ -63,16 +64,14 @@ class CalculatedColumnApiImpl extends ApiBase_1.ApiBase {
     getCalculatedColumnsReferencingColumnId(columnId) {
         var calcColumns = [];
         this.getAllCalculatedColumn().forEach((calculatedColumn) => {
-            var _a;
-            if (this.adaptable.api.columnApi.isColumnReferencedInExpression(columnId, (_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression)) {
+            if (this.adaptable.api.columnApi.isColumnReferencedInExpression(columnId, this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query))) {
                 calcColumns.push(calculatedColumn);
             }
         });
         return calcColumns;
     }
     getReferencedColumnIdsForCalculatedColumn(calculatedColumn) {
-        var _a;
-        const columnIds = this.adaptable.api.queryLanguageApi.getColumnsFromExpression((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression);
+        const columnIds = this.adaptable.api.queryLanguageApi.getColumnsFromExpression(this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query));
         return columnIds;
     }
     getReferencedColumnIdsForCalculatedColumnId(calculatedColumnId) {

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -51,6 +51,8 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     deSelectNode(rowNode: RowNode, clearSelection: boolean): void;
     deSelectNodes(rowNodes: RowNode[], clearSelection: boolean): void;
     selectCellRange(gridCellRange: GridCellRange): void;
+    selectColumn(columnId: string): void;
+    selectColumns(columnIds: string[]): void;
     getFirstRowNode(): RowNode;
     getVisibleRowNodes(): RowNode[];
     getGridCellFromRowNode(rowwNode: RowNode, columnId: string): GridCell | undefined;

package/src/Api/Implementation/GridApiImpl.js

@@ -149,14 +149,37 @@ class GridApiImpl extends ApiBase_1.ApiBase {
         this.adaptable.deSelectNodes(rowNodes, clearSelection);
     }
     selectCellRange(gridCellRange) {
-        const startNode = this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueStart);
-        const endNode = gridCellRange.primaryKeyValueEnd
-            ? this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueEnd)
-            : startNode;
+        if (gridCellRange == undefined) {
+            return;
+        }
+        if (gridCellRange.primaryKeyValueStart == undefined &&
+            gridCellRange.rowIndexStart == undefined) {
+            return;
+        }
+        let startNode;
+        let endNode;
+        startNode = gridCellRange.primaryKeyValueEnd
+            ? this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueStart)
+            : this.adaptable.getRowNodeByIndex(gridCellRange.rowIndexStart);
+        if (gridCellRange.primaryKeyValueEnd) {
+            endNode = this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueEnd);
+        }
+        else if (gridCellRange.rowIndexEnd) {
+            endNode = this.adaptable.getRowNodeByIndex(gridCellRange.rowIndexEnd);
+        }
+        else {
+            endNode = startNode;
+        }
         if (startNode && endNode) {
             this.adaptable.selectCells(gridCellRange.columnIds, startNode, endNode);
         }
     }
+    selectColumn(columnId) {
+        this.selectColumns([columnId]);
+    }
+    selectColumns(columnIds) {
+        this.adaptable.api.columnApi.selectColumns(columnIds);
+    }
     getFirstRowNode() {
         return this.adaptable.getFirstRowNode();
     }

package/src/Api/Implementation/InternalApiImpl.d.ts

@@ -8,7 +8,7 @@ import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
 import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
-import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
+import { AdaptableModule, AdaptableQLModule } from '../../PredefinedConfig/Common/Types';
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
 import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
 import { AdaptableOptions, AdaptableState, AlertButtonContext, Layout, SystemStatusMessageInfo } from '../../types';
@@ -16,7 +16,6 @@ import { IValidationService } from '../../Utilities/Services/Interface/IValidati
 import { IModuleService } from '../../Utilities/Services/Interface/IModuleService';
 import { IReportService } from '../../Utilities/Services/Interface/IReportService';
 import { ICalculatedColumnExpressionService } from '../../Utilities/Services/Interface/ICalculatedColumnExpressionService';
-import { ServerSearchOption } from '../../AdaptableOptions/SearchOptions';
 import { AdaptableAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { IDataService } from '../../Utilities/Services/Interface/IDataService';
@@ -90,7 +89,7 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     getTeamSharingService(): ITeamSharingService;
     getMetamodelService(): IMetamodelService;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
-    isServerSearchOptionSet(serverSearchOption: ServerSearchOption): boolean;
+    runModuleInAdaptableQL(adaptableQLModule: AdaptableQLModule): boolean;
     buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
     clearFlashingCellState(): void;
     clearUpdatedRowState(): void;

package/src/Api/Implementation/InternalApiImpl.js

@@ -238,9 +238,9 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         var _a, _b;
         return ((_b = (_a = this.adaptable.ModuleService.getModuleInfoByModule(adaptableModule)) === null || _a === void 0 ? void 0 : _a.FriendlyName) !== null && _b !== void 0 ? _b : adaptableModule);
     }
-    isServerSearchOptionSet(serverSearchOption) {
-        const serverSearchOptions = this.getSearchOptions().serverSearchOptions;
-        return serverSearchOptions != undefined && serverSearchOptions.includes(serverSearchOption);
+    runModuleInAdaptableQL(adaptableQLModule) {
+        const adaptableQLModules = this.getAdaptableQLOptions().externallyEvaluatedModules;
+        return !adaptableQLModules.includes(adaptableQLModule);
     }
     buildStandaloneColumnHeader(column) {
         return this.adaptable.buildStandaloneColumnHeader(column);
@@ -310,6 +310,7 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
                 .forEach((calculatedColumn) => {
                 firstRowData[calculatedColumn.ColumnId] = this.adaptable.api.gridApi.getCellRawValue(firstRowPrimaryKeyValue, calculatedColumn.ColumnId);
             });
+            // FIXME AFL shouldn't here be also the FreeTextColumn??
         }
         return firstRowData;
     }
@@ -379,7 +380,7 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
     }
     isTextComparisonCaseSensitive() {
-        return this.adaptable.adaptableOptions.generalOptions.caseSensitiveTextComparisons;
+        return this.adaptable.adaptableOptions.adaptableQLOptions.caseSensitiveTextComparisons;
     }
     executeWithProgressIndicator(label, executeFn) {
         this.dispatchReduxAction(SystemRedux_1.SystemProgressIndicatorShow(label));

package/src/Api/Implementation/QueryLanguageApiImpl.d.ts

@@ -2,12 +2,15 @@ import { ApiBase } from './ApiBase';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { QueryLanguageApi } from '../QueryLanguageApi';
 import { ExpressionFunctionMap } from '../../types';
+import { AdaptableQuery } from '../../PredefinedConfig/Common/AdaptableQuery';
 export declare class QueryLanguageApiImpl extends ApiBase implements QueryLanguageApi {
     isValidBooleanExpression(query: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     isValidObservableExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidAggregatedScalarExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     getASTForExpression(query: string): any;
     getColumnsFromExpression(expression: string): string[];
     getQueryableColumnIds(): string[] | undefined;
     getModuleExpressionFunctionMap(): ExpressionFunctionMap;
+    getAdaptableQueryExpression(query: Partial<AdaptableQuery>): string | undefined;
 }

package/src/Api/Implementation/QueryLanguageApiImpl.js

@@ -34,6 +34,15 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
         }
         return isValid;
     }
+    isValidAggregatedScalarExpression(expression, module, validationErrorMessage) {
+        const { isValid, errorMessage } = this.adaptable.api.internalApi
+            .getQueryLanguageService()
+            .validateAggregatedScalar(expression, module);
+        if (!isValid && validationErrorMessage) {
+            LoggingHelper_1.LogAdaptableWarning(`${validationErrorMessage} :: ${errorMessage}`);
+        }
+        return isValid;
+    }
     getASTForExpression(query) {
         return parser.getAST(query);
     }
@@ -51,7 +60,7 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
         }
     }
     getQueryableColumnIds() {
-        let queryableColumns = this.getQueryLanguageOptions().queryableColumns;
+        let queryableColumns = this.getExpressionOptions().queryableColumns;
         if (!queryableColumns) {
             return undefined;
         }
@@ -67,7 +76,11 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
         }
     }
     getModuleExpressionFunctionMap() {
-        return this.getQueryLanguageOptions().moduleExpressionFunctions;
+        return this.getExpressionOptions().moduleExpressionFunctions;
+    }
+    getAdaptableQueryExpression(query) {
+        var _a, _b, _c, _d;
+        return ((_d = (_c = (_b = (_a = query.BooleanExpression) !== null && _a !== void 0 ? _a : query.ScalarExpression) !== null && _b !== void 0 ? _b : query.ObservableExpression) !== null && _c !== void 0 ? _c : query.AggregatedBooleanExpression) !== null && _d !== void 0 ? _d : query.AggregatedScalarExpression);
     }
 }
 exports.QueryLanguageApiImpl = QueryLanguageApiImpl;

package/src/Api/InternalApi.d.ts

@@ -6,7 +6,7 @@ import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { SelectedCellInfo } from '../PredefinedConfig/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../PredefinedConfig/Selection/SelectedRowInfo';
-import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+import { AdaptableModule, AdaptableQLModule } from '../PredefinedConfig/Common/Types';
 import { GridCell } from '../PredefinedConfig/Selection/GridCell';
 import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
 import { IValidationService } from '../Utilities/Services/Interface/IValidationService';
@@ -15,7 +15,6 @@ import { IReportService } from '../Utilities/Services/Interface/IReportService';
 import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
 import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
 import { Layout } from '../PredefinedConfig/LayoutState';
-import { ServerSearchOption } from '../AdaptableOptions/SearchOptions';
 import { AdaptableAlert } from '../PredefinedConfig/Common/AdaptableAlert';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
 import { AdaptableMessageType, DataChangedInfo, SystemStatusMessageInfo } from '../types';
@@ -94,7 +93,7 @@ export interface InternalApi {
     getTeamSharingService(): ITeamSharingService;
     getMetamodelService(): IMetamodelService;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
-    isServerSearchOptionSet(serverSearchOption: ServerSearchOption): boolean;
+    runModuleInAdaptableQL(adaptableQLModule: AdaptableQLModule): boolean;
     buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
     getCustomSortComparer(column: AdaptableColumn): ColumnValuesComparer | undefined;
     clearFlashingCellState(): void;

package/src/Api/QueryApi.d.ts

@@ -45,7 +45,7 @@ export interface QueryApi {
     showExpandedQueryPopup(): void;
     /**
      * Set a Query as Current Query
-     * @param query Query to set
+     * @param query - Query to set
      */
     setCurrentQuery(query: string): void;
     /**
@@ -53,7 +53,7 @@ export interface QueryApi {
      */
     clearCurrentQuery(): void;
     /**
-     * Retuns the Current Query
+     * Returns the Current Query
      */
     getCurrentQuery(): string | undefined;
 }

package/src/Api/QueryLanguageApi.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableModule } from '../PredefinedConfig/Common/Types';
 import { ExpressionFunctionMap } from '../types';
+import { AdaptableQuery } from '../PredefinedConfig/Common/AdaptableQuery';
 /**
  * Manages AdapTableQL (Query Language)
  */
@@ -25,6 +26,13 @@ export interface QueryLanguageApi {
      * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
      */
     isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    /**
+     * Whether the given AggregatedScalarExpression is valid
+     * @param expression -  AggregatedScalarExpression to check
+     * @param module - module specific query
+     * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
+     */
+    isValidAggregatedScalarExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
      * Returns all Columns referenced in a QueryExpression
      * @param expression - expression to check
@@ -43,4 +51,9 @@ export interface QueryLanguageApi {
      * @param expression expression to be run
      */
     getASTForExpression(expression: string): any;
+    /**
+     * Returns the Expression string of the given AdaptableQuery, which may be either a Boolean, an AggregatedBoolean, a Scalar, an AggregatedScalar or an ObservableExpression expression
+     * @param query - the AdaptableQuery
+     */
+    getAdaptableQueryExpression(query: Partial<AdaptableQuery>): string | undefined;
 }

package/src/Api/SettingsPanelApi.d.ts

@@ -4,14 +4,13 @@ import { AdaptableModule } from '../../types';
  **/
 export interface SettingsPanelApi {
     /**
-     * Opens settings panel to specified module,
-     * when not specified it opens the first available module
-     * @param moduleName module name
+     * Opens Settings Panel and displays specified Module (if provided) or first available one
+     * @param moduleName name of Module to display
      */
     showSettingsPanel(moduleName?: AdaptableModule): void;
     /**
-     * Opens a the settings panel to the custom module
-     * @param name name of the custom settings panel
+     * Opens Settings Panel with the Custom Settings Panel, provided by name, displayed
+     * @param name name of Custom Settings Panel to display
      */
     showCustomSettingsPanel(name: string): void;
 }

package/src/PredefinedConfig/AlertState.d.ts

@@ -60,7 +60,11 @@ export interface AlertDefinitionPredicate extends AdaptablePredicate {
  */
 export declare type AlertRule = XOR<{
     Predicate: AlertDefinitionPredicate;
-}, XOR<AdaptableBooleanQuery, XOR<AdaptableObservableQuery, AdaptableAggregatedBooleanQuery>>>;
+}, AdaptableAlertQuery>;
+/**
+ *  Alert Query which may be either a Boolean, Observable or AggregatedBoolean Expression
+ */
+export declare type AdaptableAlertQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableObservableQuery, AdaptableAggregatedBooleanQuery>>;
 export declare type AdaptableAlertAction = 'highlight-cell' | 'jump-to-cell' | 'jump-to-row' | 'jump-to-column' | 'suspend' | 'undo';
 /**
  * Defines a button that appears in an Alert Form

package/src/PredefinedConfig/CalculatedColumnState.d.ts

@@ -1,7 +1,8 @@
 import { ConfigState } from './ConfigState';
 import { AdaptableObject } from './Common/AdaptableObject';
-import { AdaptableScalarQuery } from './Common/AdaptableQuery';
+import { AdaptableAggregatedScalarQuery, AdaptableScalarQuery } from './Common/AdaptableQuery';
 import { SpecialColumnSettings } from './Common/SpecialColumnSettings';
+import { XOR } from '../Utilities/Extensions/TypeExtensions';
 /**
  * Predefined Configuration for Calculated Column Module
  **/
@@ -28,9 +29,9 @@ export interface CalculatedColumn extends AdaptableObject {
      */
     CalculatedColumnSettings?: CalculatedColumnSettings;
     /**
-     * Scalar Expression used by AdapTableQL to evaluate Column's value
+     * Scalar/AggregatedScalar Query used by AdapTableQL to evaluate Column's value
      */
-    Query?: AdaptableScalarQuery;
+    Query?: AdaptableCalculatedColumnQuery;
 }
 /**
  * Set of optional properties that define a Calculated Column's behaviour
@@ -46,3 +47,7 @@ export interface CalculatedColumnSettings extends SpecialColumnSettings {
      */
     ShowToolTip?: boolean;
 }
+/**
+ * Calculated Column Query which may be a Scalar or an AggregatedScalar Expression
+ */
+export declare type AdaptableCalculatedColumnQuery = XOR<AdaptableScalarQuery, AdaptableAggregatedScalarQuery>;