@adaptabletools/adaptable 22.0.11 → 22.1.0-canary.1

package/src/Api/Implementation/ColumnApiImpl.js

@@ -71,6 +71,17 @@ export function generateAutoRowGroupColumnForColumn(column) {
         dataType: column.dataType,
     };
 }
+const SELECTION_COLUMN_FRIENDLY_NAME = '[Selection Column]';
+export function generateSelectionColumn() {
+    return {
+        ...ROW_GROUP_COLUMN_DEFAULTS,
+        columnId: AG_GRID_SELECTION_COLUMN,
+        friendlyName: SELECTION_COLUMN_FRIENDLY_NAME,
+        isGrouped: false,
+        isGeneratedRowGroupColumn: false,
+        isGeneratedSelectionColumn: true,
+    };
+}
 export function getFriendlyNameForPivotResultColumn(columnId, agGridApi) {
     if (isPivotGrandTotal(columnId)) {
         return `[Grand Total] ${columnId
@@ -304,6 +315,9 @@ export class ColumnApiImpl extends ApiBase {
         if (foundColumn?.isTreeColumn && isRowGroupColumn) {
             return foundColumn.friendlyName;
         }
+        if (foundColumn?.isGeneratedSelectionColumn) {
+            return foundColumn.friendlyName || SELECTION_COLUMN_FRIENDLY_NAME;
+        }
         let result = columnId + GeneralConstants.MISSING_COLUMN;
         if (this.isAutoRowGroupColumn(columnId)) {
             if (this.getGridApi().isTreeDataGrid()) {

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

@@ -29,5 +29,6 @@ export declare class ColumnScopeApiImpl extends ApiBase implements ColumnScopeAp
     isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     isScopeInScope(a: ColumnScope, b: ColumnScope): boolean;
     createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
+    getAnyColumnIdForScope(scope: ColumnScope): string | undefined;
     private distinctColumnValuesAreEmpty;
 }

package/src/Api/Implementation/ColumnScopeApiImpl.js

@@ -306,6 +306,18 @@ export class ColumnScopeApiImpl extends ApiBase {
         }
         return ranges;
     }
+    getAnyColumnIdForScope(scope) {
+        if (!scope) {
+            return;
+        }
+        const allAdaptableColumns = this.getColumnApi()
+            .getColumns()
+            .filter((col) => !col.isUIHiddenColumn &&
+            !col.isGeneratedRowGroupColumn &&
+            !col.isGeneratedSelectionColumn &&
+            !col.isPivotTotalColumn);
+        return allAdaptableColumns.find((col) => this.isColumnInScope(col, scope))?.columnId;
+    }
     distinctColumnValuesAreEmpty(distinctColumnsValues) {
         if (ArrayExtensions.IsNullOrEmpty(distinctColumnsValues)) {
             return true;

package/src/Api/Implementation/LayoutHelpers.js

@@ -212,6 +212,9 @@ export const tableLayoutToTableLayoutModel = (tableLayout) => {
         TableAggregationColumns: TableAggregationColumns,
         GrandTotalRow: tableLayout.GrandTotalRow,
     });
+    if (tableLayout.RowSelection != null) {
+        result.RowSelection = tableLayout.RowSelection;
+    }
     if (tableLayout.RowGroupDisplayType) {
         result.RowGroupDisplayType = tableLayout.RowGroupDisplayType;
     }
@@ -288,6 +291,9 @@ export const pivotLayoutToPivotLayoutModel = (pivotLayout) => {
                 }
             : undefined,
     });
+    if (pivotLayout.RowSelection != null) {
+        result.RowSelection = pivotLayout.RowSelection;
+    }
     if (pivotLayout.RowGroupDisplayType) {
         result.RowGroupDisplayType = pivotLayout.RowGroupDisplayType;
     }
@@ -422,6 +428,9 @@ export const tableLayoutModelToTableLayout = (layoutModel) => {
     else {
         delete tableLayout.GrandTotalRow;
     }
+    if (layoutModel.RowSelection != null) {
+        tableLayout.RowSelection = layoutModel.RowSelection;
+    }
     cleanupAdaptableObjectPrimitives(tableLayout);
     return tableLayout;
 };
@@ -538,6 +547,9 @@ export const pivotLayoutModelToPivotLayout = (layoutModel) => {
     // if (layoutModel.RowGroupDisplayType) {
     pivotLayout.RowGroupDisplayType = layoutModel.RowGroupDisplayType ?? 'single';
     // }
+    if (layoutModel.RowSelection != null) {
+        pivotLayout.RowSelection = layoutModel.RowSelection;
+    }
     return pivotLayout;
 };
 export const isPivotLayout = (layout) => Array.isArray(layout.PivotColumns);

package/src/Api/Internal/AlertInternalApi.js

@@ -525,7 +525,10 @@ export class AlertInternalApi extends ApiBase {
                             isValidExpression &&
                                 this.getAdaptableApi()
                                     .internalApi.getQueryLanguageService()
-                                    .evaluateBooleanExpression(expression, 'Alert', rowNode, { dataChangedEvent });
+                                    .evaluateBooleanExpression(expression, 'Alert', rowNode, {
+                                    dataChangedEvent,
+                                    columnScope: dataChangedEvent.column?.columnId,
+                                });
                     }
                     catch (error) {
                         isSatisfiedExpression = false;

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -253,7 +253,7 @@ export class FormatColumnInternalApi extends ApiBase {
             return this.evaluatePredicate(formatColumn, predicateDefHandlerContext);
         } // then run the Expression
         else if (formatColumn.Rule.BooleanExpression) {
-            return this.evaluateExpression(formatColumn, rowNode, pivotResultColumn);
+            return this.evaluateExpression(formatColumn, rowNode, column, pivotResultColumn);
         }
         // nothing has passed then return false
         return false;
@@ -277,13 +277,13 @@ export class FormatColumnInternalApi extends ApiBase {
     evaluatePredicate(formatColumn, predicateDefHandlerContext) {
         return this.getPredicateApi().handleColumnPredicates(formatColumn.Rule?.Predicates, predicateDefHandlerContext, false);
     }
-    evaluateExpression(formatColumn, node, pivotResultColumn) {
+    evaluateExpression(formatColumn, node, columnScope, pivotResultColumn) {
         const isValidExpression = this.getExpressionApi().isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
         try {
             return (isValidExpression &&
                 this.getAdaptableApi()
                     .internalApi.getQueryLanguageService()
-                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn }));
+                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn, columnScope: columnScope?.columnId }));
         }
         catch (error) {
             errorOnce(error.message);

package/src/Strategy/FlashingCellModule.js

@@ -88,6 +88,7 @@ export class FlashingCellModule extends AdaptableModuleBase {
                                     .getQueryLanguageService()
                                     .evaluateBooleanExpression(expression, this.moduleInfo.ModuleName, rowNode, {
                                     dataChangedEvent: cellDataChangedInfo,
+                                    columnScope: cellDataChangedInfo.column?.columnId,
                                 });
                     }
                     catch (error) {

package/src/Strategy/PlusMinusModule.js

@@ -177,15 +177,15 @@ export class PlusMinusModule extends AdaptableModuleBase {
     }
     isPlusMinusNudgeApplied(plusMinusNudge, gridCell) {
         if (plusMinusNudge.Rule?.BooleanExpression) {
-            return this.evaluateExpression(plusMinusNudge, gridCell.rowNode);
+            return this.evaluateExpression(plusMinusNudge, gridCell.rowNode, gridCell.column);
         }
         return true;
     }
-    evaluateExpression(plusMinusNudge, node) {
+    evaluateExpression(plusMinusNudge, node, column) {
         try {
             return this.api.internalApi
                 .getQueryLanguageService()
-                .evaluateBooleanExpression(plusMinusNudge.Rule?.BooleanExpression, PlusMinusModuleId, node);
+                .evaluateBooleanExpression(plusMinusNudge.Rule?.BooleanExpression, PlusMinusModuleId, node, { columnScope: column?.columnId });
         }
         catch (error) {
             errorOnce(error.message);

package/src/Strategy/SmartEditModule.js

@@ -100,7 +100,7 @@ export class SmartEditModule extends AdaptableModuleBase {
         let previewResults = [];
         let column;
         if (!this.api.layoutApi.isCurrentLayoutPivot()) {
-            if (ArrayExtensions.IsNotNullOrEmpty(selectedCellInfo.columns)) {
+            if (selectedCellInfo != null && selectedCellInfo.columns.length > 0) {
                 column = this.api.columnApi.getColumnWithColumnId(selectedCellInfo.columns[0].columnId);
                 if (column) {
                     selectedCellInfo.gridCells.forEach((selectedCell) => {

package/src/Utilities/Constants/GeneralConstants.js

@@ -1,4 +1,5 @@
 import { AUTO_GROUP_COLUMN_ID__SINGLE } from '../../layout-manager/src/normalizeLayoutModel';
+import { LayoutManager } from '../../layout-manager/src';
 export const AUTOGENERATED_PK_COLUMN = '__ADAPTABLE_PK__';
 export const MISSING_COLUMN = ' [MISSING]';
 export const LIGHT_THEME = 'light';
@@ -22,7 +23,7 @@ export const HALF_SECOND = 500;
 export const QUARTER_SECOND = 250;
 export const GROUP_PATH_SEPARATOR = '/';
 export const AG_GRID_GROUPED_COLUMN = AUTO_GROUP_COLUMN_ID__SINGLE;
-export const AG_GRID_SELECTION_COLUMN = 'ag-Grid-SelectionColumn';
+export const AG_GRID_SELECTION_COLUMN = LayoutManager.SELECTION_COLUMN_ID;
 export const AG_GRID_PIVOT_COLUMN = 'pivot_';
 export const AG_GRID_PIVOT_GRAND_TOTAL_COLUMN = 'PivotRowTotal_pivot_';
 export const AG_GRID_CHART_WINDOW = 'AG Grid Window';

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

@@ -2,7 +2,7 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Boolean Functions available in AdaptableQL
  */
-export type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'IS_NUMERIC' | 'REGEX' | 'IS_HOLIDAY' | 'IS_WORKDAY' | 'TRUE' | 'FALSE';
+export type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'IS_NUMERIC' | 'REGEX' | 'IS_TODAY' | 'IS_YESTERDAY' | 'IS_TOMORROW' | 'IS_HOLIDAY' | 'IS_WORKDAY' | 'TRUE' | 'FALSE';
 export declare const booleanExpressionFunctions: Record<BooleanFunctionName, ExpressionFunction>;
 export declare const booleanExpressionFunctionsNames: BooleanFunctionName[];
 export declare const isBooleanAdaptableQlFunction: (functionName: string) => functionName is BooleanFunctionName;

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -254,8 +254,8 @@ export const booleanExpressionFunctions = {
         },
         category: 'strings',
         description: 'Returns true if 1st input contains 2nd input',
-        signatures: ['CONTAINS(a: string, b: string)'],
-        examples: ['CONTAINS([col1], "S")'],
+        signatures: ['value1 CONTAINS value2', 'CONTAINS(a: string, b: string)'],
+        examples: ['[col1] CONTAINS "S"', 'CONTAINS([col1], "S")'],
         returnType: 'boolean',
         inputs: ['text', 'text'],
     },
@@ -325,6 +325,45 @@ export const booleanExpressionFunctions = {
         category: 'strings',
         returnType: 'boolean',
     },
+    IS_TODAY: {
+        handler(args, context) {
+            const dateToCheck = normalizeDateParam(args[0]);
+            return context.adaptableApi.calendarApi.isToday(dateToCheck);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input date is today',
+        signatures: ['IS_TODAY(a: date)'],
+        examples: ['IS_TODAY([columnName])'],
+        category: 'dates',
+        returnType: 'boolean',
+        inputs: ['date'],
+    },
+    IS_YESTERDAY: {
+        handler(args, context) {
+            const dateToCheck = normalizeDateParam(args[0]);
+            return context.adaptableApi.calendarApi.isYesterday(dateToCheck);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input date is yesterday',
+        signatures: ['IS_YESTERDAY(a: date)'],
+        examples: ['IS_YESTERDAY([columnName])'],
+        category: 'dates',
+        returnType: 'boolean',
+        inputs: ['date'],
+    },
+    IS_TOMORROW: {
+        handler(args, context) {
+            const dateToCheck = normalizeDateParam(args[0]);
+            return context.adaptableApi.calendarApi.isTomorrow(dateToCheck);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input date is tomorrow',
+        signatures: ['IS_TOMORROW(a: date)'],
+        examples: ['IS_TOMORROW([columnName])'],
+        category: 'dates',
+        returnType: 'boolean',
+        inputs: ['date'],
+    },
     IS_HOLIDAY: {
         handler(args, context) {
             const dateToCheck = normalizeDateParam(args[0]);

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

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Scalar Functions available in AdaptableQL
  */
-export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'FIELD' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'PERCENT_CHANGE' | 'ABSOLUTE_CHANGE' | 'ANY_CHANGE' | 'IS_BLANK' | 'IS_NOT_BLANK';
+export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'CURRENT_DAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'FIELD' | '$SCOPE' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'PERCENT_CHANGE' | 'ABSOLUTE_CHANGE' | 'ANY_CHANGE' | 'IS_BLANK' | 'IS_NOT_BLANK';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
 export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -90,6 +90,35 @@ export const scalarExpressionFunctions = {
         category: 'special',
         returnType: 'any',
     },
+    $SCOPE: {
+        handler(args, context) {
+            const scopeColumnId = context.columnScope;
+            if (!scopeColumnId) {
+                throw new ExpressionEvaluationError('$SCOPE', `$SCOPE is not available in this context`);
+            }
+            const column = context.adaptableApi?.columnApi.getColumnWithColumnId(scopeColumnId);
+            if (!column) {
+                throw new ExpressionEvaluationError('$SCOPE', `Column name "${scopeColumnId}" is not found`);
+            }
+            if (!column.queryable) {
+                throw new ExpressionEvaluationError('$SCOPE', `Column name "${scopeColumnId}" is not queryable`);
+            }
+            // see #derived_pivot_cell_style
+            if (context.pivotResultColumn) {
+                const baseColumnId = context.pivotResultColumn.getColDef()?.pivotValueColumn?.getColId();
+                if (baseColumnId === scopeColumnId) {
+                    // we evaluate the pivot result column instead of the base column
+                    return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, context.pivotResultColumn.getColId());
+                }
+            }
+            return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, scopeColumnId);
+        },
+        description: 'Returns the value of the column in the current scope',
+        signatures: ['$SCOPE()'],
+        examples: ['$SCOPE() > 10'],
+        category: 'special',
+        returnType: 'any',
+    },
     QUERY: {
         handler(args, context) {
             const namedQueryName = args[0];
@@ -709,8 +738,8 @@ export const scalarExpressionFunctions = {
                 return context.dataChangedEvent.oldValue !== context.dataChangedEvent.newValue;
             }
             // only COL argument is supported
-            if (columnArg.type !== 'COL') {
-                throw new ExpressionEvaluationError('ANY_CHANGE', 'accepts only a column reference as an argument');
+            if (columnArg.type !== 'COL' && columnArg.type !== '$SCOPE') {
+                throw new ExpressionEvaluationError('ANY_CHANGE', 'accepts only a column reference or scope as an argument');
             }
             const currentColumnValue = evaluateNode(columnArg, context);
             const previousValue = context.dataChangedEvent.oldValue;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -9,11 +9,37 @@ const GET_CURRENT_VERSION = () => {
         : packageJson.version) ?? packageJson.version);
 };
 export function addUuidsToInitialState(initialState) {
+    // Collect only the objects that should receive metadata:
+    // module state objects and their direct array items (root-level AdaptableObjects).
+    // Deeply nested sub-objects (e.g. CellRanges, ColumnComparison) are excluded.
+    const objectsToEnrich = new Set();
+    for (const moduleKey in initialState) {
+        const moduleState = initialState[moduleKey];
+        if (isPlainObject(moduleState)) {
+            objectsToEnrich.add(moduleState);
+            for (const key in moduleState) {
+                const value = moduleState[key];
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (isPlainObject(item)) {
+                            objectsToEnrich.add(item);
+                            // ColumnFilters are nested inside Layouts but need Uuid
+                            // for identification (suspend/unsuspend, edit vs add, etc.)
+                            if (Array.isArray(item.ColumnFilters)) {
+                                for (const filter of item.ColumnFilters) {
+                                    if (isPlainObject(filter)) {
+                                        objectsToEnrich.add(filter);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     const customizer = (value) => {
-        // so whenever we clone a plain object,
-        // we add a Uuid property
-        // jw added 9/8/20: unless there is on there already
-        if (isPlainObject(value) && value != initialState) {
+        if (isPlainObject(value) && objectsToEnrich.has(value)) {
             if (value.Uuid == null || value.Uuid == undefined) {
                 value.Uuid = createUuid();
             }

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

@@ -13,6 +13,7 @@ import { ExpressionFunctionMap } from '../../../parser/src/types';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: IRowNode, evalContext?: {
         dataChangedEvent?: CellDataChangedInfo;
+        columnScope?: string;
         pivotResultColumn?: Column;
     }): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;

package/src/Utilities/Services/MetamodelService.js

@@ -20,7 +20,7 @@ export class MetamodelService {
     getGridInfoNoCodeOptions() {
         return this.buildGridInfoOptions({
             filterItemProperty: (itemProperty) => {
-                return itemProperty.noCode === 'item';
+                return itemProperty.nC === 'item';
             },
             filterEmptyAdaptableOptions: false,
         });
@@ -50,7 +50,7 @@ export class MetamodelService {
             if (optionKey === 'fdc3Options') {
                 return;
             }
-            const optionMetamodel = optionsObjectMetamodel?.props?.find((metamodelProperty) => metamodelProperty.name === optionKey);
+            const optionMetamodel = optionsObjectMetamodel?.p?.find((metamodelProperty) => metamodelProperty.n === optionKey);
             // Return if property not found - log if not 'Revision' or 'Uuid' or 'AdaptableVersion'
             if (!optionMetamodel) {
                 if (optionKey === 'Revision' || optionKey === 'Uuid' || optionKey === 'AdaptableVersion') {
@@ -69,10 +69,10 @@ export class MetamodelService {
             }
             // if it's a REFERENCE, we try to go (recursively) deeper
             if (expectedOptionsValueType === 'R') {
-                const referenceObjectName = optionMetamodel.ref;
+                const referenceObjectName = optionMetamodel.r;
                 const referenceObject = optionsObject[optionKey];
                 const referenceObjectMetamodel = this.getAdaptableMetamodel()[referenceObjectName];
-                if (referenceObject && referenceObjectMetamodel?.kind === 'I') {
+                if (referenceObject && referenceObjectMetamodel?.k === 'I') {
                     this.validateOptionsObject(validationErrors, referenceObjectName, referenceObject, referenceObjectMetamodel, optionsObjectDefaultValues?.[optionKey]);
                 }
             }
@@ -83,7 +83,7 @@ export class MetamodelService {
         });
     }
     getExpectedOptionsValueType(metamodelProperty) {
-        const metamodelPropertyKind = metamodelProperty.kind;
+        const metamodelPropertyKind = metamodelProperty.k;
         if (supportedMetamodelTypes.includes(metamodelPropertyKind)) {
             return metamodelPropertyKind;
         }
@@ -106,11 +106,11 @@ export class MetamodelService {
             items: baseOptionsItems,
         });
         // map containers
-        adaptableOptionsMetamodel.props
-            .filter((optionItem) => optionItem.gridInfo === 'container')
+        adaptableOptionsMetamodel.p
+            .filter((optionItem) => optionItem.g === 'container')
             .forEach((containerOptionItem) => {
-            const containerMetamodelName = containerOptionItem.ref;
-            const adaptableOptionsName = containerOptionItem.name;
+            const containerMetamodelName = containerOptionItem.r;
+            const adaptableOptionsName = containerOptionItem.n;
             const containerOptionsMetamodel = adaptableMetamodel[containerMetamodelName];
             // @ts-ignore
             const containerOptionsValues = adaptableOptionsValues[adaptableOptionsName];
@@ -123,21 +123,21 @@ export class MetamodelService {
                 return;
             }
             const optionItems = this.mapGridInfoContainerItems(containerOptionsMetamodel, containerOptionsValues, containerOptionsDefaultValues, filterItemProperty);
-            gridInfoOptions.set(containerOptionItem.name, {
+            gridInfoOptions.set(containerOptionItem.n, {
                 containerLabel: this.extractUiLabel(containerOptionItem),
                 items: optionItems,
             });
         });
         return gridInfoOptions;
     }
-    mapGridInfoContainerItems(optionItemContainer, adaptableOptionsValues, defaultAdaptableOptionsValues, filter = (itemProperty) => itemProperty.gridInfo === 'item') {
-        return optionItemContainer.props.filter(filter).map((itemProperty) => {
+    mapGridInfoContainerItems(optionItemContainer, adaptableOptionsValues, defaultAdaptableOptionsValues, filter = (itemProperty) => itemProperty.g === 'item') {
+        return optionItemContainer.p.filter(filter).map((itemProperty) => {
             return {
-                name: itemProperty.name,
-                value: adaptableOptionsValues?.[itemProperty.name],
-                defaultValue: defaultAdaptableOptionsValues[itemProperty.name],
-                kind: itemProperty.kind,
-                description: StringExtensions.UnescapeHtmlEntities(itemProperty.desc),
+                name: itemProperty.n,
+                value: adaptableOptionsValues?.[itemProperty.n],
+                defaultValue: defaultAdaptableOptionsValues[itemProperty.n],
+                kind: itemProperty.k,
+                description: StringExtensions.UnescapeHtmlEntities(itemProperty.d ?? ''),
                 uiLabel: this.extractUiLabel(itemProperty),
             };
         });
@@ -152,7 +152,7 @@ export class MetamodelService {
         return this.getAdaptableMetamodel()['AdaptableOptions'];
     }
     extractUiLabel(item) {
-        return item.uiLabel || this.formatCamelCaseToHumanText(item.name);
+        return item.l || this.formatCamelCaseToHumanText(item.n);
     }
     formatCamelCaseToHumanText(camelCase) {
         if (!camelCase || camelCase == null) {

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

@@ -19,6 +19,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any, evalContext?: {
         dataChangedEvent?: CellDataChangedInfo;
         pivotResultColumn?: Column;
+        columnScope?: string;
     }): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
@@ -54,4 +55,5 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     private getBooleanAndScalarFunctions;
     private getExpressionCacheKey;
     getNodesFromExpression(input: string, nodeType: string): string[];
+    validateCircularQueryReferences(expression: string, module: AdaptableModule): void;
 }

package/src/Utilities/Services/QueryLanguageService.js

@@ -32,6 +32,7 @@ export class QueryLanguageService {
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
             dataChangedEvent: evalContext?.dataChangedEvent,
             pivotResultColumn: evalContext?.pivotResultColumn,
+            columnScope: evalContext?.columnScope,
             ...this.adaptableApi.internalApi.buildBaseContext(),
         });
     }
@@ -116,14 +117,7 @@ export class QueryLanguageService {
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
             }
-            // evaluating the expression is the only way to catch circular named query references
-            const firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
-            // Mock datachangedevent for change-based functions e.g. PERCENT_CHANGE
-            const dataChangedEvent = {
-                newValue: 100,
-                oldValue: 150,
-            };
-            this.evaluateBooleanExpression(expression, module, firstRowNode, { dataChangedEvent });
+            this.validateCircularQueryReferences(expression, module);
             const result = {
                 isValid: true,
                 errorMessage: '',
@@ -274,6 +268,8 @@ export class QueryLanguageService {
             const columnFriendlyName = this.adaptableApi.columnApi.getFriendlyNameForColumnId(columnId);
             result = result.split(columnId).join(columnFriendlyName);
         });
+        // replace $SCOPE() with friendly name as well
+        result = result.split(`$SCOPE()`).join(`"<Column Scope>"`);
         return result;
     }
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
@@ -543,4 +539,20 @@ export class QueryLanguageService {
             return [];
         }
     }
+    validateCircularQueryReferences(expression, module) {
+        if (!expression || expression.trim() === '') {
+            return;
+        }
+        const queryNodes = this.getNodesFromExpression(expression, 'QUERY');
+        if (!queryNodes.length) {
+            return;
+        }
+        // circular QUERY references can only be detected by actually evaluating the expression
+        // we just evaluate against the first row, as we don't care about the result, just about
+        // whether an exception is thrown
+        const firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
+        queryNodes.forEach((queryNode) => {
+            this.evaluateBooleanExpression(`QUERY("${queryNode}")`, module, firstRowNode);
+        });
+    }
 }

package/src/Utilities/Services/ValidationService.js

@@ -28,7 +28,9 @@ export class ValidationService {
                             cellDataChangedInfo.rowNode != null &&
                                 this.adaptableApi.internalApi
                                     .getQueryLanguageService()
-                                    .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, AlertModuleId, cellDataChangedInfo.rowNode);
+                                    .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, AlertModuleId, cellDataChangedInfo.rowNode, {
+                                    columnScope: cellDataChangedInfo.column?.columnId,
+                                });
                     }
                     catch (error) {
                         isSatisfiedExpression = false;

package/src/View/Components/EntityRulesEditor/index.js

@@ -147,7 +147,7 @@ export const EntityRulesEditor = (props) => {
                 React.createElement(EntityRulePredicatesEditor, { enablePredicateColumnId: props.enablePredicateColumnId, data: data, descriptions: descriptions, predicateDefs: filteredPredicateDefs, getPredicateDefsForColId: props.getPredicateDefsForColId, onChange: props.onChange }))) : null,
             showBoolean ? (React.createElement(QueryTab, { showRadio: showRadioButtons, value: "BooleanExpression", type: type, label: "Boolean" })) : null,
             showBoolean ? (React.createElement(Tabs.Content, { "data-name": "BooleanExpression", value: 'BooleanExpression' }, (() => {
-                const editor = (React.createElement(ExpressionEditor, { type: 'boolean', module: module, value: data.Rule?.BooleanExpression, onChange: setBooleanExpression, initialData: initialData, columns: api.columnApi.internalApi.getQueryableColumnsForUIEditor(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api, showQueryBuilder: props.showQueryBuilder }));
+                const editor = (React.createElement(ExpressionEditor, { type: 'boolean', module: module, value: data.Rule?.BooleanExpression, onChange: setBooleanExpression, initialData: initialData, columns: api.columnApi.internalApi.getQueryableColumnsForUIEditor(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api, showQueryBuilder: props.showQueryBuilder, columnScope: data.Scope }));
                 return props.showQueryBuilder ? React.createElement(Panel, null, editor) : editor;
             })())) : null,
             showObservable ? (React.createElement(QueryTab, { showRadio: showRadioButtons, value: "ObservableExpression", type: type, label: "Observable" })) : null,

package/src/View/Components/ModuleValueSelector/index.js

@@ -26,5 +26,13 @@ export const ModuleValueSelector = (props) => {
     const sortedOptions = useMemo(() => {
         return ArrayExtensions.sortArrayWithOrder(options, value, { sortUnorderedItems: true });
     }, [allowReorder, options, value]);
-    return (React.createElement(ValueSelector, { ...valueSelectorProps, options: sortedOptions, value: value, onChange: onChange, allowReorder: allowReorder, toIdentifier: (module) => module, toLabel: (module) => moduleLabelMap.get(module), isOptionDisabled: props.isOptionDisabled, disabled: props.disabled }));
+    const moduleFilter = useCallback((module, searchText) => {
+        // the module name is camelCased so I want to split it
+        // so we can also use spaces in the search text
+        const parts = module.split(/(?=[A-Z])/);
+        const withSpaces = parts.join(' ');
+        return (module.toLowerCase().includes(searchText.toLowerCase()) ||
+            withSpaces.toLowerCase().includes(searchText.toLowerCase()));
+    }, []);
+    return (React.createElement(ValueSelector, { ...valueSelectorProps, options: sortedOptions, value: value, onChange: onChange, showFilterInput: true, filter: moduleFilter, allowReorder: allowReorder, toIdentifier: (module) => module, toLabel: (module) => moduleLabelMap.get(module), isOptionDisabled: props.isOptionDisabled, disabled: props.disabled }));
 };