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

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

@@ -0,0 +1,109 @@
+import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, AdaptableScope, FormatColumn, StringFormatterOptions } from '../../types';
+import { ApiBase } from '../Implementation/ApiBase';
+import { RowNode } from '@ag-grid-community/core';
+export declare class FormatColumnInternalApi extends ApiBase {
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyle(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyleAndCellAlignment(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithDisplayFormat(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithCellAlignment(): FormatColumn[];
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithStyleForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    /**
+     * Gets Format Column if any for given Column which includes Style element with ClassName
+     * @param column The Column for which to retrieve the Format Column
+     * @returns format columns
+     */
+    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    getFormatColumnWithColumnInScope(formatColumns: FormatColumn[], column: AdaptableColumn): FormatColumn[];
+    private getFormatColumnInColumnScope;
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom DisplayFormat
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithDisplayFormatForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext context that includes value to format
+     * @param options formatter options
+     */
+    getNumberFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): any;
+    /**
+     * Format value according to format options.
+     *
+     * @param value  context that includes value to format
+     * @param options formatter options
+     */
+    getStringFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: StringFormatterOptions): string;
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext  context that includes value to format
+     * @param options formatter options
+     */
+    getDateFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): string;
+    private applyCustomFormatters;
+    /**
+     * Returns all Predicates appropriate for the given Scope
+     * @param scope Scope to check
+     */
+    getFormatColumnDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    /**
+     * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumn
+     * @param column
+     * @param params
+     */
+    isFormatColumnRelevantForColumn(formatColumn: FormatColumn, column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): boolean;
+    private evaluatePredicate;
+    private evaluateExpression;
+    /**
+     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumns
+     * @param column
+     * @param params
+     */
+    getFormatColumnsRelevantForColumn(formatColumns: FormatColumn[], column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): FormatColumn[];
+    /**
+     * Retrieves all Format Columns which have an Expression
+     * @returns Format Columns with Expression
+     */
+    getFormatColumnsWithExpression(): FormatColumn[];
+}

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatColumnInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const FormatHelper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/FormatHelper"));
+const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+class FormatColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyle() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.Style);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyleAndCellAlignment() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.Style || fc.CellAlignment);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithDisplayFormat() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.DisplayFormat);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithCellAlignment() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.CellAlignment);
+    }
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    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);
+    }
+    /**
+     * Gets Format Column if any for given Column which includes Style element with ClassName
+     * @param column The Column for which to retrieve the Format Column
+     * @returns format columns
+     */
+    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); });
+    }
+    getFormatColumnWithColumnInScope(formatColumns, column) {
+        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.adaptable.api.scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
+    }
+    // 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));
+        });
+    }
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom DisplayFormat
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    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);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext context that includes value to format
+     * @param options formatter options
+     */
+    getNumberFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        return FormatHelper_1.default.NumberFormatter(preparedValue, options);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param value  context that includes value to format
+     * @param options formatter options
+     */
+    getStringFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        return FormatHelper_1.default.StringFormatter(preparedValue, options);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext  context that includes value to format
+     * @param options formatter options
+     */
+    getDateFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        const dateFormatterOptions = options;
+        // only use DateFormatter if we have a pattern
+        return dateFormatterOptions.Pattern
+            ? FormatHelper_1.default.DateFormatter(preparedValue, options)
+            : preparedValue;
+    }
+    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 : [];
+        if (!(columnCustomFormatters === null || columnCustomFormatters === void 0 ? void 0 : columnCustomFormatters.length)) {
+            return value;
+        }
+        const adaptableOptions = this.adaptable.adaptableOptions;
+        const customFormattersFromOptions = (_c = (_b = adaptableOptions === null || adaptableOptions === void 0 ? void 0 : adaptableOptions.userInterfaceOptions) === null || _b === void 0 ? void 0 : _b.customDisplayFormatters) !== null && _c !== void 0 ? _c : [];
+        // formatters are applied in the order they are defined in the options
+        const customFormatters = customFormattersFromOptions.filter((customFormatterOption) => columnCustomFormatters.includes(customFormatterOption.id));
+        const customDisplayFormatterContext = ObjectFactory_1.default.CreateCustomDisplayFormatterContext(value, node, abColumn, this.getAdaptableApi());
+        return customFormatters.reduce((context, formatter) => {
+            if (formatter && formatter.handler) {
+                return formatter.handler(context);
+            }
+            return context.cellValue;
+        }, customDisplayFormatterContext);
+    }
+    /**
+     * Returns all Predicates appropriate for the given Scope
+     * @param scope Scope to check
+     */
+    getFormatColumnDefsForScope(scope) {
+        return this.getAdaptableApi()
+            .predicateApi.internalApi.getFormatColumnPredicateDefs()
+            .filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    }
+    /**
+     * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumn
+     * @param column
+     * @param params
+     */
+    isFormatColumnRelevantForColumn(formatColumn, column, params) {
+        var _a, _b;
+        // suspended is important to be first
+        if (formatColumn.IsSuspended) {
+            return false;
+        }
+        if (!formatColumn.IncludeGroupedRows &&
+            this.adaptable.api.gridApi.isGroupRowNode(params.node)) {
+            return false;
+        }
+        if (!formatColumn.Rule) {
+            return true;
+        }
+        // first run the predicate
+        if (formatColumn.Rule.Predicates && ((_b = (_a = formatColumn.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.length)) {
+            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, }) {
+        var _a;
+        const params = {
+            value: value,
+            oldValue: null,
+            displayValue: value,
+            node: node,
+            column: column,
+        };
+        return this.adaptable.api.predicateApi.handlePredicates((_a = formatColumn.Rule) === null || _a === void 0 ? void 0 : _a.Predicates, params, false);
+    }
+    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));
+    }
+    /**
+     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumns
+     * @param column
+     * @param params
+     */
+    getFormatColumnsRelevantForColumn(formatColumns, column, params) {
+        return formatColumns.filter((formatColumn) => this.isFormatColumnRelevantForColumn(formatColumn, column, params));
+    }
+    /**
+     * Retrieves all Format Columns which have an Expression
+     * @returns Format Columns with Expression
+     */
+    getFormatColumnsWithExpression() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => { var _a; return !!((_a = fc.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression); });
+    }
+}
+exports.FormatColumnInternalApi = FormatColumnInternalApi;

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

@@ -0,0 +1,15 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { FreeTextColumn } from '../../PredefinedConfig/FreeTextColumnState';
+export declare class FreeTextColumnInternalApi extends ApiBase {
+    /**
+     * Checks if a User Edit was in a Free Text Column
+     * @param cellDataChangedInfo change to check
+     */
+    handleFreeTextColumnDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
+    /**
+     * Returns all the references in the AdaptableState of the given FreeTextColumn
+     * @param freeTextColumn FreeTextColumn to be checked
+     */
+    getFreeTextColumnModuleReferences(freeTextColumn: FreeTextColumn): string[];
+}

package/src/Api/Internal/FreeTextColumnInternalApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeTextColumnInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class FreeTextColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Checks if a User Edit was in a Free Text Column
+     * @param cellDataChangedInfo change to check
+     */
+    handleFreeTextColumnDataChange(cellDataChangedInfo) {
+        let freeTextColumn = this.getFreeTextColumnApi()
+            .getFreeTextColumns()
+            .find((fc) => fc.ColumnId == cellDataChangedInfo.column.columnId);
+        if (freeTextColumn) {
+            let freeTextStoredValue = {
+                PrimaryKey: cellDataChangedInfo.primaryKeyValue,
+                FreeText: cellDataChangedInfo.newValue,
+            };
+            this.getFreeTextColumnApi().setStoredValue(freeTextColumn.ColumnId, freeTextStoredValue);
+            var colsToRefresh = [cellDataChangedInfo.column.columnId];
+            const refencedCalcColumns = this.adaptable.api.calculatedColumnApi.internalApi.getCalculatedColumnsReferencingColumnId(cellDataChangedInfo.column.columnId);
+            refencedCalcColumns.forEach((calculatedColumn) => {
+                colsToRefresh.push(calculatedColumn.ColumnId);
+            });
+            this.adaptable.refreshCells([cellDataChangedInfo.rowNode], colsToRefresh, false);
+        }
+    }
+    /**
+     * Returns all the references in the AdaptableState of the given FreeTextColumn
+     * @param freeTextColumn FreeTextColumn to be checked
+     */
+    getFreeTextColumnModuleReferences(freeTextColumn) {
+        const references = [];
+        this.adaptable.adaptableModules.forEach((module) => {
+            if (module
+                .getModuleFreeTextColumnReferences()
+                .some((moduleReference) => moduleReference.Uuid === freeTextColumn.Uuid)) {
+                references.push(module.moduleInfo.FriendlyName);
+            }
+        });
+        return references;
+    }
+}
+exports.FreeTextColumnInternalApi = FreeTextColumnInternalApi;

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

@@ -0,0 +1,82 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { RowNode } from '@ag-grid-community/core';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
+import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
+import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
+import { EditLookUpPermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
+export declare class GridInternalApi extends ApiBase {
+    /**
+     * Fires Grid Sorted Event
+     */
+    fireGridSortedEvent(): void;
+    /**
+     * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
+     */
+    fireCellChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    /**
+     * Fires Grid Data Changed Event - when a row has changed in AG Grid
+     */
+    fireGridDataChangedEvent(dataRows: any[], rowNodes: RowNode[], rowTrigger: 'Add' | 'Edit' | 'Delete'): void;
+    /**
+     * Gets all distinct display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctDisplayValuesForColumn(columnId: string): any[];
+    /**
+     * 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
+     */
+    getDistinctFilterDisplayValuesForColumn(columnId: string, filter: string, showFilteredRowsOnly: boolean): Promise<{
+        values: {
+            value: any;
+            label: string;
+        }[];
+        suppressClientSideFilter: boolean;
+    }>;
+    /**
+     * Gets all distinct Custom Sort values for the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctCustomSortDisplayValuesForColumn(columnId: string): Promise<any[]>;
+    /**
+     * Gets all distinct Bulk Update values for the Column with the given ColumnId
+     * @param columnId Column to check
+     * @param selectedGridCells Selected grid cells
+     */
+    getDistinctBulkUpdateDisplayValuesForColumn(columnId: string, selectedGridCells: GridCell[]): Promise<any[]>;
+    /**
+     * 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: string): any[];
+    /**
+     * 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: string, skipRowNode?: RowNode): any[];
+    /**
+     * 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: string, skipRowNode?: RowNode): any[];
+    /**
+     * Gets all distinct visible raw values in the Column
+     * @param columnId Column to check
+     */
+    getDistinctVisibleRawValuesForColumn(columnId: string): any[];
+    private sortDistinctValues;
+    setColumns(columns: AdaptableColumn[]): void;
+    setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
+    setSelectedRows(selectedRowInfo: SelectedRowInfo): void;
+    setGridCell(gridCell: GridCell): void;
+    setGridCells(gridCells: GridCell[]): void;
+    private createDataChangedInfoFromGridCell;
+    buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
+    getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
+}