@talxis/base-controls 1.2510.1 → 1.2512.2

package/dist/components/Grid/grid/GridModel.js

@@ -0,0 +1,767 @@
+import { Sorting, TotalRow, Filtering, FieldValue, Grouping, DataProvider, DataTypes, Sanitizer, Type, Formatting } from '@talxis/client-libraries';
+import { merge } from 'merge-anything';
+import { Theming } from '@talxis/react-components';
+import { getTheme } from '@fluentui/react';
+import { CHECKBOX_COLUMN_KEY } from '../constants.js';
+import hotkeys from 'hotkeys-js';
+import { BaseControls } from '../../../utils/BaseControls.js';
+
+const DEFAULT_ROW_HEIGHT = 42;
+class GridModel {
+    constructor({ onGetProps, labels, theme }) {
+        this._nestedProviderPagingLimitNotificationId = null;
+        this._cachedGridColumnsMap = new Map();
+        this._getProps = onGetProps;
+        this._labels = labels;
+        this._theme = theme ?? getTheme();
+        this.oddRowCellTheme = Theming.GenerateThemeV8(this._theme.palette.themePrimary, this._theme.palette.neutralLighterAlt, this._theme.semanticColors.bodyText);
+        this.evenRowCellTheme = Theming.GenerateThemeV8(this._theme.palette.themePrimary, this._theme.palette.white, this._theme.semanticColors.bodyText);
+        const provider = this.getDataset().getDataProvider();
+        this._sorting = new Sorting(provider);
+        this._totalRow = new TotalRow(provider);
+        this._filtering = new Filtering(provider, FieldValue);
+        this._grouping = new Grouping(provider);
+        this._registerEventListeners();
+        hotkeys('*', (event, handler) => {
+        });
+    }
+    getDataset() {
+        return this._getProps().parameters.Grid;
+    }
+    getPcfContext() {
+        return this._getProps().context;
+    }
+    getState() {
+        return this._getProps().state;
+    }
+    getParameters() {
+        return this._getProps().parameters;
+    }
+    getLabels() {
+        return this._labels;
+    }
+    isZebraEnabled() {
+        return this._getProps().parameters.EnableZebra?.raw !== false;
+    }
+    isNavigationEnabled() {
+        return this.getParameters().EnableNavigation?.raw !== false;
+    }
+    isAutoSaveEnabled() {
+        return this.getParameters().EnableAutoSave?.raw === true;
+    }
+    isGroupedColumnsPinnedEnabled() {
+        return this.getParameters().EnableGroupedColumnsPinning?.raw !== false;
+    }
+    getInlineRibbonButtonIds() {
+        return this.getParameters().InlineRibbonButtonIds?.raw ?? null;
+    }
+    isEditingEnabled() {
+        return this.getParameters().EnableEditing?.raw === true;
+    }
+    getGroupType() {
+        return this.getDataset().getDataProvider().getProperty('groupingType');
+    }
+    optionSetColorsEnabled() {
+        return this.getParameters().EnableOptionSetColors?.raw === true;
+    }
+    getDefaultExpandedGroupLevel() {
+        return this.getParameters().DefaultExpandedGroupLevel?.raw ?? -1;
+    }
+    getLicenseKey() {
+        return this.getParameters().LicenseKey?.raw ?? null;
+    }
+    getDefaultRowHeight() {
+        const height = this.getParameters().RowHeight?.raw;
+        if (height) {
+            return height;
+        }
+        return DEFAULT_ROW_HEIGHT;
+    }
+    getSelectionType() {
+        switch (this.getParameters().SelectableRows?.raw) {
+            case undefined:
+            case null: {
+                return 'multiple';
+            }
+        }
+        return this.getParameters().SelectableRows.raw;
+    }
+    getControl(column, record, editing) {
+        editing = record.getSummarizationType() === 'aggregation' ? false : editing;
+        //file and image currently do not support editor, always force cell renderers
+        switch (column.dataType) {
+            case 'File':
+            case 'Image': {
+                return {
+                    name: 'GridCellRenderer',
+                    appliesTo: 'both',
+                    bindings: {}
+                };
+            }
+        }
+        const defaultControl = {
+            name: (() => {
+                if (record.getSummarizationType() === 'aggregation') {
+                    return 'GridCellRenderer';
+                }
+                if (column.name === DataProvider.CONST.RIBBON_BUTTONS_COLUMN_NAME) {
+                    return BaseControls.GridInlineRibbon;
+                }
+                if (editing) {
+                    return BaseControls.GetControlNameForDataType(column.dataType);
+                }
+                return 'GridCellRenderer';
+            })(),
+            appliesTo: 'both',
+            bindings: {}
+        };
+        const customControls = record.getColumnInfo(column.name).ui.getCustomControls([defaultControl]);
+        const appliesToValue = editing ? 'editor' : 'renderer';
+        const customControl = customControls.find(control => control.appliesTo === 'both' || control.appliesTo === appliesToValue);
+        if (customControl) {
+            return merge(defaultControl, customControl);
+        }
+        return defaultControl;
+    }
+    getBindings(record, column, control) {
+        const columnInfo = record.getColumnInfo(column.name);
+        const bindings = {
+            'value': {
+                isStatic: false,
+                type: column.dataType,
+                value: this.getControlValue(record, column),
+                formattedValue: this.getRecordFormattedValue(record, column).value,
+                error: columnInfo.error,
+                errorMessage: columnInfo.errorMessage,
+                onNotifyOutputChanged: () => { },
+                metadata: {
+                    onOverrideMetadata: () => column.metadata
+                }
+            },
+            'IsCellCustomizer': {
+                isStatic: true,
+                type: DataTypes.TwoOptions,
+                value: true
+            }
+        };
+        if (control.bindings) {
+            Object.entries(control.bindings).map(([name, binding]) => {
+                bindings[name] = {
+                    isStatic: true,
+                    type: binding.type,
+                    value: binding.value
+                };
+            });
+        }
+        return bindings;
+    }
+    getFieldBindingParameters(record, column, editing) {
+        //make sure we have IColumn, not IGridColumn
+        column = record.getDataProvider().getColumnsMap()[column.name];
+        const summarizationType = record.getDataProvider().getSummarizationType();
+        const value = this.getRecordValue(record, column);
+        const formattedValue = this.getRecordFormattedValue(record, column);
+        const aggregationColumn = record.getDataProvider().getColumnsMap()[column.aggregation?.alias];
+        const parameters = {
+            Dataset: {
+                raw: this.getDataset(),
+                type: DataTypes.Object
+            },
+            Record: {
+                raw: record,
+                type: DataTypes.Object
+            },
+            Column: {
+                raw: column,
+                type: DataTypes.Object
+            }
+        };
+        parameters.AggregatedValue = {
+            raw: value.aggregatedValue,
+            formatted: formattedValue.aggregatedValue,
+            type: aggregationColumn?.dataType ?? DataTypes.Decimal
+        };
+        parameters.EnableNavigation = {
+            raw: (() => {
+                if (!this.isNavigationEnabled()) {
+                    return false;
+                }
+                if (summarizationType === 'aggregation') {
+                    return false;
+                }
+                else if (summarizationType === 'grouping') {
+                    switch (column.dataType) {
+                        case DataTypes.LookupCustomer:
+                        case DataTypes.LookupRegarding:
+                        case DataTypes.LookupOwner:
+                        case DataTypes.LookupSimple:
+                        case DataTypes.File:
+                        case DataTypes.Image:
+                        case DataTypes.SingleLineEmail:
+                        case DataTypes.SingleLineUrl:
+                        case DataTypes.SingleLinePhone: {
+                            return true;
+                        }
+                        default: {
+                            return false;
+                        }
+                    }
+                }
+                else {
+                    return true;
+                }
+            })(),
+            type: DataTypes.TwoOptions
+        };
+        parameters.ColumnAlignment = {
+            raw: column.alignment,
+            type: DataTypes.SingleLineText
+        };
+        parameters.IsPrimaryColumn = {
+            raw: column.isPrimary,
+            type: DataTypes.TwoOptions
+        };
+        parameters.ShowErrorMessage = {
+            raw: false,
+            type: DataTypes.TwoOptions
+        };
+        parameters.CellType = {
+            raw: editing ? 'editor' : 'renderer',
+            type: DataTypes.SingleLineText
+        };
+        parameters.AutoFocus = {
+            raw: editing,
+            type: DataTypes.TwoOptions
+        };
+        parameters.AggregationFunction = {
+            raw: summarizationType === 'aggregation' ? aggregationColumn?.aggregation?.aggregationFunction : null,
+            type: DataTypes.SingleLineText
+        };
+        parameters.PrefixIcon = {
+            raw: null,
+            type: DataTypes.SingleLineText
+        };
+        parameters.SuffixIcon = {
+            raw: null,
+            type: DataTypes.SingleLineText
+        };
+        parameters.IsInlineNewEnabled = {
+            raw: false,
+            type: DataTypes.TwoOptions
+        };
+        parameters.EnableTypeSuffix = {
+            raw: false,
+            type: DataTypes.TwoOptions
+        };
+        parameters.EnableOptionSetColors = {
+            raw: this.optionSetColorsEnabled(),
+            type: DataTypes.TwoOptions
+        };
+        parameters.CommandButtonIds = {
+            raw: this.getInlineRibbonButtonIds(),
+            type: DataTypes.SingleLineText
+        };
+        parameters.ShouldUnmountWhenOutputChanges = {
+            raw: (() => {
+                //by default, leave cell editor opened for these types since
+                // they can output partial changes as values
+                switch (column.dataType) {
+                    case 'DateAndTime.DateAndTime':
+                    case 'MultiSelectPicklist': {
+                        return false;
+                    }
+                    default: {
+                        return true;
+                    }
+                }
+            })(),
+            type: DataTypes.TwoOptions
+        };
+        return parameters;
+    }
+    isColumnExpandable(record, column) {
+        const groupBy = record.getDataProvider().grouping.getGroupBys()[0];
+        return groupBy?.columnName === column.name;
+    }
+    getFieldFormatting(record, columnName) {
+        const defaultTheme = this.getDefaultCellTheme(record);
+        const defaultBackgroundColor = defaultTheme.semanticColors.bodyBackground;
+        // Handle checkbox column specifically
+        if (columnName === CHECKBOX_COLUMN_KEY || !record) {
+            return {
+                primaryColor: this._theme.palette.themePrimary,
+                backgroundColor: defaultBackgroundColor,
+                textColor: Theming.GetTextColorForBackground(defaultBackgroundColor),
+                className: '',
+                themeOverride: {}
+            };
+        }
+        const customFormatting = record.getColumnInfo(columnName).ui.getCustomFormatting(defaultTheme) ?? {};
+        // Prepare the result with defaults
+        const result = {
+            backgroundColor: customFormatting.backgroundColor ?? defaultBackgroundColor,
+            primaryColor: customFormatting.primaryColor ?? this._theme.palette.themePrimary,
+            textColor: customFormatting.textColor ?? '',
+            className: customFormatting.className ?? '',
+            themeOverride: customFormatting.themeOverride ?? {}
+        };
+        // Apply background-specific adjustments
+        if (result.backgroundColor !== defaultBackgroundColor) {
+            result.themeOverride = merge({}, {
+                fonts: {
+                    medium: {
+                        fontWeight: 600
+                    }
+                }
+            }, result.themeOverride);
+            if (!customFormatting.primaryColor) {
+                result.primaryColor = Theming.GetTextColorForBackground(result.backgroundColor);
+            }
+        }
+        // Ensure text color is set
+        if (!result.textColor) {
+            result.textColor = Theming.GetTextColorForBackground(result.backgroundColor);
+        }
+        return result;
+    }
+    getDefaultCellTheme(record) {
+        const isEven = record.getIndex() % 2 === 0;
+        const summarizationType = record.getDataProvider().getSummarizationType();
+        if (summarizationType !== 'none') {
+            return this.oddRowCellTheme;
+        }
+        //child of a group record
+        else if (record.getDataProvider().getParentDataProvider()) {
+            return this.evenRowCellTheme;
+        }
+        else if (isEven || !this.isZebraEnabled()) {
+            return this.evenRowCellTheme;
+        }
+        else {
+            return this.oddRowCellTheme;
+        }
+    }
+    getGridColumns() {
+        this._cachedGridColumnsMap.clear();
+        const gridColumns = this.getDataset().columns.map(column => {
+            const gridColumn = this.getGridColumnByName(column.name, true);
+            this._cachedGridColumnsMap.set(gridColumn.name, gridColumn);
+            return gridColumn;
+        });
+        return gridColumns;
+    }
+    getColumnByName(columnName) {
+        return this.getDataset().getDataProvider().getColumnsMap()[columnName];
+    }
+    getGridColumnByName(columnName, force) {
+        if (!force) {
+            const column = this._cachedGridColumnsMap.get(columnName);
+            if (!column) {
+                throw new Error(`Column with name ${columnName} not found in grid columns cache.`);
+            }
+            return column;
+        }
+        else {
+            const column = this.getDataset().getColumnsMap()[columnName];
+            const sorted = this.getDataset().sorting?.find(sort => sort.name === column.name);
+            return {
+                ...column,
+                alignment: column.alignment,
+                isFiltered: this._filtering.getColumnFilter(column.name).isAppliedToDataset(),
+                isEditable: this._isColumnEditable(column),
+                isRequired: this._isColumnRequired(column),
+                canBeGrouped: this._isColumnGroupable(column),
+                isFilterable: this._isColumnFilterable(column),
+                disableSorting: !this._isColumnSortable(column),
+                canBeAggregated: this._canColumnBeAggregated(column),
+                isSortedDescending: sorted?.sortDirection === 1 ? true : false,
+                isResizable: true,
+                isSorted: sorted ? true : false
+            };
+        }
+    }
+    getRecordValue(record, column) {
+        return this._getRecordValue(record, column, false);
+    }
+    getRecordFormattedValue(record, column) {
+        return this._getRecordValue(record, column, true);
+    }
+    //returns record value in a form that is compatible with PCF typings
+    getControlValue(record, column) {
+        const columnName = typeof column === 'string' ? column : column.name;
+        column = record.getDataProvider().getColumnsMap()[columnName];
+        //can be the aggregated value
+        let value = this.getRecordValue(record, column).value;
+        switch (column.dataType) {
+            //getValue always returns string for TwoOptions
+            case 'TwoOptions': {
+                if (typeof value === 'string') {
+                    value = value == '1' ? true : false;
+                }
+                break;
+            }
+            //getValue always returns string for OptionSet
+            case 'OptionSet': {
+                value = value ? parseInt(value) : null;
+                break;
+            }
+            case 'MultiSelectPicklist': {
+                value = value ? value.split(',').map((x) => parseInt(x)) : null;
+                break;
+            }
+            case 'Lookup.Simple':
+            case 'Lookup.Customer':
+            case 'Lookup.Owner':
+            case 'Lookup.Regarding': {
+                //our implementation returns array, Power Apps returns object
+                if (value && !Array.isArray(value)) {
+                    value = [value];
+                }
+                value = value?.map((x) => Sanitizer.Lookup.getLookupValue(x));
+                break;
+            }
+        }
+        return value;
+    }
+    isRecordSelectionDisabled(record) {
+        const dataProvider = record.getDataProvider();
+        const level = dataProvider.getNestingLevel();
+        const groupBys = this.getDataset().grouping.getGroupBys();
+        if (this.getGroupType() === 'nested' && level < groupBys.length - 1) {
+            return true;
+        }
+        if (dataProvider.getSummarizationType() === 'grouping' && this.getSelectionType() === 'single') {
+            return true;
+        }
+        return false;
+    }
+    isColumnEditable(columnName, record) {
+        let isEditable = true;
+        const mainDatasetColumn = this.getDataset().getDataProvider().getColumnsMap()[columnName];
+        let column = mainDatasetColumn;
+        if (record) {
+            column = record.getDataProvider().getColumnsMap()[columnName];
+        }
+        switch (true) {
+            case !this.isEditingEnabled():
+            case record?.isSaving():
+            case column.oneClickEdit: {
+                isEditable = false;
+                break;
+            }
+        }
+        switch (column.name) {
+            case DataProvider.CONST.CHECKBOX_COLUMN_KEY:
+            case DataProvider.CONST.RIBBON_BUTTONS_COLUMN_NAME: {
+                isEditable = false;
+                break;
+            }
+        }
+        //these field types do not support editing
+        switch (column.dataType) {
+            case DataTypes.File:
+            case DataTypes.Image: {
+                isEditable = false;
+                break;
+            }
+        }
+        //if the column is not editable, return false
+        if (!isEditable) {
+            return false;
+        }
+        else {
+            //columns is editable and we are not asking for record
+            if (!record) {
+                return true;
+            }
+            //column is editable, but we need to check if the record is editable
+            else
+                return this._isRecordFieldEditable(record, column);
+        }
+    }
+    addAggregation(columnName, aggregationFunction) {
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._setAggregationDecorator(() => {
+                this._totalRow.addAggregation(columnName, aggregationFunction);
+            });
+        });
+    }
+    removeAggregation(alias) {
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._setAggregationDecorator(() => {
+                this._totalRow.removeAggregation(alias);
+            });
+        });
+    }
+    toggleColumnGroup(columnName) {
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            const column = this.getDataset().getDataProvider().getColumnsMap()[columnName];
+            if (column.grouping?.isGrouped) {
+                this._grouping.ungroupColumn(column.grouping.alias);
+            }
+            else {
+                this._grouping.groupColumn(column.name);
+            }
+            this._dataset.refresh();
+        });
+    }
+    getColumnFilter(columnName) {
+        return this._filtering.getColumnFilter(columnName);
+    }
+    removeColumnFilter(columnName, saveToDataset) {
+        this._filtering.removeColumnFilter(columnName);
+        if (!saveToDataset) {
+            return;
+        }
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            const filterExpression = this._filtering.getFilterExpression(Type.And.Value);
+            if (!filterExpression) {
+                throw new Error('Unexpected error when clearing column filter.');
+            }
+            this._dataset.filtering.setFilter(filterExpression);
+            this._dataset.refresh();
+        });
+    }
+    sortColumn(columnName, descending) {
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._sorting.getColumnSorting(columnName).setSortValue(descending ? 1 : 0, hotkeys.getPressedKeyString().includes('⇧'));
+            this._dataset.refresh();
+        });
+    }
+    clearColumnSorting(columnName) {
+        this._getInternalDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._sorting.getColumnSorting(columnName).clear();
+            this._dataset.refresh();
+        });
+    }
+    getTotalRow() {
+        return this._totalRow;
+    }
+    getFiltering() {
+        return this._filtering;
+    }
+    isSelectionModifierKeyPressed() {
+        const pressedKeys = hotkeys.getPressedKeyString().join(',');
+        switch (true) {
+            case pressedKeys.includes('⇧'):
+            case pressedKeys.includes('ctrl'):
+            case pressedKeys.includes('⌘'): {
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    getColumnSortingLabel(columnName, descending) {
+        const column = this.getDataset().getDataProvider().getColumnsMap()[columnName];
+        switch (column.dataType) {
+            case DataTypes.WholeNone:
+            case DataTypes.Decimal:
+            case DataTypes.WholeDuration:
+            case DataTypes.Currency: {
+                if (!descending) {
+                    return this._labels['filtersortmenu-sortnumber-a-z']();
+                }
+                return this._labels['filtersortmenu-sortnumber-z-a']();
+            }
+            case DataTypes.DateAndTimeDateAndTime:
+            case DataTypes.DateAndTimeDateOnly: {
+                if (!descending) {
+                    return this._labels['filtersortmenu-sortdate-a-z']();
+                }
+                return this._labels['filtersortmenu-sortdate-z-a']();
+            }
+            case DataTypes.TwoOptions: {
+                const options = column.metadata?.OptionSet ?? [];
+                if (!descending) {
+                    return `${options[0].Label} ${this._labels['filtersortmenu-sorttwooption-joint']()} ${options[1].Label}`;
+                }
+                return `${options[1].Label} ${this._labels['filtersortmenu-sorttwooption-joint']()} ${options[0].Label}`;
+            }
+            default: {
+                if (!descending) {
+                    return this._labels['filtersortmenu-sorttext-a-z']();
+                }
+                return this._labels['filtersortmenu-sorttext-z-a']();
+            }
+        }
+    }
+    destroy() {
+        if (this._nestedProviderPagingLimitNotificationId) {
+            window.Xrm.App.clearGlobalNotification(this._nestedProviderPagingLimitNotificationId);
+        }
+        hotkeys.unbind();
+    }
+    _getInternalDataProvider() {
+        return this.getDataset().getDataProvider();
+    }
+    _setAggregationDecorator(fn) {
+        fn();
+        if (this._dataset.grouping.getGroupBys().length > 0) {
+            this._dataset.refresh();
+        }
+        else {
+            this._totalRow?.refresh();
+        }
+    }
+    _getRecordValue(record, column, formatted) {
+        if (!record) {
+            return {
+                value: null,
+                aggregatedValue: null
+            };
+        }
+        const columnName = typeof column === 'string' ? column : column.name;
+        column = record.getDataProvider().getColumnsMap()[columnName];
+        if (!column) {
+            return {
+                value: null,
+                aggregatedValue: null
+            };
+        }
+        const method = formatted ? 'getFormattedValue' : 'getValue';
+        const groupBy = record.getDataProvider().grouping.getGroupBy(column.grouping?.alias);
+        const aggregation = record.getDataProvider().aggregation.getAggregation(column.aggregation?.alias);
+        let value = record[method](columnName);
+        let aggregatedValue = null;
+        if (groupBy) {
+            value = record[method](groupBy.alias);
+        }
+        if (aggregation) {
+            aggregatedValue = record[method](aggregation.alias);
+        }
+        return {
+            value: value,
+            aggregatedValue: aggregatedValue
+        };
+    }
+    _isRecordFieldEditable(record, column) {
+        const columnInfo = record.getColumnInfo(column.name);
+        //if editable not defined, return true since column is editable in this case
+        return columnInfo?.security.editable ?? true;
+    }
+    _isColumnRequired(column) {
+        if (!this.getParameters().EnableEditing?.raw) {
+            return false;
+        }
+        switch (column.metadata?.RequiredLevel) {
+            case 1:
+            case 2: {
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+    _isColumnSortable(column) {
+        //sorting enabled by default
+        if (this.getParameters().EnableSorting?.raw === false) {
+            return false;
+        }
+        return !column.disableSorting;
+    }
+    _isColumnFilterable(column) {
+        //filtering enabled by default
+        if (this.getParameters().EnableFiltering?.raw === false) {
+            return false;
+        }
+        if (!column.metadata?.SupportedFilterConditionOperators || column.metadata.SupportedFilterConditionOperators.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    _isColumnGroupable(column) {
+        //grouping disabled by default
+        if (this.getParameters().EnableGrouping?.raw !== true) {
+            return false;
+        }
+        return !!column.metadata?.CanBeGrouped;
+    }
+    _isColumnEditable(column) {
+        //editing disabled by default
+        if (this.getParameters().EnableEditing?.raw !== true) {
+            return false;
+        }
+        return !!column.metadata?.IsValidForUpdate;
+    }
+    _canColumnBeAggregated(column) {
+        //aggregations disabled by default
+        if (this.getParameters().EnableAggregation?.raw !== true) {
+            return false;
+        }
+        if (!column.metadata?.SupportedAggregations || column.metadata.SupportedAggregations.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    _registerEventListeners() {
+        this._dataset.addEventListener('onRecordColumnValueChanged', (record) => this._autoSaveRecord(record));
+        this._dataset.addEventListener('onAfterRecordSaved', () => this._refreshTotalRowOnAutoSave());
+        this._dataset.addEventListener('onAfterSaved', () => this._totalRow.refresh());
+        this._dataset.addEventListener('onNestedProviderPagingLimitReached', () => this._showNestedProviderPagingLimitNotification());
+        this._setGroupingInterceptor();
+    }
+    //TODO: use control notification instead
+    async _showNestedProviderPagingLimitNotification() {
+        if (!this._nestedProviderPagingLimitNotificationId) {
+            this._nestedProviderPagingLimitNotificationId = await window.Xrm.App.addGlobalNotification({
+                level: 4,
+                message: this.getLabels()['maximumGroupChildrenLimitReached']({ maxGroupChildren: Formatting.Get().formatInteger(5000) }),
+                type: 2
+            });
+        }
+    }
+    _autoSaveRecord(record) {
+        if (this.isAutoSaveEnabled() && record.isDirty()) {
+            record.save();
+        }
+    }
+    _refreshTotalRowOnAutoSave() {
+        if (this.isAutoSaveEnabled()) {
+            this._totalRow.refresh();
+        }
+    }
+    //this method makes sure that the grouping is only applied to the first grouping column
+    //this allows for nested grouping to work correctly
+    _setGroupingInterceptor() {
+        if (this.getGroupType() === 'flat') {
+            return;
+        }
+        let originalSortedGrouping = [];
+        let originalAggregation = [];
+        this._dataset.addEventListener('onBeforeNewDataLoaded', () => {
+            originalSortedGrouping = this._dataset.grouping.getGroupBys().sort((a, b) => {
+                const colA = this._dataset.getDataProvider().getColumnsMap()[a.columnName];
+                const colB = this._dataset.getDataProvider().getColumnsMap()[b.columnName];
+                return colA.order - colB.order;
+            });
+            originalAggregation = this._dataset.aggregation.getAggregations();
+            if (originalSortedGrouping.length > 1) {
+                this._dataset.grouping.clear();
+                const groupBy = originalSortedGrouping[0];
+                this._dataset.grouping.addGroupBy(groupBy);
+                //clear all grouping aggregations except the first one
+                for (let i = 1; i < originalSortedGrouping.length; i++) {
+                    const column = this._dataset.getDataProvider().getColumnsMap()[originalSortedGrouping[i].columnName];
+                    this._dataset.aggregation.removeAggregation(column?.aggregation?.alias);
+                }
+            }
+        });
+        this._dataset.addEventListener('onNewDataLoaded', () => {
+            originalSortedGrouping.map((group) => {
+                this._dataset.grouping.addGroupBy(group);
+            });
+            originalAggregation.map((aggr) => {
+                this._dataset.aggregation.addAggregation(aggr);
+            });
+        });
+    }
+    get _dataset() {
+        return this.getDataset();
+    }
+}
+
+export { GridModel };
+//# sourceMappingURL=GridModel.js.map