@adaptabletools/adaptable 13.0.0-canary.2 → 13.0.0-canary.4

package/index.css

@@ -3733,6 +3733,7 @@ input[type='number'].ab-Input:hover::-webkit-inner-spin-button:active {
       display: table-cell; }
 
 .ab-ToggleButton {
+  user-select: none;
   position: relative;
   display: inline-block;
   min-width: 40px;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "13.0.0-canary.2",
+  "version": "13.0.0-canary.4",
   "description": "Powerful data-agnostic HTML5 datagrid add-on that sits on top of an underlying grid component and provides all the rich functionality that advanced users expect from their DataGrids and Data Tables",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1663166834956;
+declare const _default: 1663256074117;
 export default _default;

package/publishTimestamp.js

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

package/src/AdaptableOptions/AdaptableQLOptions.d.ts

@@ -1,8 +1,13 @@
-import { ExpressionFunctionMap } from '../parser/src/types';
+import { ExpressionFunction } from '../parser/src/types';
 import { AdaptablePredicateDef } from '../PredefinedConfig/Common/AdaptablePredicate';
 import { AdaptableModule, AdaptableQLModule, AdaptableQLModules } from '../PredefinedConfig/Common/Types';
 import { BaseContext } from '../PredefinedConfig/Common/BaseContext';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
+import { BooleanFunctionName } from '../Utilities/ExpressionFunctions/booleanExpressionFunctions';
+import { ScalarFunctionName } from '../Utilities/ExpressionFunctions/scalarExpressionFunctions';
+import { ObservableFunctionName } from '../Utilities/ExpressionFunctions/observableExpressionFunctions';
+import { AggregatedBooleanFunctionName } from '../Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions';
+import { AggregatedScalarFunctionName } from '../Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions';
 /**
  * Options for managing AdaptableQL - the Adaptable Query Language which evaluates Predicates and Expressions
  */
@@ -52,44 +57,42 @@ export interface ExpressionOptions {
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultBooleanFunctions?: ExpressionFunctionMap;
+    defaultBooleanFunctions?: ExpressionFunctionDefinitions<BooleanFunctionName> | ((context: DefaultExpressionFunctionsContext<BooleanFunctionName>) => ExpressionFunctionDefinitions<BooleanFunctionName>);
     /**
      * Scalar Expression Functions available in AdaptableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultScalarFunctions?: ExpressionFunctionMap;
+    defaultScalarFunctions?: ExpressionFunctionDefinitions<ScalarFunctionName> | ((context: DefaultExpressionFunctionsContext<ScalarFunctionName>) => ExpressionFunctionDefinitions<ScalarFunctionName>);
     /**
      * Observable Expression Functions available in AdaptableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultObservableFunctions?: ExpressionFunctionMap;
+    defaultObservableFunctions?: ExpressionFunctionDefinitions<ObservableFunctionName> | ((context: DefaultExpressionFunctionsContext<ObservableFunctionName>) => ExpressionFunctionDefinitions<ObservableFunctionName>);
     /**
      * Aggregated Boolean Expression Functions available in AdaptableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultAggregatedBooleanFunctions?: ExpressionFunctionMap;
+    defaultAggregatedBooleanFunctions?: ExpressionFunctionDefinitions<AggregatedBooleanFunctionName> | ((context: DefaultExpressionFunctionsContext<AggregatedBooleanFunctionName>) => ExpressionFunctionDefinitions<AggregatedBooleanFunctionName>);
     /**
      * Aggregated Scalar Expression Functions available in AdaptableQL
      *
      * @defaultValue null (sets all)
      * @gridInfoItem
      */
-    defaultAggregatedScalarFunctions?: ExpressionFunctionMap;
+    defaultAggregatedScalarFunctions?: ExpressionFunctionDefinitions<AggregatedScalarFunctionName> | ((context: DefaultExpressionFunctionsContext<AggregatedScalarFunctionName>) => ExpressionFunctionDefinitions<AggregatedScalarFunctionName>);
     /**
      * Module specific ExpressionFunctions; if not defined, it falls back to the defined default values
      *
      * @defaultValue undefined (defaults to default values)
      * @gridInfoItem
      */
-    moduleExpressionFunctions?: {
-        [module in AdaptableModule]?: ModuleExpressionFunctions;
-    };
+    moduleExpressionFunctions?: ModuleExpressionFunctionsMap | ((context: ModuleExpressionFunctionsContext) => ModuleExpressionFunctions | undefined);
     /**
      * Columns that can be included in AdaptableQL Expressions; leave unset to include **ALL**, provide empty array to set **NONE**
      *
@@ -116,15 +119,40 @@ export interface ExpressionOptions {
      */
     customQueryVariables?: Record<string, string | number | boolean | Date | ((context: CustomQueryVariableContext) => string | number | boolean | Date)>;
 }
+/**
+ * ExpressionFunctions which may be either referenced by name (for internal Adaptable functions) or provided with custom implementation
+ */
+export declare type ExpressionFunctionDefinitions<T> = (T | Record<string, ExpressionFunction>)[];
 /**
  * Module specific Expression Functions
  */
+export declare type ModuleExpressionFunctionsMap = Partial<Record<AdaptableModule, ModuleExpressionFunctions>>;
+/**
+ * Type specific Expression Functions
+ */
 export interface ModuleExpressionFunctions {
-    booleanFunctions?: ExpressionFunctionMap;
-    scalarFunctions?: ExpressionFunctionMap;
-    observableFunctions?: ExpressionFunctionMap;
-    aggregatedBooleanFunctions?: ExpressionFunctionMap;
-    aggregatedScalarFunctions?: ExpressionFunctionMap;
+    booleanFunctions?: ExpressionFunctionDefinitions<BooleanFunctionName>;
+    scalarFunctions?: ExpressionFunctionDefinitions<ScalarFunctionName>;
+    observableFunctions?: ExpressionFunctionDefinitions<ObservableFunctionName>;
+    aggregatedBooleanFunctions?: ExpressionFunctionDefinitions<AggregatedBooleanFunctionName>;
+    aggregatedScalarFunctions?: ExpressionFunctionDefinitions<AggregatedScalarFunctionName>;
+}
+/**
+ * Context provided to ExpressionOptions.defaultExpressionFunctions property callback
+ */
+export interface DefaultExpressionFunctionsContext<T> extends BaseContext {
+    availableExpressionFunctionNames: T[];
+}
+/**
+ * Context provided to ExpressionOptions.moduleExpressionFunctions property callback
+ */
+export interface ModuleExpressionFunctionsContext extends BaseContext {
+    module: AdaptableModule;
+    defaultBooleanFunctionNames: BooleanFunctionName[];
+    defaultScalarFunctionNames: ScalarFunctionName[];
+    defaultObservableFunctionNames: ObservableFunctionName[];
+    defaultAggregatedBooleanFunctionNames: AggregatedBooleanFunctionName[];
+    defaultAggregatedScalarFunctionNames: AggregatedScalarFunctionName[];
 }
 /**
  * Context passed when evaluating `ExpressionOptions.customQueryVariables`

package/src/AdaptableOptions/GeneralOptions.d.ts

@@ -65,6 +65,12 @@ export interface GeneralOptions {
      * Value to use for 'Unbalanced Groups' (string columns)
      */
     unbalancedGroupsKey?: string | ((context: UnbalancedGroupsKeyContext) => string);
+    /**
+     * Starting with v13, ConditionalStyle module is deprecated, and it's functionality is merged into the FormatColumn module. By default, all existing conditional styles are migrated to format columns. By setting this property to TRUE, the conditional styles are not migrated.
+     *
+     * @defaultValue false
+     */
+    keepDeprecatedConditionalStyles?: boolean;
 }
 /**
  * Comparer object for Column Values - used for custom sorting

package/src/Api/ConditionalStyleApi.d.ts

@@ -7,100 +7,120 @@ import { AdaptablePredicateDef } from '../PredefinedConfig/Common/AdaptablePredi
 export interface ConditionalStyleApi {
     /**
      * Retrieves Conditional Style section from Adaptable State
+     * @deprecated use `FormatColumn` instead
      */
     getConditionalStyleState(): ConditionalStyleState;
     /**
      * Gets all Conditional Styles in Adaptable State
+     * @deprecated use `FormatColumn` instead
      */
     getAllConditionalStyle(config?: {
         includeLayoutNotAssociatedObjects?: boolean;
     }): ConditionalStyle[];
     /**
      * Get conditional style by id
+     *
+     * @deprecated use `FormatColumn` instead
      * @param id conditional style id
      * @returns conditional style
      */
     getConditionalStyleById(id: ConditionalStyle['Uuid']): ConditionalStyle;
     /**
      * Gets all Conditional Styles that are active (not-suspended) in Adaptable State
+     * @deprecated use `FormatColumn` instead
      * @returns conditional styles
      */
     getAllActiveConditionalStyle(): ConditionalStyle[];
     /**
      * Gets all Conditional Styles that are suspended in Adaptable State
+     * @deprecated use `FormatColumn` instead
      * @returns conditional styles
      */
     getAllSuspendedConditionalStyle(): ConditionalStyle[];
     /**
      * Opens Settings Panel with Conditional Style section selected and visible
+     * @deprecated use `FormatColumn` instead
      */
     showConditionalStylePopup(): void;
     /**
      * Retrieves all Conditional Styles that style whole row
+     * @deprecated use `FormatColumn` instead
      * @returns conditional styles
      */
     getRowConditionalStyles(): ConditionalStyle[] | undefined;
     /**
      * Retrieves all Conditional Styles which have an Expression
+     * @deprecated use `FormatColumn` instead
      * @returns conditional styles
      */
     getConditionalStylesWithExpression(): ConditionalStyle[] | undefined;
     /**
      * Gets all Conditional Styles that style a given Column
+     * @deprecated use `FormatColumn` instead
      * @param column Column to check
      * @returns conditional styles
      */
     getConditionalStylesForColumn(column: AdaptableColumn): ConditionalStyle[] | undefined;
     /**
      * Returns all Predicates usable in Conditional Styles
+     * @deprecated use `FormatColumn` instead
      */
     getConditionalStylePredicateDefs(): AdaptablePredicateDef[];
     /**
      * Returns all Predicates appropriate for the given Scope
+     * @deprecated use `FormatColumn` instead
      * @param scope Scope to check
      */
     getCondStylePredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
     /**
      * Retrieves all Conditional Styles ordered by Column then Row
+     * @deprecated use `FormatColumn` instead
      * @returns conditional style
      */
     getOrderedConditionalStyles(): ConditionalStyle[] | undefined;
     /**
      * Replaces Conditional Style in State with given one
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyle Conditional Style to edit
      * @returns conditional style
      */
     editConditionalStyle(conditionalStyle: ConditionalStyle): ConditionalStyle;
     /**
      * Replaces Conditional Styles in State with given ones
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyles Conditional Styles to edit
      * @returns conditional styles
      */
     editConditionalStyles(conditionalStyles: ConditionalStyle[]): ConditionalStyle[];
     /**
      * Deletes a Conditional Style
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyle Conditional Style to delete
      */
     deleteConditionalStyle(conditionalStyle: ConditionalStyle): void;
     /**
      * Deletes Conditional Styles
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyles Conditional Styles to delete
      */
     deleteConditionalStyles(conditionalStyles: ConditionalStyle[]): void;
     /**
      * Adds new Conditional Style to State
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyle Conditional Style to add
      * @returns conditional style
      */
     addConditionalStyle(conditionalStyle: ConditionalStyle): ConditionalStyle;
     /**
      * Suspends conditional style, a readonly object cannot be suspended
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyle Conditional Style to suspend
      * @returns conditional style
      */
     suspendConditionalStyle(conditionalStyle: ConditionalStyle): ConditionalStyle;
     /**
      * Un-suspends or activates a suspended conditional style
+     * @deprecated use `FormatColumn` instead
      * @param conditionalStyle Conditional Style to suspend
      * @returns conditional style
      */

package/src/Api/FormatColumnApi.d.ts

@@ -1,5 +1,5 @@
 import { FormatColumnState, FormatColumn, ColumnStyle, ColumnComparison, CellColorRange } from '../PredefinedConfig/FormatColumnState';
-import { AdaptableColumn, AdaptableFormat } from '../types';
+import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, AdaptableScope } from '../types';
 import { RowNode } from '@ag-grid-community/core';
 /**
  * Provides run-time access to the Format Column Module and associated state
@@ -134,12 +134,22 @@ export interface FormatColumnApi {
      * @returns format column
      */
     getFormatColumnWithStyleForColumn(column: AdaptableColumn): FormatColumn | undefined;
+    /**
+     * Retrieves all format columns with style for a column
+     * @param column The Column for which to retrieve the Format Column
+     */
+    getColumnFormatColumnsWithStyle(column: AdaptableColumn): FormatColumn[];
+    /**
+     * Retrieves all Format Columns with style for the whole row
+     * @returns format columns
+     */
+    getRowFormatColumnsWithStyle(): FormatColumn[];
     /**
      * Gets Format Column if any for given Column which includes Style element with ClassName
      * @param column The Column for which to retrieve the Format Column
-     * @returns format column
+     * @returns format columns
      */
-    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn): FormatColumn | undefined;
+    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn): FormatColumn[];
     /**
      * Will get the most appropriate one i.e. first named Column, then DataType, then All
      * @param column
@@ -206,4 +216,33 @@ export interface FormatColumnApi {
      * @param formatColumn Format Column
      */
     hasCustomDisplayFormatter(formatColumn: FormatColumn): boolean;
+    /**
+     * Returns all Predicates usable in Format Columns
+     */
+    getFormatColumnPredicateDefs(): AdaptablePredicateDef[];
+    /**
+     * Returns all Predicates appropriate for the given Scope
+     * @param scope Scope to check
+     */
+    getFormatColumnDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    /**
+     * Checks if format column is active for a given row
+     *
+     * @param formatColumn
+     * @param params
+     */
+    isFormatColumnActiveForRow(formatColumn: FormatColumn, params: {
+        node: RowNode;
+    }): boolean;
+    /**
+     * Checks if format column is active for a given cell
+     *
+     * @param formatColumn
+     * @param column
+     * @param params
+     */
+    isFormatColumnActiveForColumn(formatColumn: FormatColumn, column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): boolean;
 }

package/src/Api/Implementation/ColumnApiImpl.js

@@ -89,13 +89,13 @@ class ColumnApiImpl extends ApiBase_1.ApiBase {
         return false;
     }
     isNumericColumn(column) {
-        return column.dataType == 'Number';
+        return (column === null || column === void 0 ? void 0 : column.dataType) == 'Number';
     }
     isBooleanColumn(column) {
-        return column.dataType == 'Boolean';
+        return (column === null || column === void 0 ? void 0 : column.dataType) == 'Boolean';
     }
     isDateColumn(column) {
-        return column.dataType == 'Date';
+        return (column === null || column === void 0 ? void 0 : column.dataType) == 'Date';
     }
     getColumnDataTypeFromColumnId(columnId) {
         const column = this.getColumnFromId(columnId); // this.getColumns().find(c => c.ColumnId == columnId);

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

@@ -5,6 +5,7 @@ import { FormatColumnState, FormatColumn, ColumnStyle, CellColorRange, ColumnCom
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { RowNode } from '@ag-grid-community/core';
 import { AdaptableFormat } from '../../types';
+import { AdaptablePredicateDef, AdaptableScope } from '../../../types';
 export declare class FormatColumnApiImpl extends ApiBase implements FormatColumnApi {
     getFormatColumnState(): FormatColumnState;
     getAllFormatColumn(config?: LayoutAssociatedObjectLoadConfig): FormatColumn[];
@@ -27,12 +28,15 @@ export declare class FormatColumnApiImpl extends ApiBase implements FormatColumn
     unSuspendFormatColumn(formatColumn: FormatColumn): FormatColumn;
     applyFormatColumnDisplayFormats(): void;
     getActiveFormatColumnForColumn(column: AdaptableColumn): FormatColumn | undefined;
+    getColumnFormatColumnsWithStyle(column: AdaptableColumn): FormatColumn[];
+    getRowFormatColumnsWithStyle(): FormatColumn[];
     getFormatColumnForColumn(column: AdaptableColumn): FormatColumn | undefined;
     getFormatColumnForColumnId(columnId: string): FormatColumn | undefined;
     getFormatColumnWithStyleForColumn(column: AdaptableColumn): FormatColumn | undefined;
-    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn): FormatColumn | undefined;
+    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn): FormatColumn[];
     getFormatColumnWithDisplayFormatForColumn(column: AdaptableColumn): FormatColumn | undefined;
     getFormatColumnWithSingleColumnScope(columnId: string): FormatColumn | undefined;
+    private getFormatColumnInColumnScope;
     private getAppropriateFormatColumn;
     hasStyleFormatColumns(): boolean;
     showFormatColumnPopup(): void;
@@ -51,4 +55,16 @@ export declare class FormatColumnApiImpl extends ApiBase implements FormatColumn
     getStringFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): string;
     getDateFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): string;
     hasCustomDisplayFormatter(formatColumn: FormatColumn): boolean;
+    getFormatColumnPredicateDefs(): AdaptablePredicateDef[];
+    getFormatColumnDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    isFormatColumnActiveForRow(formatColumn: FormatColumn, params: {
+        node: RowNode;
+    }): boolean;
+    isFormatColumnActiveForColumn(formatColumn: FormatColumn, column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): boolean;
+    private evaluatePredicate;
+    private shouldRunStyle;
+    private evaluateExpression;
 }

package/src/Api/Implementation/FormatColumnApiImpl.js

@@ -110,6 +110,18 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         const formatColumns = this.getAllActiveFormatColumn();
         return this.getAppropriateFormatColumn(formatColumns, column);
     }
+    getColumnFormatColumnsWithStyle(column) {
+        const formatColumns = this.getAllFormatColumnWithStyle();
+        return this.getFormatColumnInColumnScope(formatColumns, column).filter((scopedFormatColumn) => {
+            return (!this.adaptable.api.scopeApi.scopeIsAll(scopedFormatColumn.Scope) &&
+                this.adaptable.api.scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
+        });
+    }
+    getRowFormatColumnsWithStyle() {
+        return this.getAllFormatColumnWithStyle().filter((formatColumn) => {
+            return this.adaptable.api.scopeApi.scopeIsAll(formatColumn.Scope);
+        });
+    }
     getFormatColumnForColumn(column) {
         const formatColumns = this.getAllFormatColumn();
         return this.getAppropriateFormatColumn(formatColumns, column);
@@ -126,8 +138,7 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         return this.getAppropriateFormatColumn(formatColumns, column);
     }
     getFormatColumnWithStyleClassNameForColumn(column) {
-        const formatColumns = this.getAllFormatColumnWithStyle().filter((fc) => StringExtensions_1.default.IsNotNullOrEmpty(fc.Style.ClassName));
-        return this.getAppropriateFormatColumn(formatColumns, column);
+        return this.getColumnFormatColumnsWithStyle(column).filter((fc) => StringExtensions_1.default.IsNotNullOrEmpty(fc.Style.ClassName));
     }
     getFormatColumnWithDisplayFormatForColumn(column) {
         const formatColumns = this.getAllFormatColumnWithDisplayFormat().concat(this.getAllFormatColumnWithCellAlignment());
@@ -150,20 +161,14 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         });
         return returnFormatColumn;
     }
-    getAppropriateFormatColumn(formatColumns, column) {
-        let scopedFormatColumns = this.getFormatColumnsWithColumnScope(formatColumns)
+    getFormatColumnInColumnScope(formatColumns, column) {
+        return this.getFormatColumnsWithColumnScope(formatColumns)
             .concat(this.getFormatColumnsWithDataTypeScope(formatColumns))
             .concat(this.getFormatColumnsWithAllScope(formatColumns));
-        let returnFormatColumn = undefined;
-        scopedFormatColumns.forEach((fc) => {
-            // we just do one and then return
-            if (returnFormatColumn == undefined) {
-                if (this.adaptable.api.scopeApi.isColumnInScope(column, fc.Scope)) {
-                    returnFormatColumn = fc;
-                }
-            }
-        });
-        return returnFormatColumn;
+    }
+    getAppropriateFormatColumn(formatColumns, column) {
+        return this.getFormatColumnInColumnScope(formatColumns, column).find((scopedFormatColumn) => !this.adaptable.api.scopeApi.scopeIsAll(scopedFormatColumn.Scope) &&
+            this.adaptable.api.scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
     }
     hasStyleFormatColumns() {
         return ArrayExtensions_1.default.IsNotNullOrEmpty(this.getAllFormatColumnWithStyle());
@@ -355,5 +360,80 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         }
         return true;
     }
+    getFormatColumnPredicateDefs() {
+        return this.adaptable.api.predicateApi.getPredicateDefsByModuleScope('formatColumn');
+    }
+    getFormatColumnDefsForScope(scope) {
+        return this.getFormatColumnPredicateDefs().filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    }
+    isFormatColumnActiveForRow(formatColumn, params) {
+        // suspedned is important to be first
+        if (formatColumn.IsSuspended) {
+            return false;
+        }
+        if (!formatColumn.Rule) {
+            return true;
+        }
+        if (this.shouldRunStyle(formatColumn, params.node) &&
+            formatColumn.Rule.BooleanExpression &&
+            this.evaluateExpression(formatColumn, params.node)) {
+            return true;
+        }
+        // nothing has passed then return false
+        return false;
+    }
+    isFormatColumnActiveForColumn(formatColumn, column, params) {
+        // suspedned is important to be first
+        if (formatColumn.IsSuspended) {
+            return false;
+        }
+        if (!formatColumn.Rule) {
+            return true;
+        }
+        if (this.shouldRunStyle(formatColumn, params.node)) {
+            // first run the predicate
+            if (formatColumn.Rule.Predicate && formatColumn.Rule.Predicate.PredicateId) {
+                if (this.evaluatePredicate({
+                    formatColumn,
+                    column,
+                    value: params.value,
+                    node: params.node,
+                })) {
+                    return true;
+                }
+            }
+            else if (formatColumn.Rule.BooleanExpression) {
+                if (this.evaluateExpression(formatColumn, params.node)) {
+                    return true;
+                }
+            }
+            // nothing has passed then return false
+            return false;
+        }
+    }
+    evaluatePredicate({ formatColumn, column, value, node, }) {
+        const params = {
+            value: value,
+            oldValue: null,
+            displayValue: value,
+            node: node,
+            column: column,
+        };
+        const result = this.adaptable.api.predicateApi.handlePredicate(formatColumn.Rule.Predicate, params, false);
+        return result;
+    }
+    shouldRunStyle(formatColumn, node) {
+        if (!formatColumn.IncludeGroupedRows && this.adaptable.api.gridApi.isGroupRowNode(node)) {
+            return false;
+        }
+        return true;
+    }
+    evaluateExpression(formatColumn, node) {
+        const isValidExpression = this.adaptable.api.queryLanguageApi.isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
+        return (isValidExpression &&
+            this.adaptable.api.internalApi
+                .getQueryLanguageService()
+                .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node));
+    }
 }
 exports.FormatColumnApiImpl = FormatColumnApiImpl;

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

@@ -142,4 +142,5 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     getValueForTag(adaptableObjectTag: AdaptableObjectTag): string | number;
     getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
     getAdaptableQueryExpressionText(query: Partial<AdaptableQuery>): string;
+    shouldKeepDeprecatedConditionalStyles(): boolean;
 }

package/src/Api/Implementation/InternalApiImpl.js

@@ -650,5 +650,9 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
             ? this.adaptable.api.queryLanguageApi.getAdaptableQueryExpressionWithColumnFriendlyNames(query)
             : this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(query);
     }
+    shouldKeepDeprecatedConditionalStyles() {
+        var _a, _b;
+        return (_b = (_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.generalOptions) === null || _b === void 0 ? void 0 : _b.keepDeprecatedConditionalStyles;
+    }
 }
 exports.InternalApiImpl = InternalApiImpl;

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

@@ -1,7 +1,6 @@
 import { ApiBase } from './ApiBase';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { QueryLanguageApi } from '../QueryLanguageApi';
-import { ExpressionFunctionMap } from '../../types';
 import { AdaptableQuery } from '../../PredefinedConfig/Common/AdaptableQuery';
 export declare class QueryLanguageApiImpl extends ApiBase implements QueryLanguageApi {
     isValidBooleanExpression(query: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
@@ -11,7 +10,6 @@ export declare class QueryLanguageApiImpl extends ApiBase implements QueryLangua
     getASTForExpression(query: string): any;
     getColumnsFromExpression(expression: string): string[];
     getQueryableColumnIds(): string[] | undefined;
-    getModuleExpressionFunctionMap(): ExpressionFunctionMap;
     getAdaptableQueryExpression(query: Partial<AdaptableQuery>): string | undefined;
     getAdaptableQueryExpressionWithColumnFriendlyNames(query: Partial<AdaptableQuery>): string | undefined;
 }

package/src/Api/Implementation/QueryLanguageApiImpl.js

@@ -83,9 +83,6 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
             }
         }
     }
-    getModuleExpressionFunctionMap() {
-        return this.getExpressionOptions().moduleExpressionFunctions;
-    }
     getAdaptableQueryExpression(query) {
         var _a, _b, _c, _d;
         return ((_d = (_c = (_b = (_a = query.BooleanExpression) !== null && _a !== void 0 ? _a : query.ScalarExpression) !== null && _b !== void 0 ? _b : query.ObservableExpression) !== null && _c !== void 0 ? _c : query.AggregatedBooleanExpression) !== null && _d !== void 0 ? _d : query.AggregatedScalarExpression);

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

@@ -3,7 +3,7 @@ import { ToolPanelApi } from '../ToolPanelApi';
 import { ToolPanelState, ToolPanelVisibilityMode } from '../../PredefinedConfig/ToolPanelState';
 import { CustomToolPanel, ToolPanelButtonContext } from '../../AdaptableOptions/ToolPanelOptions';
 import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
-import { AdaptableToolPanel } from '../../PredefinedConfig/Common/Types';
+import { AdaptableModuleButtons, AdaptableToolPanel } from '../../PredefinedConfig/Common/Types';
 export declare class ToolPanelApiImpl extends ApiBase implements ToolPanelApi {
     getToolPanelState(): ToolPanelState;
     showToolPanelPopup(): void;
@@ -14,6 +14,8 @@ export declare class ToolPanelApiImpl extends ApiBase implements ToolPanelApi {
     getCustomToolPanelByName(name: string): CustomToolPanel | undefined;
     setAdaptableToolPanelVisibilityMode(adaptableToolPanel: AdaptableToolPanel, visibilityMode: ToolPanelVisibilityMode): void;
     setCustomToolPanelVisibilityMode(customToolPanelName: string, visibilityMode: ToolPanelVisibilityMode): void;
+    setModuleButtons(moduleButtons: AdaptableModuleButtons): void;
+    getModuleButtons(): AdaptableModuleButtons;
     private setExpandedToolPanelVisibility;
     private setCollapsedToolPanelVisibility;
 }

package/src/Api/Implementation/ToolPanelApiImpl.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const ApiBase_1 = require("./ApiBase");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const ToolPanelRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ToolPanelRedux"));
+const ToolPanelRedux_1 = require("../../Redux/ActionsReducers/ToolPanelRedux");
 class ToolPanelApiImpl extends ApiBase_1.ApiBase {
     getToolPanelState() {
         return this.getAdaptableState().ToolPanel;
@@ -51,6 +52,13 @@ class ToolPanelApiImpl extends ApiBase_1.ApiBase {
             this.setCollapsedToolPanelVisibility(customToolPanelName);
         }
     }
+    setModuleButtons(moduleButtons) {
+        this.dispatchAction((0, ToolPanelRedux_1.ToolPanelSetModuleButtons)(moduleButtons));
+    }
+    getModuleButtons() {
+        var _a, _b;
+        return (_b = (_a = this.getToolPanelState()) === null || _a === void 0 ? void 0 : _a.ModuleButtons) !== null && _b !== void 0 ? _b : [];
+    }
     setExpandedToolPanelVisibility(toolPanelName) {
         this.dispatchAction(ToolPanelRedux.ToolPanelExpandToolPanel(toolPanelName));
     }

package/src/Api/InternalApi.d.ts

@@ -144,4 +144,5 @@ export interface InternalApi {
     getValueForTag(adaptableObjectTag: AdaptableObjectTag): string | number;
     getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
     getAdaptableQueryExpressionText(query: Partial<AdaptableQuery>): string;
+    shouldKeepDeprecatedConditionalStyles(): boolean;
 }

package/src/Api/QueryLanguageApi.d.ts

@@ -1,5 +1,4 @@
 import { AdaptableModule } from '../PredefinedConfig/Common/Types';
-import { ExpressionFunctionMap } from '../types';
 import { AdaptableQuery } from '../PredefinedConfig/Common/AdaptableQuery';
 /**
  * Functions related to AdapTableQL (the Adaptable Query Language)
@@ -42,10 +41,6 @@ export interface QueryLanguageApi {
      * Returns all columns that can be used in an Expression
      */
     getQueryableColumnIds(): string[];
-    /**
-     * Returns the current Module Expression Map
-     */
-    getModuleExpressionFunctionMap(): ExpressionFunctionMap;
     /**
      * Runs the AST that AdapTableQL creates for an Expression - useful when evaluating remotely
      * @param expression expression to be run