@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

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;
+}

package/src/Api/Internal/QueryInternalApi.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
+class QueryInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns the name of all the referenced Named Queries as an array of strings
+     * @param expression query string
+     */
+    getReferencedNamedQueryNames(expression = '') {
+        try {
+            return this.getAdaptableApi()
+                .internalApi.getQueryLanguageService()
+                .getNamedQueryNamesFromExpression(expression);
+        }
+        catch (error) {
+            // defensive programing, this should happen only if someone botched the predefined configs
+            (0, LoggingHelper_1.LogAdaptableWarning)(`QueryApi.getReferencedNamedQueryNames received an invalid expression: ${expression}
+                  Error: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Returns all the references in the AdaptableState of the NamedQuery with the given name
+     * @param namedQueryName namedQuery name
+     */
+    getNamedQueryModuleReferences(namedQueryName) {
+        const references = [];
+        this.adaptable.adaptableModules.forEach((module) => {
+            if (module
+                .getModuleNamedQueryReferences()
+                .some((moduleReference) => moduleReference === namedQueryName)) {
+                references.push(module.moduleInfo.FriendlyName);
+            }
+        });
+        return references;
+    }
+    /**
+     * Fires Query Run Event - typically used to enable querying on the server
+     */
+    fireQueryRunEvent() {
+        if (this.adaptable.isLive) {
+            const currentQuery = this.getQueryApi().getCurrentQuery();
+            const adaptableApi = this.getAdaptableApi();
+            const queryRunInfo = {
+                currentQuery,
+                queryAST: currentQuery
+                    ? adaptableApi.queryLanguageApi.getASTForExpression(currentQuery)
+                    : null,
+                adaptableApi: adaptableApi,
+            };
+            adaptableApi.eventApi.emit('QueryRun', queryRunInfo);
+        }
+    }
+}
+exports.QueryInternalApi = QueryInternalApi;

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

@@ -0,0 +1,11 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableQLModule } from '../../PredefinedConfig/Common/Types';
+export declare class QueryLanguageInternalApi extends ApiBase {
+    /**
+     * Checks if a column is referenced in a given Expression
+     * @param columnId Column to Check
+     * @param expression Expression to Lookup
+     */
+    isColumnReferencedInExpression(columnId: string, expression: string): boolean;
+    evaluateExpressionInAdaptableQL(module: AdaptableQLModule, expression?: string): boolean;
+}

package/src/Api/Internal/QueryLanguageInternalApi.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryLanguageInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class QueryLanguageInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Checks if a column is referenced in a given Expression
+     * @param columnId Column to Check
+     * @param expression Expression to Lookup
+     */
+    isColumnReferencedInExpression(columnId, expression) {
+        const colIds = this.getQueryLanguageApi().getColumnsFromExpression(expression);
+        return colIds.some((c) => c === columnId);
+    }
+    evaluateExpressionInAdaptableQL(module, expression) {
+        var _a;
+        const evaluateExpressionExternallyFn = (_a = this.getAdaptableQLOptions()) === null || _a === void 0 ? void 0 : _a.evaluateAdaptableQLExternally;
+        if (typeof evaluateExpressionExternallyFn !== 'function') {
+            return true;
+        }
+        const context = {
+            adaptableApi: this.getAdaptableApi(),
+            module,
+        };
+        if (expression) {
+            context.expression = expression;
+            context.referencedColumns = this.getAdaptableApi()
+                .queryLanguageApi.getColumnsFromExpression(expression)
+                .map((columnId) => this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId));
+        }
+        return !evaluateExpressionExternallyFn(context);
+    }
+}
+exports.QueryLanguageInternalApi = QueryLanguageInternalApi;

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

@@ -0,0 +1,59 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { CellColorRange, ColumnComparison, NumericStyledColumn, StyledColumn } from '../../PredefinedConfig/StyledColumnState';
+import { RowNode } from '@ag-grid-community/core/dist/cjs/es5/entities/rowNode';
+export declare class StyledColumnInternalApi extends ApiBase {
+    getMinValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    getMaxValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    /**
+     * Gets the Minimum Value to display for a Styled Column
+     * @param styledColumn Styled Column to check
+     * @param rowNode current Row Node
+     * @param cellValue current Cell Value
+     */
+    getNumericStyleMinValue(styledColumn: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number;
+    /**
+     * Returns last range that matches the cell value.
+     *
+     * @param cellRanges
+     * @param column
+     * @param rangeValueType
+     * @param cellValue
+     */
+    findRangeForColumn(cellRanges: CellColorRange[], column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType'], cellValue: any): CellColorRange | null;
+    /**
+     * Gets the Maximum Value to display for a Styled Column
+     * @param styledColumn Styled Column to check
+     * @param rowNode current Row Node
+     * @param cellValue current Cell Value
+     */
+    getNumericStyleMaxValue(styledColumn: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number;
+    /**
+     * Returns the smallest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMinValue(range: CellColorRange, column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType']): number | undefined;
+    /**
+     * Returns the largest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMaxValue(range: CellColorRange, column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType']): number | undefined;
+    /**
+     * Retrieves the ColumnComparison property, if there, from a Styled Column
+     * @param styledColumn Styled Column to Add
+     */
+    getColumnComparisonForStyledColumn(styledColumn: StyledColumn): ColumnComparison | undefined;
+    /**
+     * Returns any ColumnIds referenced in a Column Comparison
+     * @param columnComparision Column Comparison to check
+     */
+    getColumnIdsFromColumnComparison(columnComparison: ColumnComparison): string[];
+    private getDependentColumnIds;
+    /**
+     * Checks if the styled column has a range with a relative value
+     * @param styledColumn Styled Column to Add
+     */
+    hasStyledColumnRelativeCellRange(styledColumn: StyledColumn): boolean;
+}