@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.1

package/src/Api/Internal/CalculatedColumnInternalApi.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculatedColumnInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class CalculatedColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns all the references in the AdaptableState of the given CalculatedColumn
+     * @param calculatedColumn CalculatedColumn to be checked
+     */
+    getCalculatedColumnModuleReferences(calculatedColumn) {
+        const references = [];
+        this.adaptable.adaptableModules.forEach((module) => {
+            if (module
+                .getModuleCalculatedColumnReferences()
+                .some((moduleReference) => moduleReference.Uuid === calculatedColumn.Uuid)) {
+                references.push(module.moduleInfo.FriendlyName);
+            }
+        });
+        return references;
+    }
+    /**
+     * Returns all Calculated Columns whose Expression contains the ColumnId
+     * @param columnId ColumnId to check
+     */
+    getCalculatedColumnsReferencingColumnId(columnId) {
+        const calcColumns = [];
+        this.getCalculatedColumnApi()
+            .getCalculatedColumns()
+            .forEach((calculatedColumn) => {
+            if (this.getQueryLanguageApi().internalApi.isColumnReferencedInExpression(columnId, this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query))) {
+                calcColumns.push(calculatedColumn);
+            }
+        });
+        return calcColumns;
+    }
+    /**
+     * Gets any ColumnIds referenced in a Calculated Column
+     * @param calculatedColumn Calculated Column to check
+     */
+    getReferencedColumnIdsForCalculatedColumn(calculatedColumn) {
+        const columnIds = this.adaptable.api.queryLanguageApi.getColumnsFromExpression(this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query));
+        return columnIds;
+    }
+    /**
+     * Gets any ColumnIds referenced in a Calculated Column
+     * @param calculatedColumnId CalculatedColumnId to check
+     */
+    getReferencedColumnIdsForCalculatedColumnId(calculatedColumnId) {
+        const calculatedColumn = this.adaptable.api.calculatedColumnApi
+            .getCalculatedColumns()
+            .find((cc) => cc.ColumnId == calculatedColumnId);
+        if (calculatedColumn) {
+            return this.getReferencedColumnIdsForCalculatedColumn(calculatedColumn);
+        }
+    }
+}
+exports.CalculatedColumnInternalApi = CalculatedColumnInternalApi;

package/src/Api/Internal/ColumnInternalApi.d.ts

@@ -0,0 +1,33 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { Column } from '@ag-grid-community/core';
+export declare class ColumnInternalApi extends ApiBase {
+    /**
+     * Retrieves 'ColumnType' property for a given Column
+     * @param columnId Column to use
+     */
+    getAgGridColumnType(columnId: string): string | string[];
+    /**
+     * Retrieves a list providing the Friendly Name / Caption for all columns
+     */
+    getAllColumnFriendlyNames(): string[];
+    /**
+     * Retrieves AG Grid's field property for the column
+     * @param columnId columnId to look up
+     */
+    getAgGridColumnFieldForAdaptableColumn(columnId: string): string;
+    /**
+     * Retrieves AG Grid's column for an Adaptable column
+     * @param columnId columnId to look up
+     */
+    getAgGridColumnForAdaptableColumn(columnId: string): Column;
+    /**
+     * Does Column use AdapTable's Filter Form
+     * @param columnId Column to Check
+     */
+    usesAdaptableFilterForm(columnId: string): boolean;
+    /**
+     * Does Column use AdapTable's Quick Filter
+     * @param columnId Column to Check
+     */
+    usesAdaptableQuickFilter(columnId: string): boolean;
+}

package/src/Api/Internal/ColumnInternalApi.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class ColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Retrieves 'ColumnType' property for a given Column
+     * @param columnId Column to use
+     */
+    getAgGridColumnType(columnId) {
+        return this.adaptable.getAgGridColumnType(columnId);
+    }
+    /**
+     * Retrieves a list providing the Friendly Name / Caption for all columns
+     */
+    getAllColumnFriendlyNames() {
+        return this.getColumnApi()
+            .getColumns()
+            .map((c) => {
+            return c.friendlyName;
+        });
+    }
+    /**
+     * Retrieves AG Grid's field property for the column
+     * @param columnId columnId to look up
+     */
+    getAgGridColumnFieldForAdaptableColumn(columnId) {
+        const agGridColumn = this.getAgGridColumnForAdaptableColumn(columnId);
+        return agGridColumn.getColDef().field || '';
+    }
+    /**
+     * Retrieves AG Grid's column for an Adaptable column
+     * @param columnId columnId to look up
+     */
+    getAgGridColumnForAdaptableColumn(columnId) {
+        return this.adaptable.getAgGridColumnForColumnId(columnId);
+    }
+    /**
+     * Does Column use AdapTable's Filter Form
+     * @param columnId Column to Check
+     */
+    usesAdaptableFilterForm(columnId) {
+        const useAdaptableFilterForm = this.getFilterOptions().useAdaptableFilterForm;
+        if (useAdaptableFilterForm == null || useAdaptableFilterForm == false) {
+            return false;
+        }
+        if (Array.isArray(useAdaptableFilterForm) && !useAdaptableFilterForm.includes(columnId)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Does Column use AdapTable's Quick Filter
+     * @param columnId Column to Check
+     */
+    usesAdaptableQuickFilter(columnId) {
+        const useAdaptableQuickFilter = this.getFilterOptions().useAdaptableQuickFilter;
+        if (useAdaptableQuickFilter == null || useAdaptableQuickFilter == false) {
+            return false;
+        }
+        if (Array.isArray(useAdaptableQuickFilter) && !useAdaptableQuickFilter.includes(columnId)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.ColumnInternalApi = ColumnInternalApi;

package/src/Api/Internal/CustomSortInternalApi.d.ts

@@ -0,0 +1,6 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { ColumnValuesComparer } from '../../AdaptableOptions/GeneralOptions';
+export declare class CustomSortInternalApi extends ApiBase {
+    getCustomSortComparer(column: AdaptableColumn): ColumnValuesComparer | undefined;
+}

package/src/Api/Internal/CustomSortInternalApi.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSortInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class CustomSortInternalApi extends ApiBase_1.ApiBase {
+    getCustomSortComparer(column) {
+        var _a;
+        return (_a = this.getGeneralOptions().customSortComparers) === null || _a === void 0 ? void 0 : _a.find((csc) => this.adaptable.api.scopeApi.isColumnInScope(column, csc.scope));
+    }
+}
+exports.CustomSortInternalApi = CustomSortInternalApi;

package/src/Api/Internal/DashboardInternalApi.d.ts

@@ -0,0 +1,8 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { DashboardState } from '../../PredefinedConfig/DashboardState';
+export declare class DashboardInternalApi extends ApiBase {
+    /**
+     * Fires Dashboard Changed Event
+     */
+    fireDashboardChangedEvent(trigger: string, oldDashboardState: DashboardState, newDashboardState: DashboardState): void;
+}

package/src/Api/Internal/DashboardInternalApi.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+class DashboardInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires Dashboard Changed Event
+     */
+    fireDashboardChangedEvent(trigger, oldDashboardState, newDashboardState) {
+        // it's called synchronously by DASHBOARD_SET_ACTIVE_TAB & DASHBOARD_SET_IS_COLLAPSED,
+        // both firing the same events, thus this function being called twice;
+        // so we debounced to only get the latest call
+        const dashboardChangedInfo = {
+            adaptableApi: this.adaptable.api,
+            actionName: trigger,
+            oldDashboardState,
+            newDashboardState,
+        };
+        if (!(0, isEqual_1.default)(oldDashboardState, newDashboardState)) {
+            this.adaptable.api.eventApi.emitSync('DashboardChanged', dashboardChangedInfo);
+        }
+    }
+}
+exports.DashboardInternalApi = DashboardInternalApi;

package/src/Api/Internal/DataSetInternalApi.d.ts

@@ -0,0 +1,9 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { DataSet } from '../../AdaptableOptions/GeneralOptions';
+export declare class DataSetInternalApi extends ApiBase {
+    /**
+     * Fires the DataSet Selected Event
+     * @param dataSet Data Set which has been selected
+     */
+    fireDataSetSelectedEvent(dataSet: DataSet): void;
+}

package/src/Api/Internal/DataSetInternalApi.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSetInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class DataSetInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires the DataSet Selected Event
+     * @param dataSet Data Set which has been selected
+     */
+    fireDataSetSelectedEvent(dataSet) {
+        if (this.adaptable.isLive) {
+            const dataSetSelectedInfo = {
+                adaptableApi: this.adaptable.api,
+                dataSet,
+            };
+            this.adaptable.api.eventApi.emit('DataSetSelected', dataSetSelectedInfo);
+        }
+    }
+}
+exports.DataSetInternalApi = DataSetInternalApi;

package/src/Api/Internal/ExportInternalApi.d.ts

@@ -0,0 +1,11 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { Report } from '../../PredefinedConfig/ExportState';
+export declare class ExportInternalApi extends ApiBase {
+    /**
+     * Whether given data change affects given report
+     * @param cellDataChangedInfo data change to check
+     * @param report report to check
+     */
+    isDataChangeInReport(cellDataChangedInfo: CellDataChangedInfo, report: Report): boolean;
+}

package/src/Api/Internal/ExportInternalApi.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class ExportInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Whether given data change affects given report
+     * @param cellDataChangedInfo data change to check
+     * @param report report to check
+     */
+    isDataChangeInReport(cellDataChangedInfo, report) {
+        // for All Data Report any data change is true so get out asap
+        if (report.Name == 'All Data') {
+            return true;
+        }
+        // if its a Custom Report then the User has to run it so we just ignore completely
+        if (this.getExportApi().isServerReport(report)) {
+            return false;
+        }
+        // Start with the DataChanged Column and go through all possibilities
+        switch (report.ReportColumnScope) {
+            case 'AllColumns':
+                // has to be relevant so continue to rows
+                break;
+            case 'ScopeColumns':
+                // use the Scope object which will tell us if the Column is relevant
+                if (!this.adaptable.api.scopeApi.isColumnInScopeColumns(cellDataChangedInfo.column, report.Scope)) {
+                    return false;
+                }
+                break;
+            case 'SelectedColumns':
+                let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
+                if (selectedCellInfo) {
+                    if (selectedCellInfo.columns.find((c) => c.columnId == cellDataChangedInfo.column.columnId) == null) {
+                        return false;
+                    }
+                }
+                break;
+            case 'VisibleColumns':
+                //  hope that visibile column property is updated whenever the layout changes... (need to check!)
+                if (!cellDataChangedInfo.column.visible) {
+                    return false;
+                }
+                break;
+        }
+        // now do rows
+        switch (report.ReportRowScope) {
+            case 'AllRows':
+                return true;
+            case 'ExpressionRows':
+                return true; // TODO this is the only difficult one - do we check AdapTableQL?  if we can then that is good as we can then do a delta after all...
+            case 'SelectedCellRows':
+                let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
+                if (selectedCellInfo && selectedCellInfo.gridCells) {
+                    if (selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
+                        return true;
+                    }
+                }
+                return false;
+            case 'SelectedRows':
+                let selectedRowInfo = this.adaptable.api.gridApi.getSelectedRowInfo();
+                if (selectedRowInfo && selectedRowInfo.gridRows) {
+                    if (selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
+                        return true;
+                    }
+                }
+                return false;
+            case 'VisibleRows':
+                return this.adaptable.isRowNodeVisible(cellDataChangedInfo.rowNode);
+        }
+    }
+}
+exports.ExportInternalApi = ExportInternalApi;

package/src/Api/Internal/FilterInternalApi.d.ts

@@ -0,0 +1,58 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { ColumnFilter } from '../../PredefinedConfig/Common/ColumnFilter';
+import { RowNode } from '@ag-grid-community/core';
+import { LayoutColumnFilterAction } from '../../Redux/ActionsReducers/LayoutRedux';
+import * as Redux from 'redux';
+export declare class FilterInternalApi extends ApiBase {
+    /**
+     * Returns Predicate Definition for given Column and Quick Filter shortcut
+     * @param shortcut Quick Filter shortcut to lookup
+     * @param column Adaptable Column being Filtered
+     */
+    findPredicateDefByShortcut(shortcut: string, column: AdaptableColumn): AdaptablePredicateDef;
+    /**
+     * Creates an Equality Filter based on given Grid Cells
+     * @param gridCells cells to create Filter for
+     */
+    createValuesColumnFilterForCells(gridCells: GridCell[]): ColumnFilter | null;
+    /**
+     *  Creates an Equality Filter based on given Grid Cell
+     * @param gridCell cell to create Filter for
+     */
+    createEqualityColumnFilterForCell(gridCell: GridCell): ColumnFilter | null;
+    /**
+     * Retrieves description of given Column Filter
+     * @param columnFilter Column Filter to use
+     */
+    columnFilterToString(columnFilter: ColumnFilter): string;
+    /**
+     * Retrieves descriptions of given Column Filters
+     * @param columnFilters Column Filters to use
+     */
+    columnFiltersToString(columnFilters: ColumnFilter[]): string;
+    /**
+     * Calls AdapTableQL to evaluate Filter for given Row
+     * @param columnFilter Column Filter to use
+     * @param node Row Node to evaluate
+     */
+    evaluateColumnFilter(columnFilter: ColumnFilter, node: RowNode): boolean;
+    /**
+     * Checks if the filter action should trigger grid filtering.
+     *
+     * @param action Filtering Action
+     */
+    shouldNewColumnFilterTriggerGridFiltering(action: LayoutColumnFilterAction | Redux.Action): boolean;
+    /**
+     * Fires Filter Applied Event - typically used to enable filtering on the server
+     */
+    fireFilterAppliedEvent(): void;
+    /**
+     * Compares to sets of Column Filters to see if they are identical
+     * @param filters1
+     * @param filters2
+     */
+    areColumnFiltersDifferent(oldFilters: ColumnFilter[], newFilters: ColumnFilter[]): boolean;
+}

package/src/Api/Internal/FilterInternalApi.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const LayoutRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/LayoutRedux"));
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+class FilterInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns Predicate Definition for given Column and Quick Filter shortcut
+     * @param shortcut Quick Filter shortcut to lookup
+     * @param column Adaptable Column being Filtered
+     */
+    findPredicateDefByShortcut(shortcut, column) {
+        return this.getFilterApi()
+            .getFilterPredicateDefsForColumn(column)
+            .find((i) => { var _a; return (_a = i.shortcuts) === null || _a === void 0 ? void 0 : _a.includes(shortcut); });
+    }
+    /**
+     * Creates an Equality Filter based on given Grid Cells
+     * @param gridCells cells to create Filter for
+     */
+    createValuesColumnFilterForCells(gridCells) {
+        if (!gridCells) {
+            return null;
+        }
+        const filter = {
+            ColumnId: gridCells[0].column.columnId,
+            Predicate: {
+                PredicateId: 'Values',
+                Inputs: [...new Set(gridCells.map((gc) => gc.displayValue))],
+            },
+        };
+        const [savedFilter] = this.getFilterApi().setColumnFilters([filter]) || [null];
+        return savedFilter;
+    }
+    /**
+     *  Creates an Equality Filter based on given Grid Cell
+     * @param gridCell cell to create Filter for
+     */
+    createEqualityColumnFilterForCell(gridCell) {
+        if (!gridCell) {
+            return null;
+        }
+        const column = gridCell.column;
+        const filter = {
+            ColumnId: column.columnId,
+            Predicate: {
+                PredicateId: this.adaptable.api.predicateApi.internalApi.getEqualityPredicateForDataType(column.dataType),
+                Inputs: [...new Set([gridCell.rawValue])],
+            },
+        };
+        const [savedFilter] = this.getFilterApi().setColumnFilters([filter]) || [null];
+        return savedFilter;
+    }
+    /**
+     * Retrieves description of given Column Filter
+     * @param columnFilter Column Filter to use
+     */
+    columnFilterToString(columnFilter) {
+        const friendlyName = this.adaptable.api.columnApi.getFriendlyNameForColumnId(columnFilter.ColumnId);
+        return ('[' +
+            friendlyName +
+            '] ' +
+            this.adaptable.api.predicateApi.predicateToString(columnFilter.Predicate));
+    }
+    /**
+     * Retrieves descriptions of given Column Filters
+     * @param columnFilters Column Filters to use
+     */
+    columnFiltersToString(columnFilters) {
+        return columnFilters.map((cf) => this.columnFilterToString(cf)).join(', ');
+    }
+    /**
+     * Calls AdapTableQL to evaluate Filter for given Row
+     * @param columnFilter Column Filter to use
+     * @param node Row Node to evaluate
+     */
+    evaluateColumnFilter(columnFilter, node) {
+        var _a;
+        if (!columnFilter.Predicate) {
+            return true;
+        }
+        const someInputsAreEmpty = (_a = columnFilter.Predicate.Inputs) === null || _a === void 0 ? void 0 : _a.some((input) => {
+            if (typeof input === 'string') {
+                return StringExtensions_1.default.IsNullOrEmpty(input);
+            }
+            if (typeof input === 'number') {
+                return isNaN(input);
+            }
+            return !input;
+        });
+        if (someInputsAreEmpty) {
+            return true;
+        }
+        const column = this.adaptable.api.columnApi.getColumnWithColumnId(columnFilter.ColumnId);
+        if (!column) {
+            return true;
+        }
+        const gridCell = this.adaptable.api.gridApi.getGridCellFromRowNode(node, columnFilter.ColumnId);
+        if (!gridCell) {
+            return true;
+        }
+        let value = gridCell.normalisedValue;
+        return this.adaptable.api.predicateApi.handlePredicate(columnFilter.Predicate, {
+            value: value,
+            oldValue: null,
+            displayValue: gridCell.displayValue,
+            node,
+            column,
+        }, true);
+    }
+    /**
+     * Checks if the filter action should trigger grid filtering.
+     *
+     * @param action Filtering Action
+     */
+    shouldNewColumnFilterTriggerGridFiltering(action) {
+        // trigger filter change only:
+        // - new -> new filter is active
+        // - clear -> previous filters was active
+        // - clearAll -> a filter was active
+        // - edit -> same => input change
+        // - edit -> different & new is active
+        // - edit -> different & old was active
+        // - set -> new filter is active
+        // filter -> suspend changes
+        var _a, _b;
+        const isNewAndActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_ADD &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isClearAndPreviousWasActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isClearAllAtLeastOneActiveFilter = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR_ALL &&
+            this.adaptable.api.filterApi
+                .getColumnFilters()
+                .some((columnFilter) => this.adaptable.api.filterApi.isFilterActive(columnFilter));
+        let isEditTrigger = false;
+        if (action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_EDIT) {
+            const newFilter = action.columnFilter;
+            const previous = this.adaptable.api.filterApi.getColumnFilterForColumn(newFilter.ColumnId);
+            // same filter edit, so always trigger
+            if (((_a = previous === null || previous === void 0 ? void 0 : previous.Predicate) === null || _a === void 0 ? void 0 : _a.PredicateId) === ((_b = newFilter === null || newFilter === void 0 ? void 0 : newFilter.Predicate) === null || _b === void 0 ? void 0 : _b.PredicateId)) {
+                isEditTrigger = true;
+                // new filter is active
+            }
+            else if (this.adaptable.api.filterApi.isFilterActive(newFilter)) {
+                isEditTrigger = true;
+            }
+            else if (this.adaptable.api.filterApi.isFilterActive(previous)) {
+                // previous filter was active
+                isEditTrigger = true;
+            }
+        }
+        const isSetAndActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_SET &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isSuspendChanged = [
+            LayoutRedux.LAYOUT_COLUMN_FILTER_SUSPEND,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_SUSPEND_ALL,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_UNSUSPEND,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_UNSUSPEND_ALL,
+        ].includes(action.type);
+        return (isNewAndActive ||
+            isClearAndPreviousWasActive ||
+            isClearAllAtLeastOneActiveFilter ||
+            isEditTrigger ||
+            isSetAndActive ||
+            isSuspendChanged);
+    }
+    /**
+     * Fires Filter Applied Event - typically used to enable filtering on the server
+     */
+    fireFilterAppliedEvent() {
+        if (this.adaptable.isLive) {
+            const filterAppliedInfo = {
+                columnFilters: this.getFilterApi().getColumnFilters(),
+                adaptableApi: this.getAdaptableApi(),
+            };
+            this.adaptable.api.eventApi.emit('FilterApplied', filterAppliedInfo);
+        }
+    }
+    /**
+     * Compares to sets of Column Filters to see if they are identical
+     * @param filters1
+     * @param filters2
+     */
+    areColumnFiltersDifferent(oldFilters, newFilters) {
+        if (ArrayExtensions_1.default.IsNullOrEmpty(oldFilters) && ArrayExtensions_1.default.IsNullOrEmpty(newFilters)) {
+            return false;
+        }
+        return ArrayExtensions_1.default.areArraysNotEqual(oldFilters, newFilters);
+    }
+}
+exports.FilterInternalApi = FilterInternalApi;

package/src/Api/Internal/FlashingCellInternalApi.d.ts

@@ -0,0 +1,12 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { FlashingCellDefinition } from '../../PredefinedConfig/FlashingCellState';
+import { AdaptableFlashingCell } from '../../PredefinedConfig/Common/AdaptableFlashingCell';
+export declare class FlashingCellInternalApi extends ApiBase {
+    /**
+     * Merges a Flashing Cell Definition with default values
+     * @param flashingCellDefinition Flashing Cell Definition to Merge
+     */
+    mergeFlashingCellDefinitionWithDefaults(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    getAdaptableFlashingCellFor(primaryKey: string, columnId?: string): AdaptableFlashingCell | null;
+    clearFlashingCellState(): void;
+}

package/src/Api/Internal/FlashingCellInternalApi.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashingCellInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const Helper_1 = require("../../Utilities/Helpers/Helper");
+const SystemRedux_1 = require("../../Redux/ActionsReducers/SystemRedux");
+const AlertRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/AlertRedux"));
+class FlashingCellInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Merges a Flashing Cell Definition with default values
+     * @param flashingCellDefinition Flashing Cell Definition to Merge
+     */
+    mergeFlashingCellDefinitionWithDefaults(flashingCellDefinition) {
+        let flashingDefaults = this.adaptable.adaptableOptions.flashingCellOptions;
+        if (!flashingDefaults) {
+            return flashingCellDefinition;
+        }
+        // deep clone it, otherwise we will mutate&share(!!) the global flashingCellOptions object
+        flashingDefaults = (0, Helper_1.cloneObject)(flashingDefaults);
+        if (!flashingCellDefinition.DownChangeStyle && flashingDefaults.defaultDownChangeStyle) {
+            flashingCellDefinition.DownChangeStyle = flashingDefaults.defaultDownChangeStyle;
+        }
+        if (!flashingCellDefinition.UpChangeStyle && flashingDefaults.defaultUpChangeStyle) {
+            flashingCellDefinition.UpChangeStyle = flashingDefaults.defaultUpChangeStyle;
+        }
+        if (!flashingCellDefinition.NeutralChangeStyle && flashingDefaults.defaultNeutralChangeStyle) {
+            flashingCellDefinition.NeutralChangeStyle = flashingDefaults.defaultNeutralChangeStyle;
+        }
+        if (!flashingCellDefinition.FlashDuration && flashingDefaults.defaultFlashDuration) {
+            flashingCellDefinition.FlashDuration = flashingDefaults.defaultFlashDuration;
+        }
+        if (!flashingCellDefinition.FlashTarget && flashingDefaults.defaultFlashTarget) {
+            flashingCellDefinition.FlashTarget = flashingDefaults.defaultFlashTarget;
+        }
+        return flashingCellDefinition;
+    }
+    getAdaptableFlashingCellFor(primaryKey, columnId) {
+        var _a;
+        const { AdaptableFlashingCells: AdaptableFlashingAlerts, AdaptableFlashingCellsMap: AdaptableFlashingAlertsMap, } = this.getAdaptableState().System;
+        const forPrimaryKey = (_a = AdaptableFlashingAlerts[primaryKey]) !== null && _a !== void 0 ? _a : {};
+        const toFlashingAlert = (uuid) => { var _a; return uuid ? (_a = AdaptableFlashingAlertsMap[uuid]) !== null && _a !== void 0 ? _a : null : null; };
+        const adaptableFlashingCell = columnId
+            ? toFlashingAlert(forPrimaryKey[columnId])
+            : toFlashingAlert(forPrimaryKey[SystemRedux_1.FLASHING_CELL_ROW_KEY]);
+        if ((adaptableFlashingCell === null || adaptableFlashingCell === void 0 ? void 0 : adaptableFlashingCell.flashingCellDefinition) &&
+            !this.getAdaptableApi().layoutApi.internalApi.isObjectAvailableInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getAdaptableApi().layoutApi.getCurrentLayout())) {
+            return;
+        }
+        return adaptableFlashingCell;
+    }
+    clearFlashingCellState() {
+        this.dispatchAction(AlertRedux.AlertClearFlashingCells());
+    }
+}
+exports.FlashingCellInternalApi = FlashingCellInternalApi;