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

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.3",
   "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: 1663245222592;
 export default _default;

package/publishTimestamp.js

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

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

package/src/PredefinedConfig/Common/AdaptablePredicate.d.ts

@@ -103,7 +103,7 @@ export interface PredicateDefHandlerParams {
 export interface PredicateDefToStringParams {
     inputs: any[];
 }
-export declare type ModuleScope = 'filter' | 'alert' | 'conditionalstyle' | 'flashingcell';
+export declare type ModuleScope = 'filter' | 'alert' | 'conditionalstyle' | 'flashingcell' | 'formatColumn';
 /**
  * Array of Predicate Defs which are shipped by AdapTable
  */