@adaptabletools/adaptable/src/Api/Internal/FormatColumnInternalApi.js

Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements

import { ApiBase } from '../Implementation/ApiBase';
import StringExtensions from '../../Utilities/Extensions/StringExtensions';
import FormatHelper from '../../Utilities/Helpers/DisplayFormatHelper';
import ObjectFactory from '../../Utilities/ObjectFactory';
import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
import { errorOnce } from '../../agGrid/AdaptableLogger';
import { resolveDisplayFormat } from '../../AdaptableState/Common/AdaptableFormatPresets';
function getParentGroup(source) {
    if (!source) {
        return undefined;
    }
    let current = source;
    while (current.getParent()) {
        current = current.getParent();
        if (!current) {
            return undefined;
        }
        const currentProvidedColumnGroup = current.getProvidedColumnGroup();
        if (currentProvidedColumnGroup) {
            const leafColumns = current.getLeafColumns();
            if (leafColumns.length === 1 && leafColumns[0] === source) {
                continue;
            }
            return currentProvidedColumnGroup;
        }
    }
    return undefined;
}
export class FormatColumnInternalApi extends ApiBase {
    getAllFormatColumnWithStyle(config) {
        return this.getFormatColumnApi()
            .getFormatColumns(config)
            .filter((fc) => fc.Style);
    }
    getAllFormatColumnWithDisplayFormat(config) {
        return this.getFormatColumnApi()
            .getFormatColumns(config)
            .filter((fc) => fc.DisplayFormat);
    }
    getFormatColumnsWithStyleForColumn(column, config) {
        const formatColumns = this.getAllFormatColumnWithStyle()
            .filter((formatColumn) => {
            const fcTarget = formatColumn.Target ?? 'cell';
            return fcTarget === config.target;
        })
            .filter((formatColumn) => config?.includeSuspended || !formatColumn.IsSuspended);
        return this.getFormatColumnWithColumnInScope(formatColumns, column);
    }
    getFormatColumnWithStyleClassNameForColumn(column, config) {
        return this.getFormatColumnsWithStyleForColumn(column, config).filter((formatColumn) => StringExtensions.IsNotNullOrEmpty(formatColumn?.Style?.ClassName));
    }
    getFormatColumnWithColumnInScope(formatColumns, column) {
        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.getColumnScopeApi().isColumnInScope(column, scopedFormatColumn.Scope));
    }
    getFormatColumnInColumnScope(formatColumns) {
        return formatColumns.filter((fc) => {
            return (this.getColumnScopeApi().scopeHasColumns(fc.Scope) ||
                this.getColumnScopeApi().scopeHasDataType(fc.Scope) ||
                this.getColumnScopeApi().scopeIsAll(fc.Scope) ||
                this.getColumnScopeApi().scopeHasColumnType(fc.Scope));
        });
    }
    getFormatColumnsWithDisplayFormatForColumn(column, config) {
        const formatColumns = this.getAllFormatColumnWithDisplayFormat()
            .filter((formatColumn) => {
            const fcTarget = formatColumn.Target ?? 'cell';
            return fcTarget === config.target;
        })
            .filter((formatColumn) => config?.includeSuspended || !formatColumn.IsSuspended);
        return this.getFormatColumnWithColumnInScope(formatColumns, column);
    }
    getNumberFormattedValue(value, node, column, options) {
        const preparedValue = this.applyCustomFormatters(value, node, column, options);
        return FormatHelper.NumberFormatter(preparedValue, options, node, column, this.getAdaptableApi());
    }
    getStringFormattedValue(value, node, column, options) {
        const preparedValue = this.applyCustomFormatters(value, node, column, options);
        return FormatHelper.StringFormatter(preparedValue, options, node, column, this.getAdaptableApi());
    }
    getDateFormattedValue(value, node, abColumn, options) {
        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
        const dateFormatterOptions = options;
        return dateFormatterOptions.Pattern
            ? FormatHelper.DateFormatter(preparedValue, options)
            : preparedValue;
    }
    applyCustomFormatters(value, node, abColumn, options) {
        const columnCustomFormatters = options?.CustomDisplayFormats ?? [];
        if (!columnCustomFormatters?.length) {
            return value;
        }
        const customFormattersFromOptions = this.getFormatColumnOptions()?.customDisplayFormatters ?? [];
        const customFormatters = customFormattersFromOptions.filter((customFormatterOption) => columnCustomFormatters.includes(customFormatterOption.id));
        const customDisplayFormatterContext = ObjectFactory.CreateCustomDisplayFormatterContext(value, node, abColumn, this.getAdaptableApi());
        return customFormatters.reduce((context, formatter) => {
            if (formatter && formatter.handler) {
                return formatter.handler(context);
            }
            return context.cellValue;
        }, customDisplayFormatterContext);
    }
    getFormatColumnDefsForScope(scope) {
        return this.getAdaptableApi()
            .predicateApi.internalApi.getFormatColumnPredicateDefs(scope)
            .filter((predicateDef) => this.getColumnScopeApi().isScopeInScope(scope, predicateDef.columnScope));
    }
    formatColumnWithColumnGroupScopeShouldRender(formatColumn, column) {
        if (!formatColumn.ColumnGroupScope) {
            return true;
        }
        const agGridApi = this.getAdaptableApi().agGridApi;
        const agGridColumn = this._adaptable.isInPivotMode()
            ? agGridApi.getPivotResultColumns().find((col) => col.getColId() === column.columnId)
            : agGridApi.getColumn(column.columnId);
        if (!agGridColumn) {
            return false;
        }
        const columnGroupParentForCurrentColumn = getParentGroup(agGridColumn);
        if (!columnGroupParentForCurrentColumn) {
            return false;
        }
        const columnGroupScope = columnGroupParentForCurrentColumn.isExpanded()
            ? 'Expanded'
            : 'Collapsed';
        const columnGroupLeafColumns = columnGroupParentForCurrentColumn.getLeafColumns();
        const columnIsTopLevel = columnGroupParentForCurrentColumn.getLevel() === 0 &&
            columnGroupLeafColumns.length === 1 &&
            columnGroupLeafColumns[0] === agGridColumn;
        if (columnIsTopLevel) {
            return false;
        }
        if (formatColumn.ColumnGroupScope === 'Both') {
            return true;
        }
        return formatColumn.ColumnGroupScope === columnGroupScope;
    }
    formatColumnShouldRenderInCell(formatColumn, column, rowNode, cellValue, pivotResultColumn) {
        if (formatColumn.IsSuspended) {
            return false;
        }
        const isSummaryNode = this.getGridApi().isSummaryNode(rowNode);
        const isGroupedRowNode = this.getGridApi().isGroupRowNode(rowNode);
        const isGrandTotalRowNode = this.getGridApi().isGrandTotalRowNode(rowNode);
        if (isGrandTotalRowNode) {
            if (formatColumn.RowScope?.ExcludeTotalRows) {
                return false;
            }
        }
        else if (isSummaryNode) {
            if (formatColumn.RowScope?.ExcludeSummaryRows) {
                return false;
            }
        }
        else if (isGroupedRowNode) {
            if (formatColumn.RowScope?.ExcludeGroupRows) {
                return false;
            }
        }
        else {
            if (formatColumn.RowScope?.ExcludeDataRows) {
                return false;
            }
        }
        if (formatColumn.ColumnGroupScope &&
            !this.formatColumnWithColumnGroupScopeShouldRender(formatColumn, column)) {
            return false;
        }
        if (!formatColumn.Rule) {
            return true;
        }
        if (formatColumn.Rule.Predicates && formatColumn.Rule?.Predicates?.length) {
            const predicateDefHandlerContext = {
                value: cellValue,
                oldValue: null,
                rawValue: cellValue,
                displayValue: cellValue,
                node: rowNode,
                column: column,
                ...this.getAdaptableInternalApi().buildBaseContext(),
            };
            return this.evaluatePredicate(formatColumn, predicateDefHandlerContext);
        }
        else if (formatColumn.Rule.BooleanExpression) {
            return this.evaluateExpression(formatColumn, rowNode, column, pivotResultColumn);
        }
        return false;
    }
    formatColumnShouldRenderInHeader(formatColumn, column) {
        if (formatColumn.IsSuspended) {
            return false;
        }
        if (formatColumn.ColumnGroupScope &&
            !this.getFormatColumnApi().internalApi.formatColumnWithColumnGroupScopeShouldRender(formatColumn, column)) {
            return false;
        }
        return true;
    }
    evaluatePredicate(formatColumn, predicateDefHandlerContext) {
        return this.getPredicateApi().handleColumnPredicates(formatColumn.Rule?.Predicates, predicateDefHandlerContext, false);
    }
    evaluateExpression(formatColumn, node, columnScope, pivotResultColumn) {
        const isValidExpression = this.getExpressionApi().isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
        try {
            return (isValidExpression &&
                this.getAdaptableApi()
                    .internalApi.getQueryLanguageService()
                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn, columnScope: columnScope?.columnId }));
        }
        catch (error) {
            errorOnce(error.message);
            return false;
        }
    }
    getMostRelevantFormatColumnForColumn(formatColumns, column, params) {
        return formatColumns.find((formatColumn) => this.formatColumnShouldRenderInCell(formatColumn, column, params.node, params.value));
    }
    getFormatColumnsWithExpression(config) {
        return this.getFormatColumnApi()
            .getFormatColumns(config)
            .filter((fc) => !!fc.Rule?.BooleanExpression);
    }
    getFormatColumnsDependentOnColumns(columnSet, config) {
        return this.getFormatColumnApi()
            .getFormatColumns(config)
            .filter((fc) => fc.Rule?.Predicates?.some((p) => columnSet.has(p.ColumnId)));
    }
    getFormatColumnColumnsDependentOnColumnChange(column) {
        const impactedColumnIds = new Set();
        impactedColumnIds.add(column.columnId);
        this.getCalculatedColumnApi()
            .internalApi.getCalculatedColumnsDependentOnColumn(column)
            .forEach((calculatedColumnId) => {
            impactedColumnIds.add(calculatedColumnId);
        });
        const columnsThatNeedRefresh = new Set();
        this.getFormatColumnsDependentOnColumns(impactedColumnIds).forEach((formatColumn) => {
            this.getAdaptableApi()
                .columnScopeApi.getColumnsInScope(formatColumn.Scope)
                .forEach((col) => {
                columnsThatNeedRefresh.add(col.columnId);
            });
        });
        return [...columnsThatNeedRefresh];
    }
    formatColumnHeaderName(headerName, params) {
        if (!params.column) {
            return headerName;
        }
        const abColumn = this.getColumnApi().getColumnWithColumnId(params.column.getColId());
        const activeFormatColumnsWithDisplayFormat = this.getFormatColumnApi().internalApi.getFormatColumnsWithDisplayFormatForColumn(abColumn, {
            target: 'columnHeader',
        });
        if (!activeFormatColumnsWithDisplayFormat.length) {
            return headerName;
        }
        const mostRelevantFormatColumn = activeFormatColumnsWithDisplayFormat.find((formatColumn) => this.formatColumnShouldRenderInHeader(formatColumn, abColumn));
        if (!mostRelevantFormatColumn) {
            return headerName;
        }
        const resolvedDisplayFormat = resolveDisplayFormat(mostRelevantFormatColumn.DisplayFormat);
        if (resolvedDisplayFormat?.Formatter !== 'StringFormatter') {
            return headerName;
        }
        const formattedHeaderName = this.getFormatColumnApi().internalApi.getStringFormattedValue(headerName, null, abColumn, resolvedDisplayFormat.Options);
        return formattedHeaderName;
    }
}