@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.0

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -285,11 +285,9 @@ export const booleanExpressionFunctions = {
     },
     ANY_CONTAINS: {
         handler(args, context) {
-            var _a;
             const searchTerm = getStringValue(context, String(args[0]));
-            return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumns().some((column) => {
-                var _a;
-                const value = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.gridApi.getDisplayValueFromRowNode(context.node, column.columnId);
+            return context.adaptableApi?.columnApi.getColumns().some((column) => {
+                const value = context.adaptableApi?.gridApi.getDisplayValueFromRowNode(context.node, column.columnId);
                 const columnValue = getStringValue(context, String(value));
                 return columnValue.indexOf(searchTerm) !== -1;
             });

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

@@ -32,4 +32,5 @@ export declare class DeepMap<KeyType, ValueType> {
     topDownValues(): ValueType[];
     private sortedIterator;
 }
+export declare function once<ReturnType>(fn: () => ReturnType): () => ReturnType;
 export {};

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -35,7 +35,7 @@ export class DeepMap {
                     i++;
                 }
                 else {
-                    next === null || next === void 0 ? void 0 : next();
+                    next?.();
                 }
             });
         };
@@ -76,7 +76,6 @@ export class DeepMap {
         return this;
     }
     get(keys) {
-        var _a;
         let currentMap = this.map;
         if (!keys.length) {
             throw `Cannot get given keys - please provide a non-empty keys array.`;
@@ -86,7 +85,7 @@ export class DeepMap {
             const key = keys[i];
             const last = i === len - 1;
             if (last) {
-                return (_a = currentMap.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+                return currentMap.get(key)?.value;
             }
             else {
                 const pair = currentMap.get(key);
@@ -162,9 +161,9 @@ export class DeepMap {
         while (maps.length) {
             let map = maps.pop();
             let key = keys.pop();
-            if (key && (map === null || map === void 0 ? void 0 : map.size) === 0) {
+            if (key && map?.size === 0) {
                 let parentMap = maps[maps.length - 1];
-                let pair = parentMap === null || parentMap === void 0 ? void 0 : parentMap.get(key);
+                let pair = parentMap?.get(key);
                 if (pair) {
                     // pair.map === map ; which can be deleted
                     delete pair.map;
@@ -226,7 +225,7 @@ export class DeepMap {
     getArray(fn) {
         const result = [];
         this.visit((pair, keys) => {
-            result.push(fn(Object.assign(Object.assign({}, pair), { keys })));
+            result.push(fn({ ...pair, keys }));
         });
         return result;
     }
@@ -252,7 +251,7 @@ export class DeepMap {
     sortedIterator(fn) {
         const result = [];
         this.visit((pair, keys) => {
-            result.push(Object.assign(Object.assign({}, pair), { keys }));
+            result.push({ ...pair, keys });
         });
         result.sort(SORT_ASC_REVISION);
         function* makeIterator() {
@@ -263,7 +262,7 @@ export class DeepMap {
         return makeIterator();
     }
 }
-function once(fn) {
+export function once(fn) {
     let called = false;
     let result = null;
     const onceFn = () => {

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

@@ -2,7 +2,7 @@ import { ExpressionContext } from '../../parser/src/types';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { Observable } from 'rxjs';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
-import { GridDataChangedInfo } from '../../types';
+import { RowDataChangedInfo } from '../../types';
 export interface BaseParameter<T = string, N = string> {
     type: T;
     name: N;
@@ -14,18 +14,18 @@ export declare const getStringValues: (context: ExpressionContext, ...stringArgu
 export declare const getStringValue: (context: ExpressionContext, stringArgument: string) => string;
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
-export declare const getGridChangeLog$: (context: ExpressionContext, gridChangeType: GridDataChangedInfo['rowTrigger']) => Observable<GridDataChangedInfo>;
+export declare const getGridChangeLog$: (context: ExpressionContext, rowChangeType: RowDataChangedInfo['rowTrigger']) => Observable<RowDataChangedInfo>;
 export declare const handleWhereFunction: (args: ExpressionNode[], context: ExpressionContext) => any;
 export type ExpressionNode = any;
 export declare const evaluateExpressionNode: (expressionNode: ExpressionNode, context: ExpressionContext, filterFn?: (item: any) => boolean) => any;
 export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
 export declare const extractColumnParameters: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter[];
-export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], config?: {
+export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T['type'], allowedOperands: T['name'][], args: BaseParameter[], config?: {
     isOptional?: boolean;
-}) => T;
-export declare const extractParameters: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], config?: {
+}) => T | undefined;
+export declare const extractParameters: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T['type'], allowedOperands: T['name'][], args: BaseParameter[], config?: {
     isOptional?: boolean;
-}) => T[];
+}) => T[] | undefined;
 export declare const handleColumnFunction: (args: any[], context: ExpressionContext) => ColumnParameter;
-export declare const getNumericValue: (input: unknown) => number;
-export declare const validateColumnType: (columnId: string, validColumnTypes: ('Number' | 'String' | 'Date')[], consumingFunction: string, api: AdaptableApi) => import("../../types").AdaptableColumnDataType;
+export declare const getNumericValue: (input: unknown, returnRawValue?: boolean) => number;
+export declare const validateColumnType: (columnId: string, validColumnTypes: ('number' | 'text' | 'date')[], consumingFunction: string, api: AdaptableApi) => import("../../types").AdaptableColumnDataType;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -17,7 +17,7 @@ export const isTextSearchCaseInsensitive = (context) => !context.adaptableApi.ex
 // returns an observable which filters the source$ emissions and emits only if the CellDataChangedInfo relates to the given column
 // optionally, if a filter function (where clause) is provided, it is also evaluated
 export const getDataChangeLog$ = (context, columnNameFilter) => {
-    let dataChangeLog$ = context.adaptableApi.internalApi.getDataService().dataChangeLog$;
+    let dataChangeLog$ = context.adaptableApi.internalApi.getDataService().cellDataChangeLog$;
     // filter only the given column changes
     dataChangeLog$ = dataChangeLog$.pipe(filter((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
     // filter based on the WHERE clause
@@ -28,9 +28,9 @@ export const getDataChangeLog$ = (context, columnNameFilter) => {
     }
     return dataChangeLog$;
 };
-export const getGridChangeLog$ = (context, gridChangeType) => {
-    const gridChangeLog$ = context.adaptableApi.internalApi.getDataService().gridChangeLog$;
-    let gridChangeStream$ = gridChangeLog$.pipe(filter((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
+export const getGridChangeLog$ = (context, rowChangeType) => {
+    const gridChangeLog$ = context.adaptableApi.internalApi.getDataService().rowDataChangeLog$;
+    let gridChangeStream$ = gridChangeLog$.pipe(filter((rowDataChangedInfo) => rowDataChangedInfo.rowTrigger === rowChangeType));
     // filter based on the WHERE clause
     if (context.filterFn) {
         gridChangeStream$ = gridChangeStream$.pipe(filter((value) => value.rowNodes.some((node) => context.filterFn(node))));
@@ -44,11 +44,9 @@ export const handleWhereFunction = (args, context) => {
         // whereClauseResult
         return evaluateNode(whereClauseExpressionNode, {
             node: rowNode,
-            userName: context.adaptableApi.optionsApi.getUserName(),
-            adaptableId: context.adaptableApi.optionsApi.getAdaptableId(),
-            adaptableApi: context.adaptableApi,
             functions: context.whereClauseFunctions,
             evaluateCustomQueryVariable: context.adaptableApi.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
+            ...context.adaptableApi.internalApi.buildBaseContext(),
         });
     };
     // observableExpressionResult
@@ -57,12 +55,10 @@ export const handleWhereFunction = (args, context) => {
 export const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
     return evaluateNode(expressionNode, {
         node: context.node,
-        adaptableApi: context.adaptableApi,
-        userName: context.adaptableApi.optionsApi.getUserName(),
-        adaptableId: context.adaptableApi.optionsApi.getAdaptableId(),
         functions: context.functions,
         filterFn,
         evaluateCustomQueryVariable: context.adaptableApi.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
+        ...context.adaptableApi.internalApi.buildBaseContext(),
     });
 };
 export const extractColumnParameter = (consumingFunctionName, args) => {
@@ -82,8 +78,8 @@ export const extractParameter = (consumingFunctionName, allowedType, allowedOper
     return parameters[0];
 };
 export const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
-    const { isOptional } = config !== null && config !== void 0 ? config : {};
-    const result = args.filter((arg) => (arg === null || arg === void 0 ? void 0 : arg.type) === allowedType && allowedOperands.includes(arg === null || arg === void 0 ? void 0 : arg.name));
+    const { isOptional } = config ?? {};
+    const result = args.filter((arg) => arg?.type === allowedType && allowedOperands.includes(arg?.name));
     if (isOptional && !result.length) {
         return;
     }
@@ -104,11 +100,14 @@ export const handleColumnFunction = (args, context) => {
     };
     return result;
 };
-export const getNumericValue = (input) => {
+export const getNumericValue = (input, returnRawValue) => {
     if (typeof input === 'number') {
         return input;
     }
     const numericValue = toNumber(input);
+    if (returnRawValue === true) {
+        return numericValue;
+    }
     return isNaN(numericValue) ? 0 : numericValue;
 };
 export const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -8,7 +8,7 @@ export function group(groupParams, data) {
     const deepMap = new DeepMap();
     let currentGroupKeys = [];
     const initialReducerValue = initReducers(reducers);
-    const globalReducerResults = Object.assign({}, initialReducerValue);
+    const globalReducerResults = { ...initialReducerValue };
     for (let i = 0, len = data.length; i < len; i++) {
         let item = data[i];
         for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
@@ -18,7 +18,7 @@ export function group(groupParams, data) {
             if (!deepMap.has(currentGroupKeys)) {
                 const deepMapGroupValue = {
                     items: [],
-                    reducerResults: Object.assign({}, initialReducerValue),
+                    reducerResults: { ...initialReducerValue },
                 };
                 deepMap.set(currentGroupKeys, deepMapGroupValue);
             }
@@ -37,7 +37,7 @@ export function group(groupParams, data) {
     if (hasReducersWithDoneFn) {
         deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
             completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
-            next === null || next === void 0 ? void 0 : next();
+            next?.();
         });
     }
     if (hasReducersWithDoneFn) {
@@ -72,7 +72,6 @@ function initReducers(reducers) {
  *
  */
 function computeReducersFor(data, reducers, reducerResults) {
-    var _a, _b;
     if (!reducers || !Object.keys(reducers).length) {
         return;
     }
@@ -83,7 +82,7 @@ function computeReducersFor(data, reducers, reducerResults) {
                 continue;
             }
             const currentValue = reducerResults[key];
-            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            const value = reducer.field ? data[reducer.field] : reducer.getter?.(data) ?? null;
             reducerResults[key] = reducer.reducer(currentValue, value, data);
         }
 }

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -30,12 +30,12 @@ export const observableExpressionFunctions = {
                     return getDataChangeCount$(dataChangeLog$, timeframeChange$, operandParameter.value);
                 }
                 case 'MIN': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
+                    validateColumnType(operandParameter.column, ['number'], 'MIN', context.adaptableApi);
                     const timeframeChange$ = getTrailingRowValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMin$(dataChangeLog$, timeframeChange$);
                 }
                 case 'MAX': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
+                    validateColumnType(operandParameter.column, ['number'], 'MAX', context.adaptableApi);
                     const timeframeChange$ = getTrailingRowValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
@@ -70,12 +70,12 @@ export const observableExpressionFunctions = {
                     return getDataChangeCount$(dataChangeLog$, timeframeChange$, operandParameter.value);
                 }
                 case 'MIN': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
+                    validateColumnType(operandParameter.column, ['number'], 'MIN', context.adaptableApi);
                     const timeframeChange$ = getTrailingGridValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMin$(dataChangeLog$, timeframeChange$);
                 }
                 case 'MAX': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
+                    validateColumnType(operandParameter.column, ['number'], 'MAX', context.adaptableApi);
                     const timeframeChange$ = getTrailingGridValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
@@ -222,7 +222,6 @@ export const observableExpressionFunctions = {
     },
     TIMEFRAME: {
         handler(args, context) {
-            var _a;
             // unit -> milliseconds
             const durationUnitRatios = {
                 s: 1000,
@@ -232,8 +231,8 @@ export const observableExpressionFunctions = {
             const input = args[0] + '';
             //we allow only seconds, minutes & hours durations
             const matchingResult = input.match(TIMEFRAME_REGEX);
-            const value = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[1];
-            const unit = (_a = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[2]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const value = matchingResult?.[1];
+            const unit = matchingResult?.[2]?.toLowerCase();
             let duration;
             if (value && unit && durationUnitRatios[unit]) {
                 duration = parseInt(value) * durationUnitRatios[unit];
@@ -275,10 +274,9 @@ const isLastElementMinValue = (values) => {
 };
 // useful for functions which do NOT have an initial change (ex. GRID_CHANGE NONE)
 const getDataChangedInfoStub = (context) => {
-    var _a, _b;
     let rowNodeStub;
     if (!context.filterFn) {
-        rowNodeStub = (_a = context.node) !== null && _a !== void 0 ? _a : context.adaptableApi.gridApi.getFirstRowNode();
+        rowNodeStub = context.node ?? context.adaptableApi.gridApi.getFirstRowNode();
     }
     else {
         // if there is a WHERE clause defined, find the first rowNode which satisfies the condition
@@ -293,7 +291,7 @@ const getDataChangedInfoStub = (context) => {
     const rowNode = rowNodeStub;
     if (rowNode) {
         const primaryKeyValue = context.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
-        const columnId = (_b = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _b === void 0 ? void 0 : _b.columnId;
+        const columnId = context.adaptableApi.columnApi.getQueryableColumns()[0]?.columnId;
         const oldValue = context.adaptableApi.gridApi.getCellRawValue(primaryKeyValue, columnId);
         const column = context.adaptableApi.columnApi.getColumnWithColumnId(columnId);
         const newValue = oldValue;
@@ -370,7 +368,7 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
     return defer(() => {
         // keep the counter value in an internal intermediary state (distinct per row PK)
         const counterMap = new Map();
-        const getCellCounter = (dataChangeLog) => { var _a; return (_a = counterMap.get(dataChangeLog.primaryKeyValue)) !== null && _a !== void 0 ? _a : 0; };
+        const getCellCounter = (dataChangeLog) => counterMap.get(dataChangeLog.primaryKeyValue) ?? 0;
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             let currentCounter = getCellCounter(dataChangeLog);
             counterMap.set(dataChangeLog.primaryKeyValue, ++currentCounter);
@@ -424,7 +422,7 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
         // keep the changed values in an internal intermediary state (distinct per row PK)
         const rowValuesMap = new Map();
         const doubleInsertionsMap = new WeakMap();
-        const getRowValues = (dataChangeLog) => { var _a; return (_a = rowValuesMap.get(dataChangeLog.primaryKeyValue)) !== null && _a !== void 0 ? _a : []; };
+        const getRowValues = (dataChangeLog) => rowValuesMap.get(dataChangeLog.primaryKeyValue) ?? [];
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             let rowValues = getRowValues(dataChangeLog);
             if (!rowValues.length) {
@@ -499,18 +497,16 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
     }
     if (countValue === 0) {
         // handle special case when observing NO changes
-        const gridDataChangeInfoStub = {
+        const rowDataChangeInfoStub = {
             rowTrigger: consumingFunction === 'ROW_ADDED' ? 'Add' : 'Delete',
             rowNodes: [],
             dataRows: [],
             changedAt: Date.now(),
-            adaptableId: context.adaptableId,
-            adaptableApi: context.adaptableApi,
-            userName: context.userName,
+            ...context.adaptableApi.internalApi.buildBaseContext(),
         };
         return gridChangeLog$.pipe(
         // add a synthetic first value to ensure the grid is observed even when there are no changes
-        startWith(gridDataChangeInfoStub), 
+        startWith(rowDataChangeInfoStub), 
         // wait for the given time
         debounceTime(timeframeParameter.value), 
         // completing the observable (ex. alert deletion) will also fire the NONE event

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -38,7 +38,7 @@ export function aggregate(aggregateParams, data) {
     if (reducers) {
         deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
             completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
-            next === null || next === void 0 ? void 0 : next();
+            next?.();
         });
     }
     if (reducers) {
@@ -73,7 +73,6 @@ function initReducers(reducers) {
  *
  */
 function computeReducersFor(data, reducers, reducerResults, dataIndex) {
-    var _a, _b;
     if (!reducers || !Object.keys(reducers).length) {
         return;
     }
@@ -84,7 +83,7 @@ function computeReducersFor(data, reducers, reducerResults, dataIndex) {
                 continue;
             }
             const currentValue = reducerResults[key];
-            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            const value = reducer.field ? data[reducer.field] : reducer.getter?.(data) ?? null;
             reducerResults[key] = reducer.reducer(currentValue, value, data, dataIndex);
         }
 }

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' | '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' | '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

@@ -12,11 +12,12 @@ import differenceInDays from 'date-fns/differenceInDays';
 import differenceInWeeks from 'date-fns/differenceInWeeks';
 import differenceInMonths from 'date-fns/differenceInMonths';
 import differenceInYears from 'date-fns/differenceInYears';
-import { evaluateExpressionNode, isTextSearchCaseInsensitive, } from './expressionFunctionUtils';
+import { evaluateExpressionNode, getNumericValue, isTextSearchCaseInsensitive, } from './expressionFunctionUtils';
 import { normalizeDateParams } from './dateUtils';
 import StringExtensions from '../Extensions/StringExtensions';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
 import { evaluate } from '../../parser/src';
+import { evaluateNode } from '../../parser/src/evaluator';
 // useful for unary operators which expect a list of arguments
 // we extract the provided array elements into a list
 const flattenArguments = (values) => {
@@ -51,16 +52,15 @@ export const scalarExpressionFunctions = {
     },
     COL: {
         handler(args, context) {
-            var _a, _b;
             const columnId = args[0];
-            const column = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumnWithColumnId(columnId);
+            const column = context.adaptableApi?.columnApi.getColumnWithColumnId(columnId);
             if (!column) {
                 throw new ExpressionEvaluationError('COL', `Column name "${columnId}" is not found`);
             }
             if (!column.queryable) {
                 throw new ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
             }
-            return (_b = context.adaptableApi) === null || _b === void 0 ? void 0 : _b.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
+            return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
         },
         description: 'Returns the value of a Column',
         signatures: ['[colName]', 'COL(name: string)'],
@@ -70,12 +70,11 @@ export const scalarExpressionFunctions = {
     },
     FIELD: {
         handler(args, context) {
-            var _a, _b;
             const fieldName = args[0];
             if (StringExtensions.IsNullOrEmpty(fieldName)) {
                 throw new ExpressionEvaluationError('FIELD', 'requires a field name');
             }
-            return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.internalApi.getValueUsingField((_b = context.node) === null || _b === void 0 ? void 0 : _b.data, fieldName);
+            return context.adaptableApi?.internalApi.getValueUsingField(context.node?.data, fieldName);
         },
         description: 'Returns the value of a row field (not necessarily mapped to a column). If the field is nested, use dot notation (e.g. "nested.fieldName")',
         signatures: ['FIELD(fieldName:string)'],
@@ -85,12 +84,11 @@ export const scalarExpressionFunctions = {
     },
     QUERY: {
         handler(args, context) {
-            var _a, _b;
             const namedQueryName = args[0];
             if (StringExtensions.IsNullOrEmpty(namedQueryName)) {
                 return false;
             }
-            const namedQuery = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.namedQueryApi.getNamedQueryByName(namedQueryName);
+            const namedQuery = context.adaptableApi?.namedQueryApi.getNamedQueryByName(namedQueryName);
             if (!namedQuery) {
                 throw new ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
             }
@@ -108,7 +106,7 @@ export const scalarExpressionFunctions = {
             }
             const queryEvaluationResult = evaluate(namedQuery.BooleanExpression, context);
             // remove query name from callstack
-            (_b = context.namedQueryCallStack) === null || _b === void 0 ? void 0 : _b.pop();
+            context.namedQueryCallStack?.pop();
             return queryEvaluationResult;
         },
         category: 'special',
@@ -119,7 +117,7 @@ export const scalarExpressionFunctions = {
     },
     TO_ARRAY: {
         handler(args) {
-            if (!(args === null || args === void 0 ? void 0 : args.length)) {
+            if (!args?.length) {
                 return [];
             }
             return [...args];
@@ -601,5 +599,93 @@ export const scalarExpressionFunctions = {
         category: 'strings',
         returnType: 'string',
     },
+    PERCENT_CHANGE: {
+        handler(args, context) {
+            if (!context.dataChangedEvent) {
+                throw new ExpressionEvaluationError('PERCENT_CHANGE', 'is only valid in changed cell contexts');
+            }
+            const currentValue = getNumericValue(args[0], true);
+            if (Number.isNaN(currentValue)) {
+                throw new ExpressionEvaluationError('PERCENT_CHANGE', 'First argument should be numeric');
+            }
+            const previousValue = context.dataChangedEvent.oldValue;
+            const increaseDecrease = args[1];
+            let result;
+            if (!increaseDecrease) {
+                result = sanitizeNumericResult(Math.abs(((currentValue - previousValue) / previousValue) * 100));
+            }
+            else if (increaseDecrease === 'INCREASE') {
+                result =
+                    currentValue - previousValue > 0
+                        ? sanitizeNumericResult(((currentValue - previousValue) / previousValue) * 100)
+                        : undefined;
+            }
+            else if (increaseDecrease === 'DECREASE') {
+                result =
+                    currentValue - previousValue < 0
+                        ? sanitizeNumericResult(((previousValue - currentValue) / previousValue) * 100)
+                        : undefined;
+            }
+            else {
+                throw new ExpressionEvaluationError('PERCENT_CHANGE', 'Optional second argument must be "INCREASE" or "DECREASE"');
+            }
+            return result;
+        },
+        description: "Returns the percentage difference between a cell's current value and its previous value.",
+        signatures: [
+            'PERCENT_CHANGE( [colName], <INCREASE|DECREASE> )',
+            'PERCENT_CHANGE( COL(name: string), <INCREASE|DECREASE>)',
+        ],
+        examples: [
+            'PERCENT_CHANGE([col1])',
+            'PERCENT_CHANGE([col1], "INCREASE")',
+            'PERCENT_CHANGE([col1], "DECREASE")',
+        ],
+        category: 'changes',
+        returnType: 'number',
+    },
+    ABSOLUTE_CHANGE: {
+        handler(args, context) {
+            if (!context.dataChangedEvent) {
+                throw new ExpressionEvaluationError('ABSOLUTE_CHANGE', 'is only valid in changed cell contexts');
+            }
+            const currentValue = getNumericValue(args[0], true);
+            if (Number.isNaN(currentValue)) {
+                throw new ExpressionEvaluationError('ABSOLUTE_CHANGE', 'First argument should be numeric');
+            }
+            const previousValue = context.dataChangedEvent.oldValue;
+            return currentValue - previousValue;
+        },
+        description: "Returns the absolute difference between a cell's current value and its previous value.",
+        signatures: ['ABSOLUTE_CHANGE( [colName] )', 'ABSOLUTE_CHANGE( COL(name: string) )'],
+        examples: ['ABSOLUTE_CHANGE([col1])'],
+        category: 'changes',
+        returnType: 'number',
+    },
+    ANY_CHANGE: {
+        handler(args, context) {
+            if (!context.dataChangedEvent) {
+                throw new ExpressionEvaluationError('ANY_CHANGE', 'is only valid in changed cell contexts');
+            }
+            const columnArg = args[0];
+            if (!columnArg) {
+                // if no column is provided, we check if any value has changed
+                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');
+            }
+            const currentColumnValue = evaluateNode(columnArg, context);
+            const previousValue = context.dataChangedEvent.oldValue;
+            return currentColumnValue !== previousValue;
+        },
+        description: "Returns true if a cell's current value is different from its previous value, otherwise false. If no column is provided, it checks if any value has changed.",
+        signatures: ['ANY_CHANGE( [colName] )', 'ANY_CHANGE()'],
+        examples: ['ANY_CHANGE([col1])', 'ANY_CHANGE()'],
+        category: 'changes',
+        returnType: 'boolean',
+        hasEagerEvaluation: true,
+    },
 };
 export const scalarExpressionFunctionNames = getTypedKeys(scalarExpressionFunctions);

package/src/Utilities/Extensions/ArrayExtensions.d.ts

@@ -1,5 +1,6 @@
 import { SortOrder } from '../../PredefinedConfig/Common/Enums';
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+export type NonEmptyArray<T> = [T, ...Array<T>];
 export declare function GetLength(arrayToCheck: any[]): number;
 export declare function CorrectLength(arrayToCheck: any[], requiredLength: number): boolean;
 export declare function NotCorrectLength(arrayToCheck: any[], requiredLength: number): boolean;
@@ -27,9 +28,9 @@ export declare function areArraysEqualWithOrder(arr1: any[], arr2: any[]): boole
 export declare function areArraysEqualWithOrderandProperties(value: any[], other: any[]): boolean;
 export declare function sortArrayWithProperty(sortOrder: SortOrder, values: any[], sortProperty?: string): any[];
 export declare function sortArray(values: any[], sortOrder?: SortOrder): any[];
-export declare function sortCellValueArray(cellValues: GridCell[], sortOrder?: SortOrder): GridCell[];
-export declare function sortCellValueArrayNumeric(cellValues: GridCell[], sortOrder?: SortOrder): GridCell[];
-export declare function sortCellValueArrayDates(cellValues: GridCell[], sortOrder?: SortOrder): GridCell[];
+export declare function sortCellValueArray<T extends GridCell>(cellValues: T[], sortOrder?: SortOrder): T[];
+export declare function sortCellValueArrayNumeric<T extends GridCell>(cellValues: T[], sortOrder?: SortOrder): T[];
+export declare function sortCellValueArrayDates<T extends GridCell>(cellValues: T[], sortOrder?: SortOrder): T[];
 export declare function groupArrayBy(array: Array<any>, prop: string): Array<any>;
 export declare function createCommaSeparatedString(values: any[]): string;
 export declare function SumArray(array: (number | undefined)[]): number;
@@ -42,7 +43,7 @@ export declare function sortArrayWithOrder<T>(array: T[], order: T[],
  * in the current order in which they are in the array (sortUnorderedItems: false)
  * or to sort them using normal comparison rules
  */
-{ sortUnorderedItems: sortUnorderedItems }: {
+{ sortUnorderedItems }: {
     sortUnorderedItems: boolean;
 }): T[];
 export declare const ArrayExtensions: {

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -46,7 +46,7 @@ export function IsNotNull(arrayToCheck) {
     return !IsNull(arrayToCheck);
 }
 export function IsEmpty(arrayToCheck) {
-    return (arrayToCheck === null || arrayToCheck === void 0 ? void 0 : arrayToCheck.length) == 0;
+    return arrayToCheck?.length == 0;
 }
 export function IsNotEmpty(arrayToCheck) {
     return !IsEmpty(arrayToCheck);
@@ -278,7 +278,7 @@ export function sortArrayWithOrder(array, order,
  * in the current order in which they are in the array (sortUnorderedItems: false)
  * or to sort them using normal comparison rules
  */
-{ sortUnorderedItems: sortUnorderedItems }) {
+{ sortUnorderedItems }) {
     const itemsToIndex = array.reduce((acc, x, i) => {
         acc.set(x, i);
         return acc;
@@ -355,6 +355,6 @@ export const ArrayExtensions = {
     createCommaSeparatedString,
     SumArray,
     reorderArray,
-    sortArrayWithOrder
+    sortArrayWithOrder,
 };
 export default ArrayExtensions;

package/src/Utilities/Extensions/NumberExtensions.d.ts

@@ -1,7 +1,11 @@
 export declare function abbreviateNumber(numberToAbbreviate: number): string;
-export declare function WrapInParentheses(numberToWrap: number): string;
+export declare function wrapInParentheses(numberToWrap: number): string;
+export declare function timesBy100(value: any): any;
+export declare function divideBy100(value: any): any;
 export declare const NumberExtensions: {
     abbreviateNumber: typeof abbreviateNumber;
-    WrapInParentheses: typeof WrapInParentheses;
+    wrapInParentheses: typeof wrapInParentheses;
+    timesBy100: typeof timesBy100;
+    divideBy100: typeof divideBy100;
 };
 export default NumberExtensions;