@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/Utilities/Services/AlertLiveBindingService.js

@@ -0,0 +1,162 @@
+import { AlertModuleId } from '../Constants/ModuleConstants';
+const GRID_STATE_KEY = '';
+export class AlertLiveBindingService {
+    api;
+    bindings = new Map();
+    destroyed = false;
+    constructor(api) {
+        this.api = api;
+    }
+    destroy() {
+        this.destroyed = true;
+        for (const uuid of [...this.bindings.keys()]) {
+            this.unbind(uuid);
+        }
+    }
+    bind(alertDefinition) {
+        if (this.destroyed) {
+            return;
+        }
+        this.unbind(alertDefinition.Uuid);
+        const queryLanguageService = this.api.internalApi.getQueryLanguageService();
+        const handle = queryLanguageService.getComputedValueStore().getOrCreateNode({
+            module: AlertModuleId,
+            expression: alertDefinition.Rule,
+        });
+        const binding = {
+            definition: alertDefinition,
+            handle,
+            unsubscribe: () => { },
+            state: new Map(),
+            seeded: false,
+            lastEvaluatedAt: queryLanguageService.getClock().now(),
+        };
+        binding.unsubscribe = handle.subscribe((node) => this.evaluate(binding, node));
+        this.bindings.set(alertDefinition.Uuid, binding);
+        handle.refresh();
+        void handle.node.result;
+        if (!binding.seeded) {
+            this.evaluate(binding, handle.node);
+        }
+    }
+    unbind(alertDefinitionUuid) {
+        const binding = this.bindings.get(alertDefinitionUuid);
+        if (!binding) {
+            return;
+        }
+        this.bindings.delete(alertDefinitionUuid);
+        binding.unsubscribe();
+        binding.handle.release();
+    }
+    isBound(alertDefinitionUuid) {
+        return this.bindings.has(alertDefinitionUuid);
+    }
+    syncFromState() {
+        if (this.destroyed) {
+            return;
+        }
+        const active = this.api.alertApi.internalApi.getActiveLiveAlertDefinitions();
+        const activeUuids = new Set(active.map((definition) => definition.Uuid));
+        for (const uuid of [...this.bindings.keys()]) {
+            if (!activeUuids.has(uuid)) {
+                this.unbind(uuid);
+            }
+        }
+        active.forEach((definition) => {
+            if (!this.bindings.has(definition.Uuid)) {
+                this.bind(definition);
+            }
+        });
+    }
+    getState(alertDefinitionUuid, rowNode) {
+        const binding = this.bindings.get(alertDefinitionUuid);
+        if (!binding) {
+            return undefined;
+        }
+        const key = binding.handle.node.compiled.isRowIndependent ? GRID_STATE_KEY : rowNode?.id;
+        if (key === undefined) {
+            return undefined;
+        }
+        const firing = binding.state.get(key);
+        return firing === undefined ? undefined : firing ? 'Firing' : 'Normal';
+    }
+    evaluate(binding, node) {
+        if (this.destroyed || !this.bindings.has(binding.definition.Uuid)) {
+            return;
+        }
+        const result = node.result;
+        if (!result) {
+            return;
+        }
+        const rowIndependent = node.compiled.isRowIndependent;
+        const firing = [];
+        let gridFiring = false;
+        if (rowIndependent) {
+            const next = Boolean(result.value);
+            const prev = binding.state.get(GRID_STATE_KEY) ?? false;
+            binding.state.set(GRID_STATE_KEY, next);
+            gridFiring = binding.seeded && !prev && next;
+        }
+        else {
+            const agGridApi = this.api.agGridApi;
+            for (const rowId of this.candidateRowIds(binding, node)) {
+                const rowNode = agGridApi?.getRowNode(rowId);
+                if (!rowNode) {
+                    binding.state.delete(rowId);
+                    continue;
+                }
+                const next = Boolean(result.getValueForRow(rowNode));
+                const prev = binding.state.get(rowId) ?? false;
+                binding.state.set(rowId, next);
+                if (binding.seeded && !prev && next) {
+                    firing.push(rowNode);
+                }
+            }
+        }
+        binding.seeded = true;
+        binding.lastEvaluatedAt = this.api.internalApi.getQueryLanguageService().getClock().now();
+        if (gridFiring) {
+            this.api.alertApi.internalApi.showLiveAlert(binding.definition);
+        }
+        else if (firing.length) {
+            this.api.alertApi.internalApi.showLiveAlert(binding.definition, firing);
+        }
+    }
+    candidateRowIds(binding, node) {
+        const ids = new Set();
+        const allRowIds = () => {
+            for (const rowNode of this.api.gridApi.getAllRowNodes()) {
+                if (rowNode.id !== undefined) {
+                    ids.add(rowNode.id);
+                }
+            }
+            return [...ids];
+        };
+        if (node.lastChangedRowIds === undefined) {
+            return allRowIds();
+        }
+        node.lastChangedRowIds.forEach((rowId) => ids.add(rowId));
+        binding.state.forEach((firing, rowId) => {
+            if (firing) {
+                ids.add(rowId);
+            }
+        });
+        const history = this.api.internalApi.getQueryLanguageService().getHistoryStore();
+        for (const slot of node.compiled.observable) {
+            if (slot.window.kind !== 'within' || slot.key.scope !== 'row') {
+                continue;
+            }
+            history
+                .rowsWithExpiry(slot.key, slot.window.ms, binding.lastEvaluatedAt)
+                .forEach((rowId) => ids.add(rowId));
+            if (slot.source === 'NO_CHANGES') {
+                const elapsed = history.rowsWithEpochElapse(slot.window.ms, binding.lastEvaluatedAt);
+                if (elapsed.allRows) {
+                    return allRowIds();
+                }
+                elapsed.rowIds.forEach((rowId) => ids.add(rowId));
+            }
+        }
+        return [...ids];
+    }
+}

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

@@ -1,22 +1,33 @@
-import { ICalculatedColumnExpressionService } from './Interface/ICalculatedColumnExpressionService';
+import { ICalculatedColumnExpressionService, InferredCalculatedColumnTypes, ObservableCalculatedColumnRefresh } from './Interface/ICalculatedColumnExpressionService';
+import type { LiveRefreshTarget } from './Interface/ILiveRefreshService';
 import { IRowNode } from 'ag-grid-enterprise';
-import { AdaptableCalculatedColumnQuery, CalculatedColumn, CalculatedColumnSettings } from '../../AdaptableState/CalculatedColumnState';
+import { CalculatedColumn, CalculatedColumnSettings } from '../../AdaptableState/CalculatedColumnState';
+import type { ResolvedExpression } from '../../AdaptableState/Common/AdaptableQuery';
 import { CellDataChangedInfo } from '../../AdaptableState/Common/CellDataChangedInfo';
-import { RowDataChangedInfo } from '../../AdaptableState/Common/RowDataChangedInfo';
 import { AdaptableApi } from '../../../types';
 export declare class CalculatedColumnExpressionService implements ICalculatedColumnExpressionService {
     private adaptableApi;
-    private aggregatedScalarLiveValuesMap;
+    /**
+     * Aggregated Calculated Columns are bindings onto shared computed-value
+     * store nodes (E-11): the store owns compile, dirty tracking (dependency
+     * index), batched execution, and diff-gated notifications; this map only
+     * ties a column Uuid to its node handle + grid-refresh subscription.
+     */
+    private aggregatedColumnBindings;
     constructor(adaptableApi: AdaptableApi);
+    private getComputedValueStore;
     buildSyntheticCellDataChangedInfosForCalcColumns(cellDataChangedInfo: CellDataChangedInfo): CellDataChangedInfo[];
-    listentoCellDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
-    listentoRowDataChange(rowDataChangedInfo: RowDataChangedInfo): void;
     destroy(): void;
-    getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): CalculatedColumnSettings['DataType'];
-    isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
+    resolveCalculatedColumnQuery(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): ResolvedExpression;
+    isAggregatedCalculatedColumn(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): boolean;
+    getCalculatedColumnDataType(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): CalculatedColumnSettings['DataType'];
+    inferCalculatedColumnTypes(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): InferredCalculatedColumnTypes;
+    getLiveRefreshTarget(calculatedColumn: CalculatedColumn): LiveRefreshTarget | undefined;
+    getObservableCalculatedColumnsAffectedByColumn(columnId: string): ObservableCalculatedColumnRefresh[];
+    isCalculatedColumnQueryValid(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>, calculatedColumnId?: string): boolean;
     evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, rowNode: IRowNode): any;
-    createAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
-    destroyAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
+    bindAggregatedCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    unbindAggregatedCalculatedColumn(calculatedColumn: CalculatedColumn): void;
 }
 export declare function buildSyntheticCellDataChangedInfosForCalcColumns(adaptableApi: AdaptableApi, info: CellDataChangedInfo): CellDataChangedInfo[];
 export declare function expandCellDataChangedInfosWithCalculatedColumns(adaptableApi: AdaptableApi, cellDataChangedInfos: CellDataChangedInfo[]): CellDataChangedInfo[];

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -1,139 +1,231 @@
+import { DURATION_CELL_DATA_TYPE } from '../../aql/durationHelper';
 import { CalculatedColumnModuleId } from '../Constants/ModuleConstants';
-import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
-import * as parser from '../../parser/src';
+import { expressionKindForCalculatedColumnType, getCalculatedColumnType, } from '../../AdaptableState/CalculatedColumnState';
+import { createHostExpressionContext, evaluate } from "../../../vendor/aql/index.js";
+import { createAdaptableAqlHost } from '../../aql/createAdaptableAqlHost';
 import Helper from '../Helpers/Helper';
+import { CALCULATED_COLUMN_INVALID_CELL_VALUE } from '../Constants/GeneralConstants';
 export class CalculatedColumnExpressionService {
     adaptableApi;
-    aggregatedScalarLiveValuesMap = new Map();
+    aggregatedColumnBindings = new Map();
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
         this.adaptableApi = adaptableApi;
     }
+    getComputedValueStore() {
+        return this.adaptableApi.internalApi.getQueryLanguageService().getComputedValueStore();
+    }
     buildSyntheticCellDataChangedInfosForCalcColumns(cellDataChangedInfo) {
         return buildSyntheticCellDataChangedInfosForCalcColumns(this.adaptableApi, cellDataChangedInfo);
     }
-    listentoCellDataChange(cellDataChangedInfo) {
-        if (cellDataChangedInfo.trigger === 'calculatedColumnChange') {
-            return;
-        }
-        const refreshedCalculatedColumns = [];
-        this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
-            const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
-            const columnDependencies = this.adaptableApi.calculatedColumnApi.internalApi.getReferencedColumnIdsForCalculatedColumn(calculatedColumn);
-            if (columnDependencies.includes(cellDataChangedInfo.column.columnId)) {
-                aggregatedScalarLiveValue.refresh();
-                refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
-            }
+    destroy() {
+        this.aggregatedColumnBindings.forEach((binding) => {
+            binding.unsubscribe();
+            binding.handle.release();
         });
-        if (refreshedCalculatedColumns.length) {
-            this.adaptableApi.gridApi.refreshColumns(refreshedCalculatedColumns);
-        }
+        this.aggregatedColumnBindings.clear();
+        this.aggregatedColumnBindings = null;
     }
-    listentoRowDataChange(rowDataChangedInfo) {
-        const refreshedCalculatedColumns = [];
-        this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
-            const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
-            aggregatedScalarLiveValue.refresh();
-            refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
-        });
-        if (refreshedCalculatedColumns.length) {
-            this.adaptableApi.gridApi.refreshColumns(refreshedCalculatedColumns);
-        }
+    resolveCalculatedColumnQuery(calculatedColumn) {
+        return this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .resolveExpression(calculatedColumn?.Expression, CalculatedColumnModuleId, expressionKindForCalculatedColumnType(getCalculatedColumnType(calculatedColumn)));
     }
-    destroy() {
-        this.aggregatedScalarLiveValuesMap.clear();
-        this.aggregatedScalarLiveValuesMap = null;
+    isAggregatedCalculatedColumn(calculatedColumn) {
+        return this.resolveCalculatedColumnQuery(calculatedColumn).kind === 'aggregated';
     }
-    getCalculatedColumnDataType(calculatedColumnQuery) {
+    getCalculatedColumnDataType(calculatedColumn) {
+        return this.inferCalculatedColumnTypes(calculatedColumn).DataType;
+    }
+    inferCalculatedColumnTypes(calculatedColumn) {
         try {
-            if (calculatedColumnQuery.AggregatedScalarExpression) {
-                return 'number';
+            const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+            const outputType = this.adaptableApi.internalApi
+                .getQueryLanguageService()
+                .getExpressionOutputType(query.text, CalculatedColumnModuleId);
+            switch (outputType) {
+                case 'duration':
+                    return { DataType: 'number', CellDataType: DURATION_CELL_DATA_TYPE };
+                case 'array':
+                    return { DataType: 'numberArray' };
+                case 'number':
+                case 'text':
+                case 'date':
+                case 'boolean':
+                    return { DataType: outputType };
+                default:
+                    break;
+            }
+            if (query.kind === 'aggregated') {
+                return { DataType: 'number' };
             }
             let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
             let firstRowValue = this.adaptableApi.internalApi
                 .getQueryLanguageService()
-                .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, CalculatedColumnModuleId, firstRowNode);
+                .evaluateScalarExpression(query.text, CalculatedColumnModuleId, firstRowNode);
             if (firstRowValue instanceof Date) {
-                return 'date';
+                return { DataType: 'date' };
             }
             if (typeof firstRowValue === 'boolean') {
-                return 'boolean';
+                return { DataType: 'boolean' };
             }
             if (typeof firstRowValue === 'string') {
-                return 'text';
+                return { DataType: 'text' };
             }
             if (typeof firstRowValue === 'number') {
-                return 'number';
+                return { DataType: 'number' };
             }
             if (Array.isArray(firstRowValue)) {
-                return 'numberArray';
+                return { DataType: 'numberArray' };
             }
+            return { DataType: undefined };
         }
         catch (e) {
-            this.adaptableApi.logError(`Invalid CalculatedColumn expression ${this.adaptableApi.expressionApi.getAdaptableQueryExpression(calculatedColumnQuery)} :: ${e}`);
-            return 'number';
+            return { DataType: 'number' };
+        }
+    }
+    getLiveRefreshTarget(calculatedColumn) {
+        const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+        if (!query.text) {
+            return undefined;
+        }
+        const dependencies = this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .getExpressionDependencies(query.text, CalculatedColumnModuleId);
+        if (!dependencies || !(dependencies.windowed || dependencies.time)) {
+            return undefined;
+        }
+        return { kind: 'columns', columnIds: [calculatedColumn.ColumnId] };
+    }
+    getObservableCalculatedColumnsAffectedByColumn(columnId) {
+        const queryLanguageService = this.adaptableApi.internalApi.getQueryLanguageService();
+        const affected = [];
+        for (const calculatedColumn of this.adaptableApi.calculatedColumnApi.getCalculatedColumns()) {
+            const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+            if (!query.text) {
+                continue;
+            }
+            const dependencies = queryLanguageService.getExpressionDependencies(query.text, CalculatedColumnModuleId);
+            if (!dependencies?.observable) {
+                continue;
+            }
+            const watchesColumn = dependencies.anyColumn || dependencies.columns.includes(columnId);
+            if (!watchesColumn) {
+                continue;
+            }
+            affected.push({
+                columnId: calculatedColumn.ColumnId,
+                rowIndependent: queryLanguageService.isExpressionRowIndependent(query.text, CalculatedColumnModuleId),
+            });
         }
+        return affected;
     }
-    isCalculatedColumnQueryValid(calculatedColumnQuery) {
-        if (calculatedColumnQuery.ScalarExpression) {
+    isCalculatedColumnQueryValid(calculatedColumn, calculatedColumnId) {
+        const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+        if (!query.text) {
+            return false;
+        }
+        if (calculatedColumnId) {
             try {
-                let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
                 this.adaptableApi.internalApi
                     .getQueryLanguageService()
-                    .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, CalculatedColumnModuleId, firstRowNode);
-                return true;
+                    .validateCircularCalculatedColumnReferences(query.text, calculatedColumnId);
             }
-            catch (e) {
+            catch {
                 return false;
             }
         }
-        if (calculatedColumnQuery.AggregatedScalarExpression) {
-            const validationResult = this.adaptableApi.expressionApi.isValidAggregatedScalarExpression(calculatedColumnQuery.AggregatedScalarExpression, CalculatedColumnModuleId);
-            return validationResult;
+        if (query.kind === 'aggregated') {
+            return this.adaptableApi.expressionApi.isValidAggregatedExpression(query.text, CalculatedColumnModuleId);
+        }
+        try {
+            let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
+            this.adaptableApi.internalApi
+                .getQueryLanguageService()
+                .evaluateScalarExpression(query.text, CalculatedColumnModuleId, firstRowNode);
+            return true;
+        }
+        catch (e) {
+            return false;
         }
-        return false;
     }
     evaluateCalculatedColumnQuery(calculatedColumn, rowNode) {
         try {
             if (this.adaptableApi.gridApi.isGroupRowNode(rowNode)) {
                 return undefined;
             }
-            if (calculatedColumn?.Query?.ScalarExpression) {
-                return this.adaptableApi.internalApi
-                    .getQueryLanguageService()
-                    .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, CalculatedColumnModuleId, rowNode);
+            if (!calculatedColumn?.Expression) {
+                return undefined;
             }
-            if (calculatedColumn?.Query?.AggregatedScalarExpression) {
-                const aggregatedScalarLiveValue = this.aggregatedScalarLiveValuesMap.get(calculatedColumn.Uuid);
-                return aggregatedScalarLiveValue?.getAggregatedValueForRow(rowNode);
+            const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+            if (query.kind === 'aggregated') {
+                const binding = this.aggregatedColumnBindings.get(calculatedColumn.Uuid);
+                const node = binding?.handle.node;
+                if (!node || node.error) {
+                    return node?.error ? CALCULATED_COLUMN_INVALID_CELL_VALUE : undefined;
+                }
+                return node.result?.getValueForRow(rowNode);
             }
+            return this.adaptableApi.internalApi
+                .getQueryLanguageService()
+                .evaluateScalarExpression(query.text, CalculatedColumnModuleId, rowNode);
         }
         catch (error) {
-            this.adaptableApi.logError(`Invalid CalculatedColumn expression ${calculatedColumn?.Query?.ScalarExpression ??
-                calculatedColumn?.Query?.AggregatedScalarExpression} :: ${error}`);
-            return null;
+            return CALCULATED_COLUMN_INVALID_CELL_VALUE;
         }
     }
-    createAggregatedScalarLiveValue(calculatedColumn) {
-        this.destroyAggregatedScalarLiveValue(calculatedColumn);
-        if (calculatedColumn.Query?.AggregatedScalarExpression) {
+    bindAggregatedCalculatedColumn(calculatedColumn) {
+        const query = this.resolveCalculatedColumnQuery(calculatedColumn);
+        const aggregatedExpression = query.kind === 'aggregated' ? query.text : undefined;
+        const existing = this.aggregatedColumnBindings.get(calculatedColumn.Uuid);
+        if (existing &&
+            existing.handle.node.spec.expression === aggregatedExpression &&
+            existing.columnId === calculatedColumn.ColumnId) {
+            existing.handle.refresh();
+            return;
+        }
+        this.unbindAggregatedCalculatedColumn(calculatedColumn);
+        if (aggregatedExpression) {
             try {
-                const aggregatedScalarLiveValue = new AggregatedScalarLiveValue({
-                    aggregatedScalarExpression: calculatedColumn.Query?.AggregatedScalarExpression,
-                }, CalculatedColumnModuleId, this.adaptableApi);
-                this.aggregatedScalarLiveValuesMap.set(calculatedColumn.Uuid, aggregatedScalarLiveValue);
+                const handle = this.getComputedValueStore().getOrCreateNode({
+                    module: CalculatedColumnModuleId,
+                    expression: aggregatedExpression,
+                });
+                const columnId = calculatedColumn.ColumnId;
+                const unsubscribe = handle.subscribe(() => {
+                    this.adaptableApi.gridApi.refreshColumns([columnId]);
+                });
+                this.aggregatedColumnBindings.set(calculatedColumn.Uuid, {
+                    handle,
+                    columnId,
+                    unsubscribe,
+                });
             }
             catch (e) {
-                this.adaptableApi.logError(`Creating CalculatedColumn ('${calculatedColumn.Query?.AggregatedScalarExpression}') failed!`, e.message);
+                this.adaptableApi.logError(`Creating CalculatedColumn ('${aggregatedExpression}') failed!`, e.message);
             }
         }
     }
-    destroyAggregatedScalarLiveValue(calculatedColumn) {
-        this.aggregatedScalarLiveValuesMap.delete(calculatedColumn.Uuid);
+    unbindAggregatedCalculatedColumn(calculatedColumn) {
+        const binding = this.aggregatedColumnBindings.get(calculatedColumn.Uuid);
+        if (binding) {
+            binding.unsubscribe();
+            binding.handle.release();
+            this.aggregatedColumnBindings.delete(calculatedColumn.Uuid);
+        }
     }
 }
-function isScalarCalculatedColumn(calculatedColumn) {
-    return !!calculatedColumn.Query?.ScalarExpression;
+function isScalarCalculatedColumn(adaptableApi, calculatedColumn) {
+    if (!calculatedColumn.Expression) {
+        return false;
+    }
+    const queryLanguageService = adaptableApi.internalApi.getQueryLanguageService();
+    const query = adaptableApi.internalApi
+        .getCalculatedColumnExpressionService()
+        .resolveCalculatedColumnQuery(calculatedColumn);
+    return (query.kind === 'scalar' &&
+        !queryLanguageService.getExpressionDependencies(query.text, CalculatedColumnModuleId)
+            ?.observable);
 }
 function collectDependentScalarCalculatedColumns(adaptableApi, rootColumnId) {
     const collected = [];
@@ -151,7 +243,7 @@ function collectDependentScalarCalculatedColumns(adaptableApi, rootColumnId) {
                 return;
             }
             const calculatedColumn = adaptableApi.calculatedColumnApi.getCalculatedColumnForColumnId(dependentColumnId);
-            if (!calculatedColumn || !isScalarCalculatedColumn(calculatedColumn)) {
+            if (!calculatedColumn || !isScalarCalculatedColumn(adaptableApi, calculatedColumn)) {
                 return;
             }
             seenCalcColumnIds.add(dependentColumnId);
@@ -172,10 +264,10 @@ function evaluateScalarExpressionWithShadowData(adaptableApi, calculatedColumn,
     const moduleFns = internalApi
         .getQueryLanguageService()
         .getModuleExpressionFunctionsMap(CalculatedColumnModuleId);
-    const baseFunctions = { ...moduleFns.booleanFunctions, ...moduleFns.scalarFunctions };
+    const baseFunctions = { ...moduleFns.scalarFunctions };
     const resolveColumnValue = (columnId) => {
         const childCalculatedColumn = adaptableApi.calculatedColumnApi.getCalculatedColumnForColumnId(columnId);
-        if (childCalculatedColumn?.Query?.ScalarExpression) {
+        if (childCalculatedColumn && isScalarCalculatedColumn(adaptableApi, childCalculatedColumn)) {
             return evaluateScalarExpressionWithShadowData(adaptableApi, childCalculatedColumn, rowNode, shadowData);
         }
         const adaptableColumn = adaptableApi.columnApi.getColumnWithColumnId(columnId);
@@ -192,11 +284,14 @@ function evaluateScalarExpressionWithShadowData(adaptableApi, calculatedColumn,
             handler: (args) => internalApi.getValueUsingField(shadowData, args[0]),
         },
     };
-    return parser.evaluate(calculatedColumn.Query.ScalarExpression, {
-        node: { ...rowNode, data: shadowData },
+    const shadowRowNode = { ...rowNode, data: shadowData };
+    const context = createHostExpressionContext({
+        host: createAdaptableAqlHost(adaptableApi),
         functions: customFunctions,
-        ...internalApi.buildBaseContext(),
+        rowRef: shadowRowNode,
+        ext: internalApi.buildBaseContext(),
     });
+    return evaluate(calculatedColumn.Expression, context);
 }
 export function buildSyntheticCellDataChangedInfosForCalcColumns(adaptableApi, info) {
     if (!info.rowNode ||
@@ -214,7 +309,13 @@ export function buildSyntheticCellDataChangedInfosForCalcColumns(adaptableApi, i
     const expressionService = adaptableApi.internalApi.getCalculatedColumnExpressionService();
     const syntheticEvents = [];
     calculatedColumns.forEach((calculatedColumn) => {
-        const oldValue = evaluateScalarExpressionWithShadowData(adaptableApi, calculatedColumn, info.rowNode, shadowData);
+        let oldValue;
+        try {
+            oldValue = evaluateScalarExpressionWithShadowData(adaptableApi, calculatedColumn, info.rowNode, shadowData);
+        }
+        catch {
+            return;
+        }
         const newValue = expressionService.evaluateCalculatedColumnQuery(calculatedColumn, info.rowNode);
         if (oldValue == newValue) {
             return;

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

@@ -0,0 +1,28 @@
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableApi, CellAddress } from '../../types';
+import { IAdaptableService } from './Interface/IAdaptableService';
+/**
+ * This service controls the in-cell popup interaction for Comments.
+ * If Comments are set up it listens to Cell Selection and Mouse Enter events.
+ */
+export declare class CommentsService implements IAdaptableService {
+    private api;
+    adaptable: IAdaptable;
+    private isListeningToEvents;
+    constructor(api: AdaptableApi);
+    destroy(): void;
+    private getAdaptableState;
+    private dispatchAction;
+    static isSameAddress(a: CellAddress, b: CellAddress): boolean;
+    checkListenToEvents(): void;
+    shouldListenToEvents(): boolean;
+    setUpEventListeners(): void;
+    private getCellPositionFromEvent;
+    private handleMouseEnter;
+    private handleCellSelected;
+    getOpenCellAddress(): CellAddress | undefined;
+    getEditMode(): boolean;
+    hidePopup(): void;
+    showPopup(cellAddress: CellAddress, editMode: boolean): void;
+    editFocusedEntity(entity: 'Comment'): void;
+}