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

package/src/Api/Internal/GridInternalApi.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
+class GridInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires Grid Sorted Event
+     */
+    fireGridSortedEvent() {
+        if (this.adaptable.isLive) {
+            const adaptableSortState = this.adaptable.api.configApi.getAdaptableSortState();
+            const adaptableApi = this.getAdaptableApi();
+            const gridSortedInfo = {
+                adaptableSortState: adaptableSortState,
+                adaptableApi: adaptableApi,
+            };
+            adaptableApi.eventApi.emit('GridSorted', gridSortedInfo);
+        }
+    }
+    /**
+     * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
+     */
+    fireCellChangedEvent(cellDataChangedInfo) {
+        if (this.adaptable.isLive) {
+            const cellChangedInfo = {
+                adaptableApi: this.adaptable.api,
+                cellChange: cellDataChangedInfo,
+            };
+            this.adaptable.api.eventApi.emit('CellChanged', cellChangedInfo);
+        }
+    }
+    /**
+     * Fires Grid Data Changed Event - when a row has changed in AG Grid
+     */
+    fireGridDataChangedEvent(dataRows, rowNodes, rowTrigger) {
+        if (this.adaptable.isLive) {
+            const gridDataChangedInfo = {
+                changedAt: Date.now(),
+                adaptableApi: this.adaptable.api,
+                rowTrigger,
+                dataRows,
+                rowNodes,
+            };
+            this.adaptable.api.eventApi.emit('GridDataChanged', gridDataChangedInfo);
+        }
+    }
+    /**
+     * Gets all distinct display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, false);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct Filter values for the Column with the given ColumnId (used for Floating Filter and Column Header filter)
+     * @param columnId Column to check
+     * @param columnFilter Current applied filter
+     */
+    async getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return {
+                values: [],
+                suppressClientSideFilter: false,
+            };
+        }
+        const { gridCells, suppressClientSideFilter } = await this.adaptable.getDistinctFilterValuesForColumn(abColumn, showFilteredRowsOnly, filter);
+        return {
+            values: this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+                return {
+                    label: cv.displayValue,
+                    value: cv.normalisedValue,
+                };
+            }),
+            suppressClientSideFilter,
+        };
+    }
+    /**
+     * Gets all distinct Custom Sort values for the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    async getDistinctCustomSortDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const gridCells = await this.adaptable.getDistinctCustomSortValuesForColumn(abColumn, false);
+        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct Bulk Update values for the Column with the given ColumnId
+     * @param columnId Column to check
+     * @param selectedGridCells Selected grid cells
+     */
+    async getDistinctBulkUpdateDisplayValuesForColumn(columnId, selectedGridCells) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const gridCells = await this.adaptable.getDistinctBulkUpdateValuesForColumn(abColumn, false, selectedGridCells);
+        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctVisibleDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, true);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct raw values in Column. Values are sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getDistinctRawValuesForColumn(columnId, skipRowNode) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        return this.sortDistinctValues(this.getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode), abColumn).map((cv) => {
+            return cv.rawValue;
+        });
+    }
+    /**
+     * Gets all distinct raw values in Column. Values are un-sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        return this.adaptable.getDistinctValuesForColumn(abColumn, false, skipRowNode);
+    }
+    /**
+     * Gets all distinct visible raw values in the Column
+     * @param columnId Column to check
+     */
+    getDistinctVisibleRawValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, true);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.rawValue;
+        });
+    }
+    sortDistinctValues(returnValues, column) {
+        // this does NOT into account Custom Sort - far too hard for now...
+        let sortOrder = Enums_1.SortOrder.Asc;
+        if (this.getFilterOptions().sortColumnValuesInFilter) {
+            let columnSort = this.adaptable.api.gridApi.getColumnSortForColumn(column.columnId);
+            if (columnSort && columnSort.SortOrder == 'Desc') {
+                sortOrder = Enums_1.SortOrder.Desc;
+            }
+        }
+        if (this.getColumnApi().hasNumberDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
+            returnValues = ArrayExtensions_1.default.sortCellValueArrayNumeric(returnValues, sortOrder);
+        }
+        else if (this.getColumnApi().hasDateDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
+            returnValues = ArrayExtensions_1.default.sortCellValueArrayDates(returnValues, sortOrder);
+        }
+        else {
+            returnValues = ArrayExtensions_1.default.sortCellValueArray(returnValues, sortOrder);
+        }
+        return returnValues;
+    }
+    setColumns(columns) {
+        this.dispatchAction(GridRedux.GridSetColumns(columns));
+    }
+    setSelectedCells(selectedCellInfo) {
+        this.dispatchAction(GridRedux.GridSetSelectedCells(selectedCellInfo));
+    }
+    setSelectedRows(selectedRowInfo) {
+        this.dispatchAction(GridRedux.GridSetSelectedRows(selectedRowInfo));
+    }
+    setGridCell(gridCell) {
+        const cellDataChangedInfo = this.createDataChangedInfoFromGridCell(gridCell);
+        this.adaptable.setCellValue(cellDataChangedInfo);
+    }
+    setGridCells(gridCells) {
+        if (ArrayExtensions_1.default.IsNotNullOrEmpty(gridCells)) {
+            gridCells.forEach((gc) => {
+                this.setGridCell(gc);
+            });
+        }
+    }
+    createDataChangedInfoFromGridCell(gridCell) {
+        let currentValue = this.adaptable.getDisplayValue(gridCell.primaryKeyValue, gridCell.column.columnId);
+        const currentRowNode = this.adaptable.getRowNodeForPrimaryKey(gridCell.primaryKeyValue);
+        const cellDataChangedInfo = this.getAdaptableApi().internalApi.buildDataChangedInfo({
+            oldValue: currentValue,
+            newValue: gridCell.rawValue,
+            column: gridCell.column,
+            primaryKeyValue: gridCell.primaryKeyValue,
+            rowNode: currentRowNode,
+        });
+        return cellDataChangedInfo;
+    }
+    buildStandaloneColumnHeader(column) {
+        return this.adaptable.buildStandaloneColumnHeader(column);
+    }
+    getEditLookUpValuesForColumn(editLookUpItem, column, gridCell) {
+        if (!editLookUpItem || !column) {
+            return undefined;
+        }
+        let editLookUpValues = editLookUpItem.values;
+        // first do the function then get hardcoded items
+        if (editLookUpValues != null && typeof editLookUpValues === 'function') {
+            const editLookUpContext = {
+                adaptableApi: this.adaptable.api,
+                column: column,
+                gridCell,
+            };
+            return editLookUpValues(editLookUpContext);
+        }
+        else {
+            let arr = editLookUpValues;
+            if (arr && ArrayExtensions_1.default.IsNotNullOrEmpty(arr)) {
+                return arr;
+            }
+        }
+        // if no hard-coded values or function provided then just get the distinct values for the column
+        // this will use the columnApi method that first looks for permitted values and then distinct values
+        return this.getDistinctDisplayValuesForColumn(column.columnId);
+    }
+}
+exports.GridInternalApi = GridInternalApi;

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

@@ -0,0 +1,48 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { Layout, LayoutState } from '../../PredefinedConfig/LayoutState';
+import { LayoutAssociatedObject } from '../../AdaptableOptions/LayoutOptions';
+import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
+export declare class LayoutInternalApi extends ApiBase {
+    /**
+     * Fires the `LayoutChanged` event
+     * @param trigger what caused event to fire
+     * @param oldSate Layout State before change
+     * @param newState Layout State after change
+     */
+    fireLayoutChangedEvent(trigger: string, oldSate: LayoutState, newState: LayoutState, skipEqualityCheck?: boolean): void;
+    /**
+     * Compares 2 Layouts for equality
+     * @param layout1 First Layout
+     * @param layout2 Second Layout
+     */
+    areLayoutsEqual(layout1: Layout, layout2: Layout): boolean;
+    /**
+     * Creates a Default Layout (when none provided in Config)
+     * @returns layout
+     */
+    createDefaultLayoutIfNeeded(): Layout | null;
+    /**
+     * Returns true if Layouts will contain Expanded Row Groups information
+     */
+    areExpandedRowGroupsSavedInLayouts(): boolean;
+    /**
+     * Checks if the draft layout and the current layout are the same.
+     * Useful when `autoSaveLayouts=true`
+     */
+    areDraftAndCurrentLayoutEqual(): boolean;
+    /**
+     * Returns what the layout supports.
+     * This takes into account the data-source.
+     */
+    getLayoutSupportedFeatures(): {
+        RowGroupedColumns: boolean;
+        AggregationColumns: boolean;
+        PivotColumns: boolean;
+        ColumnFilters: boolean;
+        ColumnSorts: boolean;
+    };
+    updateCurrentDraftLayout(layout: Layout): void;
+    hasLayoutSpecificObjects(): boolean;
+    isObjectAvailableInLayout(object: LayoutAssociatedObject, module: AdaptableModule, layout: Layout): boolean;
+    showLayoutNotAssociatedObjects(): boolean;
+}

package/src/Api/Internal/LayoutInternalApi.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+class LayoutInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires the `LayoutChanged` event
+     * @param trigger what caused event to fire
+     * @param oldSate Layout State before change
+     * @param newState Layout State after change
+     */
+    fireLayoutChangedEvent(trigger, oldSate, newState, skipEqualityCheck) {
+        const layoutChangedInfo = {
+            adaptableApi: this.getAdaptableApi(),
+            actionName: trigger,
+            oldLayoutState: oldSate,
+            newLayoutState: newState,
+        };
+        if (!skipEqualityCheck && (0, isEqual_1.default)(oldSate, newState)) {
+            return;
+        }
+        this.adaptable.api.eventApi.emit('LayoutChanged', layoutChangedInfo);
+    }
+    /**
+     * Compares 2 Layouts for equality
+     * @param layout1 First Layout
+     * @param layout2 Second Layout
+     */
+    areLayoutsEqual(layout1, layout2) {
+        if (!layout1 && !layout2) {
+            return true;
+        }
+        if (!layout1 || !layout2) {
+            return false;
+        }
+        const defaults = {
+            ColumnSorts: [],
+            //   ColumnFlexMap: {},
+            ColumnWidthMap: {},
+            RowGroupedColumns: [],
+        };
+        layout1 = Object.assign(Object.assign({}, defaults), layout1);
+        layout2 = Object.assign(Object.assign({}, defaults), layout2);
+        return (0, isEqual_1.default)(layout1, layout2);
+    }
+    /**
+     * Creates a Default Layout (when none provided in Config)
+     * @returns layout
+     */
+    createDefaultLayoutIfNeeded() {
+        let gridState = this.getAdaptableApi().gridApi.getGridState();
+        let layoutState = this.getLayoutApi().getLayoutState();
+        const isLayoutDefined = (layoutName) => !!layoutState.Layouts.filter((layout) => layout.Name === layoutName)[0];
+        let defaultLayoutColumns = gridState.Columns.filter((column) => column.visible);
+        const columnsMap = gridState.Columns.reduce((acc, col) => {
+            acc[col.columnId] = col;
+            return acc;
+        }, {});
+        let shouldCreateDefaultLayout = this.getLayoutOptions().createDefaultLayout;
+        if (!layoutState.Layouts || !layoutState.Layouts.length) {
+            shouldCreateDefaultLayout = true;
+        }
+        if (shouldCreateDefaultLayout) {
+            if (!layoutState.Layouts || !isLayoutDefined(GeneralConstants_1.DEFAULT_LAYOUT)) {
+                let defaultLayout = ObjectFactory_1.default.CreateEmptyLayout({
+                    Name: GeneralConstants_1.DEFAULT_LAYOUT,
+                    Columns: defaultLayoutColumns.map((c) => c.columnId),
+                    AggregationColumns: defaultLayoutColumns.reduce((acc, col) => {
+                        if (col.aggregationFunction) {
+                            acc[col.columnId] = col.aggregationFunction;
+                        }
+                        return acc;
+                    }, {}),
+                    PinnedColumnsMap: defaultLayoutColumns.reduce((acc, col) => {
+                        if (col.pinned) {
+                            acc[col.columnId] = col.pinned;
+                        }
+                        return acc;
+                    }, {}),
+                }, gridState.Columns);
+                this.getLayoutApi().createOrUpdateLayout(defaultLayout);
+                return defaultLayout;
+            }
+        }
+    }
+    /**
+     * Returns true if Layouts will contain Expanded Row Groups information
+     */
+    areExpandedRowGroupsSavedInLayouts() {
+        return (this.getLayoutOptions().includeExpandedRowGroups ||
+            this.getLayoutOptions().displayRowGroups === 'dynamic');
+    }
+    /**
+     * Checks if the draft layout and the current layout are the same.
+     * Useful when `autoSaveLayouts=true`
+     */
+    areDraftAndCurrentLayoutEqual() {
+        const state = this.getAdaptableState();
+        const currentLayout = this.getLayoutApi().getLayoutByName(state.Layout.CurrentLayout);
+        const draftLayout = state.Grid.CurrentLayout;
+        return this.areLayoutsEqual(currentLayout, draftLayout);
+    }
+    /**
+     * Returns what the layout supports.
+     * This takes into account the data-source.
+     */
+    getLayoutSupportedFeatures() {
+        const layoutSupportedFeatures = {
+            RowGroupedColumns: true,
+            AggregationColumns: true,
+            PivotColumns: true,
+            ColumnFilters: true,
+            ColumnSorts: true,
+        };
+        if (this.adaptable.getRowModel() === 'viewport') {
+            layoutSupportedFeatures.RowGroupedColumns = false;
+            layoutSupportedFeatures.AggregationColumns = false;
+            layoutSupportedFeatures.PivotColumns = false;
+        }
+        return layoutSupportedFeatures;
+    }
+    updateCurrentDraftLayout(layout) {
+        this.dispatchAction(GridRedux.LayoutUpdateCurrentDraft(layout));
+    }
+    hasLayoutSpecificObjects() {
+        const layoutTagOptions = this.getLayoutOptions().layoutTagOptions;
+        if (!layoutTagOptions) {
+            return false;
+        }
+        if (layoutTagOptions.autoCheckTagsForLayouts == true ||
+            typeof (layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.isObjectAvailableInLayout) === 'function') {
+            return true;
+        }
+        return false;
+    }
+    isObjectAvailableInLayout(object, module, layout) {
+        var _a;
+        if (!this.hasLayoutSpecificObjects()) {
+            return true;
+        }
+        const layoutTagOptions = this.getLayoutOptions().layoutTagOptions;
+        if ((layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.autoCheckTagsForLayouts) == true) {
+            return ArrayExtensions_1.default.IsNullOrEmpty(object.Tags) ? true : (_a = object.Tags) === null || _a === void 0 ? void 0 : _a.includes(layout.Name);
+        }
+        const context = {
+            adaptableObject: object,
+            module,
+            layout,
+            adaptableApi: this.getAdaptableApi(),
+        };
+        return layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.isObjectAvailableInLayout(context);
+    }
+    showLayoutNotAssociatedObjects() {
+        return this.getAdaptableState().System.ShowLayoutNotAssociatedObjects;
+    }
+}
+exports.LayoutInternalApi = LayoutInternalApi;

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

@@ -0,0 +1,37 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptablePredicate, AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { SystemFilterPredicateId } from '../../PredefinedConfig/Common/ColumnFilter';
+import { AdaptableColumnDataType } from '../../PredefinedConfig/Common/AdaptableColumn';
+export declare class PredicateInternalApi extends ApiBase {
+    /**
+     * Returns true if the predicate has a dropdown.
+     *
+     * @param predicate
+     */
+    hasPredicateValues(predicate: AdaptablePredicate): boolean;
+    /**
+     * Get all Filter Predicate Definitions - System and Custom
+     */
+    getFilterPredicateDefs(): AdaptablePredicateDef[];
+    private getSystemFilterPredicateIds;
+    /**
+     * Get all Alert Predicate Definitions - System and Custom
+     */
+    getAlertPredicateDefs(): AdaptablePredicateDef[];
+    private getSystemAlertPredicateIds;
+    /**
+     * Get all Format Column Predicate Definitions - System and Custom
+     */
+    getFormatColumnPredicateDefs(): AdaptablePredicateDef[];
+    private getSystemFormatColumnPredicateIds;
+    /**
+     * Get all Flashing Cell Predicate Definitions - System and Custom
+     */
+    getFlashingCellPredicateDefs(): AdaptablePredicateDef[];
+    private getSystemFlashingCellPredicateIds;
+    /**
+     * Gets the correct Equality-type System Predicate for a particular DataType
+     * @param dataType DataType of Column
+     */
+    getEqualityPredicateForDataType(dataType: AdaptableColumnDataType): SystemFilterPredicateId;
+}

package/src/Api/Internal/PredicateInternalApi.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredicateInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class PredicateInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns true if the predicate has a dropdown.
+     *
+     * @param predicate
+     */
+    hasPredicateValues(predicate) {
+        return (predicate === null || predicate === void 0 ? void 0 : predicate.PredicateId) === 'Values' || (predicate === null || predicate === void 0 ? void 0 : predicate.PredicateId) === 'ExcludeValues';
+    }
+    /**
+     * Get all Filter Predicate Definitions - System and Custom
+     */
+    getFilterPredicateDefs() {
+        var _a;
+        return [
+            ...(_a = this.getSystemFilterPredicateIds()) === null || _a === void 0 ? void 0 : _a.map((predicateId) => this.getPredicateApi().getPredicateDefById(predicateId)),
+            ...this.getPredicateApi().getCustomPredicateDefs(),
+        ].filter((predicateDef) => predicateDef.moduleScope.includes('filter'));
+    }
+    getSystemFilterPredicateIds() {
+        // for now we still need to get the old ones in case they have been provided
+        // however they have been deprectated and they are not populated by AdapTable
+        const oldSystemFilterPredicates = this.getFilterOptions().systemFilters;
+        if (oldSystemFilterPredicates) {
+            return oldSystemFilterPredicates;
+        }
+        // if old list not provided use the new property in Predicate Options
+        const systemFilterPredicates = this.getAdaptableQLOptions().predicateOptions.systemFilterPredicates;
+        if (typeof systemFilterPredicates === 'function') {
+            const systemPredicateContext = {
+                adaptableApi: this.adaptable.api,
+                systemPredicateDefs: this.getPredicateApi()
+                    .getSystemPredicateDefs()
+                    .filter((p) => p.moduleScope.includes('filter')),
+                moduleScope: 'filter',
+            };
+            return systemFilterPredicates(systemPredicateContext);
+        }
+        return systemFilterPredicates;
+    }
+    /**
+     * Get all Alert Predicate Definitions - System and Custom
+     */
+    getAlertPredicateDefs() {
+        var _a;
+        return [
+            ...(_a = this.getSystemAlertPredicateIds()) === null || _a === void 0 ? void 0 : _a.map((predicateId) => this.getPredicateApi().getPredicateDefById(predicateId)),
+            ...this.getPredicateApi().getCustomPredicateDefs(),
+        ].filter((predicateDef) => predicateDef.moduleScope.includes('alert'));
+    }
+    getSystemAlertPredicateIds() {
+        const systemAlertPredicates = this.getAdaptableQLOptions().predicateOptions.systemAlertPredicates;
+        if (typeof systemAlertPredicates === 'function') {
+            const systemPredicateContext = {
+                adaptableApi: this.adaptable.api,
+                systemPredicateDefs: this.getPredicateApi()
+                    .getSystemPredicateDefs()
+                    .filter((p) => p.moduleScope.includes('alert')),
+                moduleScope: 'alert',
+            };
+            return systemAlertPredicates(systemPredicateContext);
+        }
+        return systemAlertPredicates;
+    }
+    /**
+     * Get all Format Column Predicate Definitions - System and Custom
+     */
+    getFormatColumnPredicateDefs() {
+        var _a;
+        return [
+            ...(_a = this.getSystemFormatColumnPredicateIds()) === null || _a === void 0 ? void 0 : _a.map((predicateId) => this.getPredicateApi().getPredicateDefById(predicateId)),
+            ...this.getPredicateApi().getCustomPredicateDefs(),
+        ].filter((predicateDef) => predicateDef.moduleScope.includes('formatColumn'));
+    }
+    getSystemFormatColumnPredicateIds() {
+        const systemFormatColumnPredicates = this.getAdaptableQLOptions().predicateOptions.systemFormatColumnPredicates;
+        if (typeof systemFormatColumnPredicates === 'function') {
+            const systemPredicateContext = {
+                adaptableApi: this.adaptable.api,
+                systemPredicateDefs: this.getPredicateApi()
+                    .getSystemPredicateDefs()
+                    .filter((p) => p.moduleScope.includes('formatColumn')),
+                moduleScope: 'formatColumn',
+            };
+            return systemFormatColumnPredicates(systemPredicateContext);
+        }
+        return systemFormatColumnPredicates;
+    }
+    /**
+     * Get all Flashing Cell Predicate Definitions - System and Custom
+     */
+    getFlashingCellPredicateDefs() {
+        var _a;
+        return [
+            ...(_a = this.getSystemFlashingCellPredicateIds()) === null || _a === void 0 ? void 0 : _a.map((predicateId) => this.getPredicateApi().getPredicateDefById(predicateId)),
+            ...this.getPredicateApi().getCustomPredicateDefs(),
+        ].filter((predicateDef) => predicateDef.moduleScope.includes('flashingcell'));
+    }
+    getSystemFlashingCellPredicateIds() {
+        const systemFlashingCellPredicates = this.getAdaptableQLOptions().predicateOptions.systemFlashingCellPredicates;
+        if (typeof systemFlashingCellPredicates === 'function') {
+            const systemPredicateContext = {
+                adaptableApi: this.adaptable.api,
+                systemPredicateDefs: this.getPredicateApi()
+                    .getSystemPredicateDefs()
+                    .filter((p) => p.moduleScope.includes('flashingcell')),
+                moduleScope: 'flashingcell',
+            };
+            return systemFlashingCellPredicates(systemPredicateContext);
+        }
+        return systemFlashingCellPredicates;
+    }
+    /**
+     * Gets the correct Equality-type System Predicate for a particular DataType
+     * @param dataType DataType of Column
+     */
+    getEqualityPredicateForDataType(dataType) {
+        let predicateId;
+        switch (dataType) {
+            case 'Number':
+                predicateId = 'Equals';
+                break;
+            case 'Date':
+                predicateId = 'On';
+                break;
+            case 'String':
+                predicateId = 'Is';
+                break;
+            default:
+                predicateId = 'Equals';
+                break;
+        }
+        return predicateId;
+    }
+}
+exports.PredicateInternalApi = PredicateInternalApi;

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

@@ -0,0 +1,17 @@
+import { ApiBase } from '../Implementation/ApiBase';
+export declare class QueryInternalApi extends ApiBase {
+    /**
+     * Returns the name of all the referenced Named Queries as an array of strings
+     * @param expression query string
+     */
+    getReferencedNamedQueryNames(expression?: string): string[];
+    /**
+     * Returns all the references in the AdaptableState of the NamedQuery with the given name
+     * @param namedQueryName namedQuery name
+     */
+    getNamedQueryModuleReferences(namedQueryName: string): string[];
+    /**
+     * Fires Query Run Event - typically used to enable querying on the server
+     */
+    fireQueryRunEvent(): void;
+}