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

package/src/Api/Implementation/FormatColumnApiImpl.js

@@ -7,7 +7,6 @@ const ApiBase_1 = require("./ApiBase");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
 const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
-const Helper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/Helper"));
 const FormatHelper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/FormatHelper"));
 const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
 class FormatColumnApiImpl extends ApiBase_1.ApiBase {
@@ -28,41 +27,16 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         return this.getAllFormatColumn().filter((formatColumn) => formatColumn.IsSuspended);
     }
     getAllFormatColumnWithStyle() {
-        return this.getAllFormatColumn().filter((fc) => fc.Style != null);
+        return this.getAllFormatColumn().filter((fc) => fc.Style);
     }
-    getColumnComparisonForFormatColumn(formatColumn) {
-        var _a, _b;
-        if (formatColumn.ColumnStyle) {
-            if ((_a = formatColumn.ColumnStyle.GradientStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison) {
-                return formatColumn.ColumnStyle.GradientStyle.ColumnComparison;
-            }
-            if ((_b = formatColumn.ColumnStyle.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.ColumnComparison) {
-                return formatColumn.ColumnStyle.PercentBarStyle.ColumnComparison;
-            }
-        }
-        return undefined;
-    }
-    getColumnIdsFromColumnComparison(columnComparison) {
-        let returnValues = [];
-        if (typeof columnComparison.MinValue === 'string') {
-            let minIds = this.adaptable.api.columnApi.getColumnIdsFromId(columnComparison.MinValue, false);
-            if (ArrayExtensions_1.default.IsNotNullOrEmpty(minIds)) {
-                returnValues.push(...minIds);
-            }
-        }
-        if (typeof columnComparison.MaxValue === 'string') {
-            let maxIds = this.adaptable.api.columnApi.getColumnIdsFromId(columnComparison.MaxValue, false);
-            if (ArrayExtensions_1.default.IsNotNullOrEmpty(maxIds)) {
-                returnValues.push(...maxIds);
-            }
-        }
-        return returnValues;
+    getAllFormatColumnWithStyleAndCellAlignment() {
+        return this.getAllFormatColumn().filter((fc) => fc.Style || fc.CellAlignment);
     }
     getAllFormatColumnWithDisplayFormat() {
-        return this.getAllFormatColumn().filter((fc) => fc.DisplayFormat != null);
+        return this.getAllFormatColumn().filter((fc) => fc.DisplayFormat);
     }
     getAllFormatColumnWithCellAlignment() {
-        return this.getAllFormatColumn().filter((fc) => fc.CellAlignment != null);
+        return this.getAllFormatColumn().filter((fc) => fc.CellAlignment);
     }
     addFormatColumn(formatColumn) {
         this.addUidToAdaptableObject(formatColumn);
@@ -106,32 +80,27 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
     applyFormatColumnDisplayFormats() {
         throw 'This API method is deprecated - it is not needed anymore.';
     }
-    getActiveFormatColumnForColumn(column) {
-        const formatColumns = this.getAllActiveFormatColumn();
-        return this.getAppropriateFormatColumn(formatColumns, column);
+    getFormatColumnsForColumn(column, config) {
+        const formatColumns = this.getAllFormatColumn().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.getFormatColumnWithColumnInScope(formatColumns, column);
     }
-    getFormatColumnForColumn(column) {
-        const formatColumns = this.getAllFormatColumn();
-        return this.getAppropriateFormatColumn(formatColumns, column);
+    getFormatColumnsWithStyleForColumn(column, config) {
+        const formatColumns = this.getAllFormatColumnWithStyleAndCellAlignment().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.getFormatColumnWithColumnInScope(formatColumns, column);
     }
-    getFormatColumnForColumnId(columnId) {
+    getFormatColumnsForColumnId(columnId, config) {
         const abColumn = this.adaptable.api.columnApi.getColumnFromId(columnId);
         if (!abColumn) {
             return undefined;
         }
-        return this.getFormatColumnForColumn(abColumn);
-    }
-    getFormatColumnWithStyleForColumn(column) {
-        const formatColumns = this.getAllFormatColumnWithStyle();
-        return this.getAppropriateFormatColumn(formatColumns, column);
+        return this.getFormatColumnsForColumn(abColumn, config);
     }
-    getFormatColumnWithStyleClassNameForColumn(column) {
-        const formatColumns = this.getAllFormatColumnWithStyle().filter((fc) => StringExtensions_1.default.IsNotNullOrEmpty(fc.Style.ClassName));
-        return this.getAppropriateFormatColumn(formatColumns, column);
+    getFormatColumnWithStyleClassNameForColumn(column, config) {
+        return this.getFormatColumnsWithStyleForColumn(column, config).filter((formatColumn) => { var _a; return StringExtensions_1.default.IsNotNullOrEmpty((_a = formatColumn === null || formatColumn === void 0 ? void 0 : formatColumn.Style) === null || _a === void 0 ? void 0 : _a.ClassName); });
     }
-    getFormatColumnWithDisplayFormatForColumn(column) {
-        const formatColumns = this.getAllFormatColumnWithDisplayFormat().concat(this.getAllFormatColumnWithCellAlignment());
-        return this.getAppropriateFormatColumn(formatColumns, column);
+    getFormatColumnsWithDisplayFormatForColumn(column, config) {
+        const formatColumns = this.getAllFormatColumnWithDisplayFormat().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.getFormatColumnWithColumnInScope(formatColumns, column);
     }
     getFormatColumnWithSingleColumnScope(columnId) {
         const abColumn = this.adaptable.api.columnApi.getColumnFromId(columnId);
@@ -150,20 +119,21 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
         });
         return returnFormatColumn;
     }
-    getAppropriateFormatColumn(formatColumns, column) {
-        let scopedFormatColumns = 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;
-                }
-            }
+    // TODO is this really needed, I don't think it achieves anything
+    getFormatColumnInColumnScope(formatColumns) {
+        // we need to maintain the format columns order, therefore we will extract all 3 scope types in a single iteration
+        return formatColumns.filter((fc) => {
+            return (
+            // this.getFormatColumnsWithColumnScope(formatColumns)
+            this.adaptable.api.scopeApi.scopeHasColumns(fc.Scope) ||
+                // this.getFormatColumnsWithDataTypeScope(formatColumns)
+                this.adaptable.api.scopeApi.scopeHasDataType(fc.Scope) ||
+                // this.getFormatColumnsWithAllScope(formatColumns)
+                this.adaptable.api.scopeApi.scopeIsAll(fc.Scope));
         });
-        return returnFormatColumn;
+    }
+    getFormatColumnWithColumnInScope(formatColumns, column) {
+        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.adaptable.api.scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
     }
     hasStyleFormatColumns() {
         return ArrayExtensions_1.default.IsNotNullOrEmpty(this.getAllFormatColumnWithStyle());
@@ -180,129 +150,6 @@ class FormatColumnApiImpl extends ApiBase_1.ApiBase {
     getFormatColumnsWithColumnScope(formatColumns) {
         return formatColumns.filter((fc) => this.adaptable.api.scopeApi.scopeHasColumns(fc.Scope));
     }
-    getNumericStyleMinValue(numericStyle, column, rowNode, cellValue) {
-        var _a, _b;
-        const columnComparison = numericStyle.GradientStyle
-            ? numericStyle.GradientStyle.ColumnComparison
-            : (_a = numericStyle.PercentBarStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison;
-        if (columnComparison) {
-            if (!isNaN(Number(columnComparison.MinValue))) {
-                return Number(columnComparison.MinValue);
-            }
-            else {
-                let columnId = columnComparison.MinValue;
-                if (!this.adaptable.api.columnApi.doesColumnExist(columnId)) {
-                    return 0;
-                }
-                else {
-                    return this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, columnId);
-                }
-            }
-        }
-        // for Gradient Column we want just the range that contains cell value
-        if (numericStyle.GradientStyle) {
-            let range;
-            numericStyle.GradientStyle.CellRanges.forEach((cellRange) => {
-                if (!range) {
-                    if ((cellRange.Min == 'Col-Min' || cellValue >= cellRange.Min) &&
-                        (cellRange.Max == 'Col-Max' || cellValue <= cellRange.Max)) {
-                        range = cellRange;
-                    }
-                }
-            });
-            return this.getCellColorRangeMinValue(range, column);
-        }
-        // for percentbar we want to get the whole Ranges
-        if (numericStyle.PercentBarStyle) {
-            const ranges = (_b = numericStyle.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.CellRanges;
-            if (ranges) {
-                return this.getCellColorRangeMinValue(ranges[0], column);
-            }
-        }
-    }
-    getNumericStyleMaxValue(numericStyle, column, rowNode, cellValue) {
-        var _a, _b;
-        const columnComparison = numericStyle.GradientStyle
-            ? numericStyle.GradientStyle.ColumnComparison
-            : (_a = numericStyle.PercentBarStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison;
-        if (columnComparison) {
-            if (!isNaN(Number(columnComparison.MaxValue))) {
-                return Number(columnComparison.MaxValue);
-            }
-            else {
-                let columnId = columnComparison.MaxValue;
-                if (!this.adaptable.api.columnApi.doesColumnExist(columnId)) {
-                    return 0;
-                }
-                else {
-                    return this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, columnId);
-                }
-            }
-        }
-        if (numericStyle.GradientStyle) {
-            let range;
-            numericStyle.GradientStyle.CellRanges.forEach((cellRange) => {
-                if (!range) {
-                    if ((cellRange.Min == 'Col-Min' || cellValue >= cellRange.Min) &&
-                        (cellRange.Max == 'Col-Max' || cellValue <= cellRange.Max)) {
-                        range = cellRange;
-                    }
-                }
-            });
-            return this.getCellColorRangeMaxValue(range, column);
-        }
-        if (numericStyle.PercentBarStyle) {
-            const ranges = (_b = numericStyle.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.CellRanges;
-            if (ranges) {
-                return this.getCellColorRangeMaxValue(ranges[ranges.length - 1], column);
-            }
-        }
-    }
-    getCellColorRangeMinValue(range, column) {
-        if (!range) {
-            return undefined;
-        }
-        if (range.Min == undefined) {
-            return undefined;
-        }
-        return range.Min == 'Col-Min'
-            ? this.getAdaptableApi().columnApi.getMinValueForNumericColumn(column)
-            : range.Min;
-    }
-    getCellColorRangeMaxValue(range, column) {
-        if (!range) {
-            return undefined;
-        }
-        if (range.Max == undefined) {
-            return undefined;
-        }
-        return range.Max == 'Col-Max'
-            ? this.getAdaptableApi().columnApi.getMaxValueForNumericColumn(column)
-            : range.Max;
-    }
-    getCheckBoxStyleFormatColumn(column) {
-        var _a;
-        if (column.dataType != 'Boolean') {
-            return undefined;
-        }
-        const checkBoxFormatColumns = (_a = this.getFormatColumnState().FormatColumns) === null || _a === void 0 ? void 0 : _a.filter((fc) => { var _a; return (_a = fc.ColumnStyle) === null || _a === void 0 ? void 0 : _a.CheckBoxStyle; });
-        const formatColumn = checkBoxFormatColumns.find((fc) => this.adaptable.api.scopeApi.isColumnInScope(column, fc.Scope));
-        return formatColumn;
-    }
-    isCheckBoxStyleFormatColumn(column) {
-        const formatColumn = this.getCheckBoxStyleFormatColumn(column);
-        return Helper_1.default.objectExists(formatColumn);
-    }
-    fireCheckboxColumnClickedEvent(columnId, rowData, primaryKeyValue, isChecked) {
-        let checkboxColumnClickedInfo = {
-            adaptableApi: this.adaptable.api,
-            column: this.adaptable.api.columnApi.getColumnFromId(columnId),
-            rowData: rowData,
-            primaryKeyValue: primaryKeyValue,
-            isChecked: isChecked,
-        };
-        this.adaptable.api.eventApi.emit('CheckboxColumnClicked', checkboxColumnClickedInfo);
-    }
     applyCustomFormatters(value, node, abColumn, options) {
         var _a, _b, _c;
         const columnCustomFormatters = (_a = options === null || options === void 0 ? void 0 : options.CustomDisplayFormats) !== null && _a !== void 0 ? _a : [];
@@ -355,5 +202,74 @@ 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));
+    }
+    getFormatColumnsRelevantForColumn(formatColumns, column, params) {
+        return formatColumns.filter((formatColumn) => this.isFormatColumnRelevantForColumn(formatColumn, column, params));
+    }
+    isFormatColumnRelevantForColumn(formatColumn, column, params) {
+        // suspended is important to be first
+        if (formatColumn.IsSuspended) {
+            return false;
+        }
+        if (!formatColumn.Rule) {
+            return true;
+        }
+        if (!formatColumn.IncludeGroupedRows &&
+            this.adaptable.api.gridApi.isGroupRowNode(params.node)) {
+            return false;
+        }
+        // first run the predicate
+        if (formatColumn.Rule.Predicate && formatColumn.Rule.Predicate.PredicateId) {
+            return this.evaluatePredicate({
+                formatColumn,
+                column,
+                value: params.value,
+                node: params.node,
+            });
+        }
+        else if (formatColumn.Rule.BooleanExpression) {
+            return this.evaluateExpression(formatColumn, params.node);
+        }
+        // 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));
+    }
+    getFormatColumnsWithExpression() {
+        return this.getAllFormatColumn().filter((fc) => { var _a; return !!((_a = fc.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression); });
+    }
+    incrementFormatColumnPrecedence(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnMoveUp(formatColumn));
+    }
+    decrementFormatColumnPrecedence(formatColumn) {
+        this.dispatchAction(FormatColumnRedux.FormatColumnMoveDown(formatColumn));
+    }
 }
 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;
+    deleteConditionalStyles(conditionalStyles: any[]): void;
 }

package/src/Api/Implementation/InternalApiImpl.js

@@ -650,5 +650,10 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
             ? this.adaptable.api.queryLanguageApi.getAdaptableQueryExpressionWithColumnFriendlyNames(query)
             : this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(query);
     }
+    deleteConditionalStyles(conditionalStyles) {
+        conditionalStyles.forEach((cs) => {
+            this.dispatchAction(DeadRedux.ConditionalStyleDelete(cs));
+        });
+    }
 }
 exports.InternalApiImpl = InternalApiImpl;

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

@@ -5,6 +5,7 @@ import { IPushPullApi } from '../IPushPullApi';
 import { Glue42Api } from '../Glue42Api';
 import { OpenFinApi } from '../OpenFinApi';
 import { FinanceApi } from '../FinanceApi';
+import { FinsembleApi } from '../FinsembleApi';
 export declare class PluginsApiImpl extends ApiBase implements PluginsApi {
     getPluginsState(): PluginsState;
     getPluginState(pluginId: string): any;
@@ -15,4 +16,5 @@ export declare class PluginsApiImpl extends ApiBase implements PluginsApi {
     getGlue42PluginApi(): Glue42Api;
     getOpenFinPluginApi(): OpenFinApi;
     getFinancePluginApi(): FinanceApi;
+    getFinsemblePluginApi(): FinsembleApi;
 }

package/src/Api/Implementation/PluginsApiImpl.js

@@ -32,6 +32,9 @@ class PluginsApiImpl extends ApiBase_1.ApiBase {
             if (pluginId === 'openfin') {
                 return api;
             }
+            if (pluginId === 'finsemble') {
+                return api;
+            }
             return api;
         }
         catch (ex) {
@@ -50,5 +53,8 @@ class PluginsApiImpl extends ApiBase_1.ApiBase {
     getFinancePluginApi() {
         return this.getPluginApi('finance');
     }
+    getFinsemblePluginApi() {
+        return this.getPluginApi('finsemble');
+    }
 }
 exports.PluginsApiImpl = PluginsApiImpl;

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

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

package/src/Api/Implementation/QueryLanguageApiImpl.js

@@ -4,7 +4,6 @@ exports.QueryLanguageApiImpl = void 0;
 const tslib_1 = require("tslib");
 const ApiBase_1 = require("./ApiBase");
 const parser = tslib_1.__importStar(require("../../parser/src"));
-const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
 const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
 class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
     isValidBooleanExpression(query, module, validationErrorMessage) {
@@ -67,24 +66,16 @@ class QueryLanguageApiImpl extends ApiBase_1.ApiBase {
             return [];
         }
     }
-    getQueryableColumnIds() {
-        let queryableColumns = this.getExpressionOptions().queryableColumns;
-        if (!queryableColumns) {
-            return undefined;
+    isColumnQueryable(adaptableColumnBase) {
+        let queryableColumnFn = this.getExpressionOptions().isColumnQueryable;
+        if (queryableColumnFn) {
+            const queryableColumnContext = {
+                adaptableColumn: adaptableColumnBase,
+                adaptableApi: this.getAdaptableApi(),
+            };
+            return queryableColumnFn(queryableColumnContext);
         }
-        // first do the function then get hardcoded items
-        if (typeof queryableColumns === 'function') {
-            return queryableColumns();
-        }
-        else {
-            let arr = queryableColumns;
-            if (arr && ArrayExtensions_1.default.IsNotNullOrEmpty(arr)) {
-                return arr;
-            }
-        }
-    }
-    getModuleExpressionFunctionMap() {
-        return this.getExpressionOptions().moduleExpressionFunctions;
+        return true;
     }
     getAdaptableQueryExpression(query) {
         var _a, _b, _c, _d;

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

@@ -2,7 +2,7 @@ import { ApiBase } from './ApiBase';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableScope, ScopeDataType } from '../../PredefinedConfig/Common/AdaptableScope';
 import { ScopeApi } from '../ScopeApi';
-import { CellColorRange } from '../../PredefinedConfig/FormatColumnState';
+import { CellColorRange } from '../../PredefinedConfig/StyledColumnState';
 export declare class ScopeApiImpl extends ApiBase implements ScopeApi {
     isColumnInScope(column: AdaptableColumn | undefined, scope: AdaptableScope | undefined): boolean;
     getColumnsForScope(scope: AdaptableScope): AdaptableColumn[];

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

@@ -0,0 +1,25 @@
+import { ApiBase, LayoutAssociatedObjectLoadConfig } from './ApiBase';
+import { StyledColumnApi } from '../StyledColumnApi';
+import { StyledColumnState, StyledColumn } from '../../PredefinedConfig/StyledColumnState';
+import { AdaptableColumn, CellColorRange, ColumnComparison } from '../../types';
+import { RowNode } from '@ag-grid-community/core';
+export declare class StyledColumnApiImpl extends ApiBase implements StyledColumnApi {
+    getStyledColumnState(): StyledColumnState;
+    getAllStyledColumn(config?: LayoutAssociatedObjectLoadConfig): StyledColumn[];
+    getStyledColumnById(id: StyledColumn['Uuid']): StyledColumn;
+    getStyledColumnByColumnId(id: StyledColumn['Uuid']): StyledColumn;
+    getAllActiveStyledColumn(): StyledColumn[];
+    getAllSuspendedStyledColumn(): StyledColumn[];
+    deleteStyledColumn(styledColumn: StyledColumn): void;
+    addStyledColumn(styledColumn: StyledColumn): void;
+    getNumericStyleMinValue(styledColumn: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number;
+    getNumericStyleMaxValue(styledColumn: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number | undefined;
+    getCellColorRangeMinValue(range: CellColorRange, column: AdaptableColumn): number | undefined;
+    getCellColorRangeMaxValue(range: CellColorRange, column: AdaptableColumn): number | undefined;
+    getColumnComparisonForStyledColumn(styledColumn: StyledColumn): ColumnComparison | undefined;
+    getColumnIdsFromColumnComparison(columnComparison: ColumnComparison): string[];
+    getCheckBoxStyleStyledColumn(column: AdaptableColumn): StyledColumn | undefined;
+    isCheckBoxStyleStyledColumn(column: AdaptableColumn): boolean;
+    fireCheckboxColumnClickedEvent(columnId: string, rowData: any, primaryKeyValue: any, isChecked: boolean): void;
+    getActiveStyledColumnForColumn(column: AdaptableColumn): StyledColumn | undefined;
+}