@adaptabletools/adaptable 11.0.0-canary.5 → 11.0.0

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.5",
+  "version": "11.0.0",
   "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: 1645013151802;
+declare const _default: 1645637438183;
 export default _default;

package/publishTimestamp.js

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

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
  */
@@ -72,7 +72,7 @@ export interface AdaptableOptions {
      */
     userName?: string;
     /**
-     * The AG Grid object which AdapTable interacts with.  Note: if using React or Angular Wrapper, no need to populate this property as AdapTable wires it up differently
+     * The AG Grid object which AdapTable interacts with.  Note: if using AdapTable React or AdapTable Angular, no need to populate this property as AdapTable wires it up differently
      *
      * @defaultValue n/a (Mandatory)
      */
@@ -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,33 @@
 import { ExpressionFunctionMap } from '../parser/src/types';
-import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+import { AdaptableModule, AdaptableQLModules } from '../PredefinedConfig/Common/Types';
+/**
+ * Options for managing AdaptableQL - the Adaptable Query Lanaguage which evaluates Predicates and Expressions
+ */
+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
      *
@@ -26,12 +50,19 @@ export interface QueryLanguageOptions {
      */
     defaultObservableFunctions?: ExpressionFunctionMap;
     /**
-     * Aggregation Expression Functions available in AdapTableQL
+     * Aggregated Boolean Expression Functions available in AdapTableQL
+     *
+     * @defaultValue null (sets all)
+     * @gridInfoItem
+     */
+    defaultAggregatedBooleanFunctions?: ExpressionFunctionMap;
+    /**
+     * Aggregated Scalar Expression Functions available in AdapTableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultAggregationFunctions?: ExpressionFunctionMap;
+    defaultAggregatedScalarFunctions?: ExpressionFunctionMap;
     /**
      * Module specific ExpressionFunctions; if not defined, it falls back to the defined default values
      *
@@ -70,5 +101,6 @@ export interface ModuleExpressionFunctions {
     booleanFunctions?: ExpressionFunctionMap;
     scalarFunctions?: ExpressionFunctionMap;
     observableFunctions?: ExpressionFunctionMap;
-    aggregationFunctions?: ExpressionFunctionMap;
+    aggregatedBooleanFunctions?: ExpressionFunctionMap;
+    aggregatedScalarFunctions?: ExpressionFunctionMap;
 }

package/src/AdaptableOptions/ContainerOptions.d.ts

@@ -17,7 +17,7 @@ export interface ContainerOptions {
      */
     agGridContainer?: string | HTMLElement;
     /**
-     *  how long AdapTable waits for AG Grid before giving up connecting to it; useful when AG Grid is instantiated separately (eg: by React or Angular Wrappers)
+     *  how long AdapTable waits for AG Grid before giving up connecting to it; useful when AG Grid is instantiated separately (eg: by AdapTable React or AdapTable Angular)
      *
      * @defaultValue 60s
      * @gridInfoItem

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/SettingsPanelOptions.d.ts

@@ -61,11 +61,12 @@ export interface SettingsPanelOptions {
      */
     customSettingsPanels?: CustomSettingsPanel[];
 }
+/**
+ * Definition of a Custom Panel to add to the Adaptable Settings Panel
+ */
 export interface CustomSettingsPanel {
     /**
-     * Name appears in Settings Panel Navigation
-     * To be shown you must include it in settingsPanelOptions.navigation.
-     * By default is added to the end.
+     * Appears in Settings Panel Navigation and must be included in settingsPanelOptions.navigation for it to be displayed (by default added to the end)
      */
     name: string;
     /**

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/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -89,7 +89,7 @@ export interface UserInterfaceOptions {
     /**
      * Which sections to show in the Grid Info Screen
      *
-     * @defaultValue ['GridSummary', 'AdaptableOptions','ColumnInfo']
+     * @defaultValue ['GridSummary', 'AdaptableOptions', 'ColumnInfo']
      */
     gridInfoSections?: GridInfoSections;
 }

package/src/Api/AdaptableApi.d.ts

@@ -35,6 +35,7 @@ import { PredicateApi } from './PredicateApi';
 import { DataChangeHistoryApi } from './DataChangeHistoryApi';
 import { FlashingCellApi } from './FlashingCellApi';
 import { ChartingApi } from './ChartingApi';
+import { SettingsPanelApi } from './SettingsPanelApi';
 /**
  *
  * The `AdaptableApi` provides developers with run-time access to AdapTable.
@@ -147,6 +148,10 @@ export interface AdaptableApi {
      * Provides access to the Schedule Module
      */
     scheduleApi: ScheduleApi;
+    /**
+     * Provides access to the Settings Panel
+     */
+    settingsPanelApi: SettingsPanelApi;
     /**
      * Manages the `Scope` object - used widely to determine where objects are applied
      */

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/ColumnApi.d.ts

@@ -35,10 +35,6 @@ export interface ColumnApi {
      * Returns all boolean Columns
      */
     getBooleanColumns(): AdaptableColumn[];
-    /**
-     * Returns all numeric array Columns
-     */
-    getNumericArrayColumns(): AdaptableColumn[];
     /**
      * Returns all Sortable Columns
      */

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/AdaptableApiImpl.d.ts

@@ -1,5 +1,5 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableApi } from '../../types';
+import { AdaptableApi, SettingsPanelApi } from '../../types';
 import { AlertApi } from '../AlertApi';
 import { BulkUpdateApi } from '../BulkUpdateApi';
 import { CalculatedColumnApi } from '../CalculatedColumnApi';
@@ -71,6 +71,7 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     userInterfaceApi: UserInterfaceApi;
     queryApi: QueryApi;
     queryLanguageApi: QueryLanguageApi;
+    settingsPanelApi: SettingsPanelApi;
     toolPanelApi: ToolPanelApi;
     teamSharingApi: TeamSharingApi;
     scopeApi: ScopeApi;

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -38,6 +38,7 @@ const DataChangeHistoryApiImpl_1 = require("./DataChangeHistoryApiImpl");
 const QueryLanguageApiImpl_1 = require("./QueryLanguageApiImpl");
 const FlashingCellApiImpl_1 = require("./FlashingCellApiImpl");
 const ChartingApiImpl_1 = require("./ChartingApiImpl");
+const SettingsPanelApiImpl_1 = require("./SettingsPanelApiImpl");
 class AdaptableApiImpl {
     constructor(adaptable) {
         this.adaptable = adaptable;
@@ -69,6 +70,7 @@ class AdaptableApiImpl {
         this.smartEditApi = new SmartEditApiImpl_1.SmartEditApiImpl(adaptable);
         this.filterApi = new FilterApiImpl_1.FilterApiImpl(adaptable);
         this.systemStatusApi = new SystemStatusApiImpl_1.SystemStatusApiImpl(adaptable);
+        this.settingsPanelApi = new SettingsPanelApiImpl_1.SettingsPanelApiImpl(adaptable);
         this.themeApi = new ThemeApiImpl_1.ThemeApiImpl(adaptable);
         this.userInterfaceApi = new UserInterfaceApiImpl_1.UserInterfaceApiImpl(adaptable);
         this.queryApi = new QueryApiImpl_1.QueryApiImpl(adaptable);

package/src/Api/Implementation/AlertApiImpl.js

@@ -79,10 +79,13 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
             switch (highhlightType) {
                 case 'Error':
                     backgroundColor = 'var(--ab-color-error)';
+                    break;
                 case 'Info':
                     backgroundColor = 'var(--ab-color-info)';
+                    break;
                 case 'Success':
                     backgroundColor = 'var(--ab-color-success)';
+                    break;
                 case 'Warning':
                     backgroundColor = 'var(--ab-color-warn)';
             }
@@ -266,7 +269,7 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         var _a, _b;
         let ruleDescription = alert.Rule.Predicate
             ? this.adaptable.api.predicateApi.predicateToString(alert.Rule.Predicate)
-            : (_b = (_a = alert.Rule.BooleanExpression) !== null && _a !== void 0 ? _a : alert.Rule.ObservableExpression) !== null && _b !== void 0 ? _b : alert.Rule.AggregationExpression;
+            : (_b = (_a = alert.Rule.BooleanExpression) !== null && _a !== void 0 ? _a : alert.Rule.ObservableExpression) !== null && _b !== void 0 ? _b : alert.Rule.AggregatedBooleanExpression;
         return ruleDescription;
     }
 }

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/ColumnApiImpl.d.ts

@@ -42,7 +42,6 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     getColumnFromFriendlyName(columnName: string, logWarning?: boolean): AdaptableColumn;
     getColumnsOfType(dataType: DataType): AdaptableColumn[];
     getNumericColumns(): AdaptableColumn[];
-    getNumericArrayColumns(): AdaptableColumn[];
     getStringColumns(): AdaptableColumn[];
     getDateColumns(): AdaptableColumn[];
     getBooleanColumns(): AdaptableColumn[];

package/src/Api/Implementation/ColumnApiImpl.js

@@ -224,8 +224,6 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
                 return this.getDateColumns();
             case Enums_1.DataType.Number:
                 return this.getNumericColumns();
-            case Enums_1.DataType.NumberArray:
-                return this.getNumericArrayColumns();
             case Enums_1.DataType.String:
                 return this.getStringColumns();
             default:
@@ -235,9 +233,6 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
     getNumericColumns() {
         return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.Number);
     }
-    getNumericArrayColumns() {
-        return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.NumberArray);
-    }
     getStringColumns() {
         return this.getColumns().filter((c) => c.dataType == Enums_1.DataType.String);
     }

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;
-    isValidAggregationExpression(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;
 }