@adaptabletools/adaptable 11.0.0-canary.6 → 11.0.1

package/index.css

@@ -3103,8 +3103,7 @@ input[type='number'].ab-Input:hover::-webkit-inner-spin-button:active {
     align-items: stretch;
     flex: 1;
     overflow-x: auto;
-    padding-top: var(--ab-dashboard-gap-size);
-    padding-bottom: var(--ab-dashboard-gap-size); }
+    padding: var(--ab-dashboard-gap-size); }
 
 .ab-Dashboard__container {
     display: flex;
@@ -3254,7 +3253,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 +3291,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.1",
   "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: 1646327668940;
 export default _default;

package/publishTimestamp.js

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

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -158,12 +158,14 @@ 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;
     getPlugin(pluginId: string): AdaptablePlugin;
     setValue(dataChangedInfo: DataChangedInfo): void;
     cancelEdit(): any;
+    isCellEditable(rowNode: RowNode, column: Column): boolean;
     getFirstRowNode(): RowNode;
     forAllRowNodesDo(func: (rowNode: RowNode) => void): void;
     forAllVisibleRowNodesDo(func: (rowNode: RowNode) => void): void;
@@ -227,5 +229,5 @@ export interface IAdaptable {
     updateColDefsForSpecialColumns({ skipSetupColumns }?: {
         skipSetupColumns?: boolean;
     }): void;
-    getAgGridColumnForAdaptableColumn(abColumn: AdaptableColumn): Column;
+    getAgGridColumnForColumnId(columnId: string): Column;
 }

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,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
      *
@@ -32,6 +56,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 +102,5 @@ export interface ModuleExpressionFunctions {
     scalarFunctions?: ExpressionFunctionMap;
     observableFunctions?: ExpressionFunctionMap;
     aggregatedBooleanFunctions?: ExpressionFunctionMap;
+    aggregatedScalarFunctions?: ExpressionFunctionMap;
 }

package/src/AdaptableOptions/FilterOptions.d.ts

@@ -65,6 +65,10 @@ export interface FilterOptions {
      * @gridInfoItem
      */
     quickFilterValuesTrigger?: 'mouseenter' | 'click';
+    /**
+     * TODO: add comment
+     */
+    quickFilterHeight?: number;
     /**
      * When to re-filter grid after user edits data: 'Always', 'Never' or 'Throttle' (which requires a 'ThrottleDelay')
      *

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

@@ -11,7 +11,7 @@ export interface SettingsPanelOptions {
     /**
      * Icon for Settings Panel  Can be `ConfigurationIcon`, `ApplicationIcon` or a custom Icon
      *
-     * @defaultValue 'ConfigurationIcon'
+     * @defaultValue `ConfigurationIcon`
      */
     icon?: 'ConfigurationIcon' | 'ApplicationIcon' | AdaptableIcon;
     /**
@@ -35,7 +35,7 @@ export interface SettingsPanelOptions {
     /**
      * Initial position of Settings Panel window
      *
-     * @defaultValue 'Middle of Screen'
+     * @defaultValue Middle of Screen
      */
     position?: {
         x: number;
@@ -44,7 +44,7 @@ export interface SettingsPanelOptions {
     /**
      * Initial size of Settings Panel
      *
-     * @defaultValue 'Computed based on size of screen'
+     * @defaultValue Computed based on size of screen
      */
     size?: {
         width: number;
@@ -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/ToolPanelOptions.d.ts

@@ -59,7 +59,7 @@ export interface ToolPanelOptions {
     /**
      * ToolPanel Buttons provided by Users which perform custom behaviour
      */
-    customToolPanelButtons?: AdaptableButton<ToolPanelButtonContext>[];
+    customButtons?: AdaptableButton<ToolPanelButtonContext>[];
     /**
      * ToolPanels provided by Users which contain custom content
      */
@@ -80,7 +80,7 @@ export interface CustomToolPanel extends AdaptableObject {
     /**
      * Optional set of buttons to show in the ToolPanel
      */
-    toolPanelButtons?: AdaptableButton<CustomToolPanelButtonContext>[];
+    buttons?: AdaptableButton<CustomToolPanelButtonContext>[];
     /**
      * Function to provide bespoke content when NOT using a Framework wrapper
      */

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

@@ -60,10 +60,9 @@ export interface GridApi {
      * @param columnId column to update
      * @param newValue new value to use
      * @param primaryKeyValue primaryKeyValue of the row (i.e. the value in the PrimaryKeyColumn identified in Adaptable Options)
-     * @param forceFilter whether to refilter the Grid (and update aggregations) on data change - default is false
      *
      */
-    setCellValue(columnId: string, newValue: any, primaryKeyValue: any, forceFilter: boolean): void;
+    setCellValue(columnId: string, newValue: any, primaryKeyValue: any): void;
     /**
      * Updates multiple cells
      * @param gridCells cells to update
@@ -143,6 +142,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 +183,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/AlertApiImpl.js

@@ -125,8 +125,7 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
           this.adaptable.api.gridApi.setCellValue(
             dataChangedInfo.columnId,
             value,
-            dataChangedInfo.primaryKeyValue,
-            true
+            dataChangedInfo.primaryKeyValue
           );
         }
         */

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.js

@@ -198,7 +198,7 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
         return agGridColumn.getColDef().field || '';
     }
     getAgGridColumnForAdaptableColumn(columnId) {
-        return this.adaptable.getAgGridColumnForAdaptableColumn(this.getColumnFromId(columnId));
+        return this.adaptable.getAgGridColumnForColumnId(columnId);
     }
     getColumnFromFriendlyName(columnName, logWarning = true) {
         // just return null if no columns rather than logging a warning - otherwise get lots at startup

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

@@ -51,12 +51,16 @@ class GridApiImpl extends ApiBase_1.ApiBase {
         if (!abColumn || abColumn.readOnly) {
             return;
         }
+        const rowNode = this.getRowNodeForPrimaryKey(primaryKeyValue);
+        if (!this.adaptable.isCellEditable(rowNode, this.adaptable.getAgGridColumnForColumnId(columnId))) {
+            return;
+        }
         const gridCell = {
             primaryKeyValue: primaryKeyValue,
             rawValue: newValue,
             displayValue: newValue,
             normalisedValue: newValue,
-            rowNode: this.getRowNodeForPrimaryKey(primaryKeyValue),
+            rowNode: rowNode,
             column: abColumn,
         };
         this.adaptable.api.internalApi.setGridCell(gridCell);
@@ -149,14 +153,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();
     }
@@ -313,23 +340,16 @@ class GridApiImpl extends ApiBase_1.ApiBase {
         this.adaptable.redrawRow(rowNode);
     }
     areCellsEditable(gridCells) {
-        let returnValue = true;
-        gridCells.forEach((gridCell) => {
-            if (returnValue) {
-                if (gridCell.column.readOnly) {
-                    returnValue = false;
-                    return;
-                }
-                let cellEditableFn = this.adaptable.adaptableOptions.editOptions.isCellEditable;
-                if (cellEditableFn) {
-                    let functionReturnValue = cellEditableFn(gridCell);
-                    if (!functionReturnValue) {
-                        returnValue = false;
-                    }
-                }
+        for (let gridCell of gridCells) {
+            if (gridCell.column.readOnly) {
+                return false;
             }
-        });
-        return returnValue;
+            const isCellEditable = this.adaptable.isCellEditable(gridCell.rowNode, this.adaptable.getAgGridColumnForColumnId(gridCell.column.columnId));
+            if (!isCellEditable) {
+                return false;
+            }
+        }
+        return true;
     }
     getRowCount() {
         return this.adaptable.getRowCount();

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