@adaptabletools/adaptable 13.0.0-canary.8 → 13.0.0-canary.9

package/src/Utilities/Defaults/DefaultAdaptableOptions.js

@@ -5,13 +5,8 @@ const tslib_1 = require("tslib");
 const GeneralConstants = tslib_1.__importStar(require("../Constants/GeneralConstants"));
 const GeneralConstants_1 = require("../Constants/GeneralConstants");
 const UIHelper_1 = tslib_1.__importStar(require("../../View/UIHelper"));
-const booleanExpressionFunctions_1 = require("../ExpressionFunctions/booleanExpressionFunctions");
-const scalarExpressionFunctions_1 = require("../ExpressionFunctions/scalarExpressionFunctions");
-const observableExpressionFunctions_1 = require("../ExpressionFunctions/observableExpressionFunctions");
-const aggregatedBooleanExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedBooleanExpressionFunctions");
 const AdaptablePredicate_1 = require("../../PredefinedConfig/Common/AdaptablePredicate");
 const Enums_1 = require("../../PredefinedConfig/Common/Enums");
-const aggregatedScalarExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedScalarExpressionFunctions");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 // change type to DeepRequired<AdaptableOptions> to check which properties have no default values defined
 exports.DefaultAdaptableOptions = {
@@ -64,11 +59,11 @@ exports.DefaultAdaptableOptions = {
         customPredicateDefs: [],
         displayColumnFriendlyNamesForExpressions: true,
         expressionOptions: {
-            defaultBooleanFunctions: booleanExpressionFunctions_1.booleanExpressionFunctionsList,
-            defaultScalarFunctions: scalarExpressionFunctions_1.scalarExpressionFunctionsList,
-            defaultObservableFunctions: observableExpressionFunctions_1.observableExpressionFunctionsList,
-            defaultAggregatedBooleanFunctions: aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctionsList,
-            defaultAggregatedScalarFunctions: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctionsList,
+            systemBooleanFunctions: undefined,
+            systemScalarFunctions: undefined,
+            systemObservableFunctions: undefined,
+            systemAggregatedBooleanFunctions: undefined,
+            systemAggregatedScalarFunctions: undefined,
             moduleExpressionFunctions: undefined,
             queryableColumns: undefined,
             performExpressionValidation: true,

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

@@ -16,5 +16,5 @@ export interface ScalarAggregationOperand extends BaseParameter<'aggregationScal
     value: AggregatedScalarExpressionEvaluation;
 }
 export declare const aggregatedBooleanExpressionFunctions: Record<AggregatedBooleanFunctionName, ExpressionFunction>;
-export declare const aggregatedBooleanExpressionFunctionsList: Record<AggregatedBooleanFunctionName, ExpressionFunction>[];
+export declare const aggregatedBooleanExpressionFunctionNames: AggregatedBooleanFunctionName[];
 export {};

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedBooleanExpressionFunctionsList = exports.aggregatedBooleanExpressionFunctions = void 0;
+exports.aggregatedBooleanExpressionFunctionNames = exports.aggregatedBooleanExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const aggregatedScalarExpressionFunctions_1 = require("./aggregatedScalarExpressionFunctions");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 const SUPPORTED_AGGREGATION_FNS = ['SUM', 'MIN', 'MAX', 'AVG'];
 const aggregationScalarOperandMap = {
     SUM: ['string', 'number'],
@@ -174,6 +175,4 @@ const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
     // numeric value
     return (0, parseInt_1.default)(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
 };
-exports.aggregatedBooleanExpressionFunctionsList = Object.entries(exports.aggregatedBooleanExpressionFunctions).map(([functionName, expressionImplementation]) => ({
-    [functionName]: expressionImplementation,
-}));
+exports.aggregatedBooleanExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedBooleanExpressionFunctions);

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

@@ -42,5 +42,5 @@ export interface CumulatedAggregationValue {
 export declare const cumulativeAggregatedExpressionFunctions: AggregatedScalarFunctionName[];
 export declare const aggregatedExpressionFunctions: AggregatedScalarFunctionName[];
 export declare const aggregatedScalarExpressionFunctions: Record<AggregatedScalarFunctionName, ExpressionFunction>;
-export declare const aggregatedScalarExpressionFunctionsList: Record<AggregatedScalarFunctionName, ExpressionFunction>[];
+export declare const aggregatedScalarExpressionFunctionNames: AggregatedScalarFunctionName[];
 export {};

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedScalarExpressionFunctionsList = exports.aggregatedScalarExpressionFunctions = exports.aggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = void 0;
+exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpressionFunctions = exports.aggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = void 0;
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 exports.cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
     'OVER',
@@ -649,9 +650,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
     };
     return cumulationExpressionEvaluation;
 };
-exports.aggregatedScalarExpressionFunctionsList = Object.entries(exports.aggregatedScalarExpressionFunctions).map(([functionName, expressionImplementation]) => ({
-    [functionName]: expressionImplementation,
-}));
+exports.aggregatedScalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedScalarExpressionFunctions);
 // !! mutates expressionEvaluation
 const addGroupByParams = (groupByColumnNames, expressionEvaluation) => {
     if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {

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

@@ -4,4 +4,4 @@ import { ExpressionFunction } from '../../parser/src/types';
  */
 export declare type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'IS_BLANK' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'QUERY';
 export declare const booleanExpressionFunctions: Record<BooleanFunctionName, ExpressionFunction>;
-export declare const booleanExpressionFunctionsList: Record<BooleanFunctionName, ExpressionFunction>[];
+export declare const booleanExpressionFunctionsNames: BooleanFunctionName[];

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanExpressionFunctionsList = exports.booleanExpressionFunctions = void 0;
+exports.booleanExpressionFunctionsNames = exports.booleanExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const isAfter_1 = tslib_1.__importDefault(require("date-fns/isAfter"));
 const isBefore_1 = tslib_1.__importDefault(require("date-fns/isBefore"));
@@ -9,6 +9,7 @@ const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/String
 const src_1 = require("../../parser/src");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 exports.booleanExpressionFunctions = {
     OR: {
         handler(args) {
@@ -293,6 +294,4 @@ exports.booleanExpressionFunctions = {
         examples: ['QUERY("anyNamedQuery")'],
     },
 };
-exports.booleanExpressionFunctionsList = Object.entries(exports.booleanExpressionFunctions).map(([functionName, expressionImplementation]) => ({
-    [functionName]: expressionImplementation,
-}));
+exports.booleanExpressionFunctionsNames = (0, TypeExtensions_1.getTypedKeys)(exports.booleanExpressionFunctions);

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

@@ -6,5 +6,5 @@ export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | Obs
 declare type ObservableFunction = 'ROW_CHANGE' | 'GRID_CHANGE';
 declare type ChangeFunction = 'MAX' | 'MIN' | 'NONE' | 'COUNT';
 export declare const observableExpressionFunctions: Record<ObservableFunctionName, ExpressionFunction>;
-export declare const observableExpressionFunctionsList: Record<ObservableFunctionName, ExpressionFunction>[];
+export declare const observableExpressionFunctionNames: ObservableFunctionName[];
 export {};

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.observableExpressionFunctionsList = exports.observableExpressionFunctions = void 0;
+exports.observableExpressionFunctionNames = exports.observableExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 // numeric value(digits) followed by a single 's', 'm' or 'h' letter (case insensitive)
 const TIMEFRAME_REGEX = /^(\d+)(s|m|h)$/i;
 const SYSTEM_MAX_TIMEFRAME_SIZE = 86400000; // 24h
@@ -212,9 +213,7 @@ exports.observableExpressionFunctions = {
         examples: ["TIMEFRAME('20s')", "TIMEFRAME('5m')", "TIMEFRAME('1h')"],
     },
 };
-exports.observableExpressionFunctionsList = Object.entries(exports.observableExpressionFunctions).map(([functionName, expressionImplementation]) => ({
-    [functionName]: expressionImplementation,
-}));
+exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.observableExpressionFunctions);
 // return TRUE if the last(tail) element has the greatest value
 const isLastElementMaxValue = (values) => {
     const [tailValue] = values.slice(-1);

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

@@ -4,4 +4,4 @@ import { ExpressionFunction } from '../../parser/src/types';
  */
 export declare type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'TODAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'COL' | 'VAR';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
-export declare const scalarExpressionFunctionsList: Record<ScalarFunctionName, ExpressionFunction>[];
+export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scalarExpressionFunctionsList = exports.scalarExpressionFunctions = void 0;
+exports.scalarExpressionFunctionNames = exports.scalarExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const parseISO_1 = tslib_1.__importDefault(require("date-fns/parseISO"));
@@ -19,6 +19,7 @@ const differenceInYears_1 = tslib_1.__importDefault(require("date-fns/difference
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const dateUtils_1 = require("./dateUtils");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 const sanitizeArguments = (values, allowNaN) => {
     return values.filter((value) => value != undefined && value != null && value !== '' && (allowNaN || !isNaN(value)));
 };
@@ -356,6 +357,4 @@ exports.scalarExpressionFunctions = {
         examples: ['VAR(CURRENT_USER)', 'VAR(IS_VALID_VALUE, IS_BLANK([col1]), [col2] < [col3])'],
     },
 };
-exports.scalarExpressionFunctionsList = Object.entries(exports.scalarExpressionFunctions).map(([functionName, expressionImplementation]) => ({
-    [functionName]: expressionImplementation,
-}));
+exports.scalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.scalarExpressionFunctions);

package/src/Utilities/ObjectFactory.js

@@ -291,7 +291,6 @@ function CreateEmptyFormatColumn() {
         Style: CreateEmptyStyle(),
         DisplayFormat: undefined,
         CellAlignment: undefined,
-        HeaderName: undefined,
     };
 }
 exports.CreateEmptyFormatColumn = CreateEmptyFormatColumn;

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

@@ -43,9 +43,7 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     isCumulativeAggregate(input: string): boolean;
     getExpressionWithColumnFriendlyNames(expression?: string): string;
     getModuleExpressionFunctionsMap(module: AdaptableModule): ModuleExpressionFunctionsMap;
-    private getFunctionNames;
-    private extractDefaultExpressionFunctions;
-    private mapFunctionsDefinitionToMap;
+    private extractMappedExpressionFunctions;
     evaluateCustomQueryVariable(functionName: string, args?: any[]): any;
     private getBooleanAndScalarFunctions;
     private getExpressionCacheKey;

package/src/Utilities/Services/QueryLanguageService.js

@@ -275,7 +275,7 @@ class QueryLanguageService {
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
     getModuleExpressionFunctionsMap(module) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c;
         const expressionOptions = this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions;
         if (module) {
             let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
@@ -283,19 +283,19 @@ class QueryLanguageService {
                 return cachedResult;
             }
         }
-        const defaultBooleanExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultBooleanFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions);
-        const defaultScalarExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultScalarFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions);
-        const defaultObservableExpressionFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultObservableFunctions, observableExpressionFunctions_1.observableExpressionFunctions);
-        const defaultAggregatedBooleanFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions);
-        const defaultAggregatedScalarFunctions = this.extractDefaultExpressionFunctions(expressionOptions.defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions);
+        const generalBooleanExpressionFunctions = this.extractMappedExpressionFunctions(booleanExpressionFunctions_1.booleanExpressionFunctions, expressionOptions.systemBooleanFunctions, expressionOptions.customBooleanFunctions);
+        const generalScalarExpressionFunctions = this.extractMappedExpressionFunctions(scalarExpressionFunctions_1.scalarExpressionFunctions, expressionOptions.systemScalarFunctions, expressionOptions.customScalarFunctions);
+        const generalObservableExpressionFunctions = this.extractMappedExpressionFunctions(observableExpressionFunctions_1.observableExpressionFunctions, expressionOptions.systemObservableFunctions);
+        const generalAggregatedBooleanExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions, expressionOptions.systemAggregatedBooleanFunctions);
+        const generalAggregatedScalarExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions, expressionOptions.systemAggregatedScalarFunctions);
         if (!module) {
             (0, LoggingHelper_1.LogAdaptableInfo)(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
-                booleanFunctions: this.mapFunctionsDefinitionToMap(defaultBooleanExpressionFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions),
-                scalarFunctions: this.mapFunctionsDefinitionToMap(defaultScalarExpressionFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions),
-                observableFunctions: this.mapFunctionsDefinitionToMap(defaultObservableExpressionFunctions, observableExpressionFunctions_1.observableExpressionFunctions),
-                aggregatedBooleanFunctions: this.mapFunctionsDefinitionToMap(defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions),
-                aggregatedScalarFunctions: this.mapFunctionsDefinitionToMap(defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions),
+                booleanFunctions: generalBooleanExpressionFunctions,
+                scalarFunctions: generalScalarExpressionFunctions,
+                observableFunctions: generalObservableExpressionFunctions,
+                aggregatedBooleanFunctions: generalAggregatedBooleanExpressionFunctions,
+                aggregatedScalarFunctions: generalAggregatedScalarExpressionFunctions,
             };
         }
         let moduleExpressionFunctions;
@@ -303,11 +303,11 @@ class QueryLanguageService {
             const context = {
                 adaptableApi: this.adaptableApi,
                 module,
-                defaultBooleanFunctionNames: this.getFunctionNames(defaultBooleanExpressionFunctions),
-                defaultScalarFunctionNames: this.getFunctionNames(defaultScalarExpressionFunctions),
-                defaultObservableFunctionNames: this.getFunctionNames(defaultObservableExpressionFunctions),
-                defaultAggregatedBooleanFunctionNames: this.getFunctionNames(defaultAggregatedBooleanFunctions),
-                defaultAggregatedScalarFunctionNames: this.getFunctionNames(defaultAggregatedScalarFunctions),
+                availableBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalBooleanExpressionFunctions),
+                availableScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalScalarExpressionFunctions),
+                availableObservableFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalObservableExpressionFunctions),
+                availableAggregatedBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedBooleanExpressionFunctions),
+                availableAggregatedScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedScalarExpressionFunctions),
             };
             moduleExpressionFunctions = (_a = expressionOptions.moduleExpressionFunctions(context)) !== null && _a !== void 0 ? _a : {};
         }
@@ -315,49 +315,45 @@ class QueryLanguageService {
             moduleExpressionFunctions = (_c = (_b = expressionOptions.moduleExpressionFunctions) === null || _b === void 0 ? void 0 : _b[module]) !== null && _c !== void 0 ? _c : {};
         }
         const moduleExpressionFunctionsMap = {
-            booleanFunctions: this.mapFunctionsDefinitionToMap((_d = moduleExpressionFunctions.booleanFunctions) !== null && _d !== void 0 ? _d : defaultBooleanExpressionFunctions, booleanExpressionFunctions_1.booleanExpressionFunctions),
-            scalarFunctions: this.mapFunctionsDefinitionToMap((_e = moduleExpressionFunctions.scalarFunctions) !== null && _e !== void 0 ? _e : defaultScalarExpressionFunctions, scalarExpressionFunctions_1.scalarExpressionFunctions),
-            observableFunctions: this.mapFunctionsDefinitionToMap((_f = moduleExpressionFunctions.observableFunctions) !== null && _f !== void 0 ? _f : defaultObservableExpressionFunctions, observableExpressionFunctions_1.observableExpressionFunctions),
-            aggregatedBooleanFunctions: this.mapFunctionsDefinitionToMap((_g = moduleExpressionFunctions.aggregatedBooleanFunctions) !== null && _g !== void 0 ? _g : defaultAggregatedBooleanFunctions, aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions),
-            aggregatedScalarFunctions: this.mapFunctionsDefinitionToMap((_h = moduleExpressionFunctions.aggregatedScalarFunctions) !== null && _h !== void 0 ? _h : defaultAggregatedScalarFunctions, aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions),
+            booleanFunctions: this.extractMappedExpressionFunctions(generalBooleanExpressionFunctions, moduleExpressionFunctions.systemBooleanFunctions, moduleExpressionFunctions.customBooleanFunctions),
+            scalarFunctions: this.extractMappedExpressionFunctions(generalScalarExpressionFunctions, moduleExpressionFunctions.systemScalarFunctions, moduleExpressionFunctions.customScalarFunctions),
+            observableFunctions: this.extractMappedExpressionFunctions(generalObservableExpressionFunctions, moduleExpressionFunctions.systemObservableFunctions),
+            aggregatedBooleanFunctions: this.extractMappedExpressionFunctions(generalAggregatedBooleanExpressionFunctions, moduleExpressionFunctions.systemAggregatedBooleanFunctions),
+            aggregatedScalarFunctions: this.extractMappedExpressionFunctions(generalAggregatedScalarExpressionFunctions, moduleExpressionFunctions.systemAggregatedScalarFunctions),
         };
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleExpressionFunctionsMap);
         return moduleExpressionFunctionsMap;
     }
-    getFunctionNames(definitions) {
-        return definitions.flatMap((definition) => {
-            if (typeof definition === 'string') {
-                return definition;
-            }
-            else {
-                return (0, TypeExtensions_1.getTypedKeys)(definition);
-            }
-        });
-    }
-    extractDefaultExpressionFunctions(defaultOptions, availableExpressionFunctions) {
-        if (typeof defaultOptions === 'function') {
-            const context = {
+    extractMappedExpressionFunctions(availableExpressionFunctions, systemFunctions, customFunctions) {
+        const systemFunctionNames = typeof systemFunctions === 'function'
+            ? systemFunctions({
                 adaptableApi: this.adaptableApi,
                 availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(availableExpressionFunctions),
-            };
-            return defaultOptions(context);
+            })
+            : systemFunctions;
+        let generalExpressionFunctions = {};
+        // add system functions
+        if (Array.isArray(systemFunctionNames)) {
+            // add only system functions specified by user
+            systemFunctionNames.forEach((systemFunctionName) => {
+                generalExpressionFunctions[systemFunctionName] =
+                    availableExpressionFunctions[systemFunctionName];
+            });
         }
-        return defaultOptions;
-    }
-    mapFunctionsDefinitionToMap(functionsDefinition, internalExpressionFunctions) {
-        let resultMap = {};
-        functionsDefinition.forEach((definition) => {
-            if (typeof definition === 'string') {
-                const internalFunction = internalExpressionFunctions[definition];
-                if (internalFunction) {
-                    resultMap[definition] = internalFunction;
-                }
-            }
-            else {
-                resultMap = Object.assign(Object.assign({}, resultMap), definition);
-            }
-        });
-        return resultMap;
+        else {
+            // add ALL system functions
+            generalExpressionFunctions = Object.assign({}, availableExpressionFunctions);
+        }
+        const customFunctionDefinitions = typeof customFunctions === 'function'
+            ? customFunctions({
+                adaptableApi: this.adaptableApi,
+                availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalExpressionFunctions),
+            })
+            : customFunctions;
+        if (customFunctionDefinitions) {
+            generalExpressionFunctions = Object.assign(Object.assign({}, generalExpressionFunctions), customFunctionDefinitions);
+        }
+        return generalExpressionFunctions;
     }
     evaluateCustomQueryVariable(functionName, args) {
         var _a, _b, _c;

package/src/View/FormatColumn/Wizard/FormatColumnSettingsWizardSection.js

@@ -6,13 +6,9 @@ const React = tslib_1.__importStar(require("react"));
 const rebass_1 = require("rebass");
 const DropdownButton_1 = tslib_1.__importDefault(require("../../../components/DropdownButton"));
 const FormLayout_1 = tslib_1.__importStar(require("../../../components/FormLayout"));
-const Input_1 = tslib_1.__importDefault(require("../../../components/Input"));
 const CheckBox_1 = require("../../../components/CheckBox");
 const Tabs_1 = require("../../../components/Tabs");
 const OnePageAdaptableWizard_1 = require("../../Wizard/OnePageAdaptableWizard");
-const StringExtensions_1 = tslib_1.__importDefault(require("../../../Utilities/Extensions/StringExtensions"));
-const react_1 = require("react");
-const LoggingHelper_1 = require("../../../Utilities/Helpers/LoggingHelper");
 const Tag_1 = require("../../../components/Tag");
 let alignmentOptions = [
     { value: 'Left', label: 'Left' },
@@ -25,9 +21,6 @@ const renderFormatColumnSettingsSummary = (data) => {
         React.createElement(rebass_1.Text, null,
             "Cell alignment ",
             React.createElement(Tag_1.Tag, null, (_a = data.CellAlignment) !== null && _a !== void 0 ? _a : 'default')),
-        data.HeaderName ? (React.createElement(rebass_1.Text, { mt: 3 },
-            "Header name ",
-            React.createElement(Tag_1.Tag, null, data.HeaderName))) : null,
         React.createElement(rebass_1.Text, { mt: 3 },
             "Include grouped rows ",
             React.createElement(Tag_1.Tag, null, data.IncludeGroupedRows ? 'yes' : 'no'))));
@@ -41,18 +34,6 @@ const FormatColumnSettingsWizardSection = (props) => {
     const onIncludeGroupedRowsChanged = (IncludeGroupedRows) => {
         props.onChange(Object.assign(Object.assign({}, data), { IncludeGroupedRows }));
     };
-    const onHeaderNameChanged = (event) => {
-        let e = event.target;
-        props.onChange(Object.assign(Object.assign({}, data), { HeaderName: e.value }));
-    };
-    const [hasHeaderName, setHasHeaderName] = (0, react_1.useState)(false);
-    (0, react_1.useEffect)(() => {
-        const hasCustomHeaderName = StringExtensions_1.default.IsNotNullOrEmpty(data.HeaderName);
-        setHasHeaderName(hasCustomHeaderName);
-        if (hasCustomHeaderName) {
-            (0, LoggingHelper_1.ConsoleLogWarning)(`DEPRECATED: The 'FormatColumn.HeaderName' property is deprecated; use a Layout custom Column Header instead!`);
-        }
-    }, []);
     return (React.createElement(Tabs_1.Tabs, null,
         React.createElement(Tabs_1.Tabs.Tab, null, "Format"),
         React.createElement(Tabs_1.Tabs.Content, null,
@@ -70,9 +51,6 @@ const FormatColumnSettingsWizardSection = (props) => {
                                 label: item.label,
                                 onClick: () => onCellAlignmentSelectChanged(item.value),
                             })), columns: ['label'] }, data.CellAlignment ? data.CellAlignment : 'Select Option')),
-                    hasHeaderName && api.scopeApi.isSingleColumnScope(data.Scope) && (React.createElement(FormLayout_1.FormRow, { label: "Header Name" },
-                        React.createElement(Input_1.default, { value: data.HeaderName, onChange: (e) => onHeaderNameChanged(e), style: { minWidth: '15rem' } }),
-                        ' ')),
                     React.createElement(FormLayout_1.FormRow, { label: "Include Grouped Rows:" },
                         React.createElement(rebass_1.Flex, { alignItems: "center", marginLeft: 2 },
                             React.createElement(CheckBox_1.CheckBox, { checked: data.IncludeGroupedRows, onChange: onIncludeGroupedRowsChanged, mr: 2 }))))))));

package/src/View/FormatColumn/Wizard/FormatColumnStyleWizardSection.js

@@ -22,7 +22,6 @@ const isFormatColumnStyleValid = (data, api) => {
         data.Style &&
         UIHelper_1.default.IsEmptyStyle(data.Style) &&
         data.DisplayFormat === undefined &&
-        data.HeaderName === undefined &&
         data.CellAlignment === undefined &&
         !api.scopeApi.isSingleBooleanColumnScope(data.Scope)) {
         return 'No format applied';

package/src/agGrid/Adaptable.d.ts

@@ -1,4 +1,4 @@
-import { ChartModel, ChartRef, ColDef, ColGroupDef, Column, ExcelStyle, GridOptions, Module, RowNode } from '@ag-grid-community/core';
+import { ChartModel, ChartRef, ColDef, ColGroupDef, Column, ExcelStyle, GridOptions, Module, ModuleNames, RowNode } from '@ag-grid-community/core';
 import { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard } from '../AdaptableInterfaces/AdaptableNoCodeWizard';
 import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
 import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
@@ -293,7 +293,7 @@ export declare class Adaptable implements IAdaptable {
     setupColumnComparator({ col, colId, abColumn }: ColumnSetupInfo): void;
     private applyCurrentTheme;
     private applyFinalRendering;
-    private isAgGridModulePresent;
+    isAgGridModulePresent(moduleName: ModuleNames): boolean;
     private getAgGridRegisteredModules;
     private onRowDataChanged;
     private onCellDataChanged;

package/src/agGrid/Adaptable.js

@@ -466,19 +466,13 @@ class Adaptable {
                 AdaptableHelper_1.default.checkValidPrimaryKey(this);
             }, (e) => {
                 (0, LoggingHelper_1.ConsoleLogError)('Failed to Init Modules : ', e);
-                // for now we initiliaze the grid even if initialising Modules has failed (perhaps revisit this?)
+                // for now we initialize the grid even if initialising Modules has failed (perhaps revisit this?)
                 this.initInternalGridLogic();
                 this.api.internalApi.hideLoadingScreen(); // doesnt really help but at least clears the screen
             }).then(async () => {
                 this.api.internalApi.hideLoadingScreen();
                 this.isInitialised = true;
                 this._adaptableReady = true;
-                // setTimeout(() => {
-                // this.api.eventApi.emit('AdaptableReady', {
-                //   adaptableApi: this.api,
-                //   gridOptions: this.adaptableOptions.gridOptions,
-                // });
-                // }, 0);
             });
             if (this.abContainerElement == null) {
                 this.abContainerElement = this.getAdaptableContainerElement();
@@ -3406,13 +3400,6 @@ class Adaptable {
             if (layoutCustomHeader) {
                 resultHeaderName = layoutCustomHeader;
             }
-            // check if the deprecated formatColumn header is used
-            const formatColumn = this.api.formatColumnApi.getFormatColumnForColumnId(abColumn.columnId);
-            if (!layoutCustomHeader && (formatColumn === null || formatColumn === void 0 ? void 0 : formatColumn.HeaderName) && !formatColumn.IsSuspended) {
-                // fallback to the formatColumn property if no Layout custom header is provided
-                resultHeaderName = formatColumn.HeaderName;
-                (0, LoggingHelper_1.ConsoleLogWarning)(`DEPRECATED: 'FormatColumn.HeaderName' is deprecated: use 'Layout.ColumnHeadersMap' instead`);
-            }
             // required here for the initial layout rendering
             abColumn.friendlyName = resultHeaderName;
             return resultHeaderName;