@talxis/base-controls 1.2508.1 → 1.2509.1-alpha.0

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

@@ -0,0 +1,787 @@
+import { Sorting, TotalRow, Filtering, FieldValue, Grouping, DataTypes, Sanitizer, DataProvider, Type } from '@talxis/client-libraries';
+import { merge } from 'merge-anything';
+import { Theming } from '@talxis/react-components';
+import { getTheme } from '@fluentui/react';
+import deepEqual from 'fast-deep-equal';
+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._cachedColumns = [];
+        this._cachedColumnsMap = new Map();
+        this._hasFirstDataBeenLoaded = false;
+        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);
+        this._registerEventListeners();
+        hotkeys('*', (event, handler) => {
+        });
+    }
+    init() {
+        if (this._hasFirstDataBeenLoaded) {
+            return;
+        }
+        this._hasFirstDataBeenLoaded = true;
+        this.__sorting = new Sorting(() => this.getDataset().getDataProvider());
+        this.__totalRow = new TotalRow({
+            onGetDataProvider: () => this.getDataset().getDataProvider(),
+        });
+        this.__filtering = new Filtering(() => this.getDataset().getDataProvider(), FieldValue);
+        this.__grouping = new Grouping(() => this.getDataset().getDataProvider());
+    }
+    getDataset() {
+        return this._getProps().parameters.Grid;
+    }
+    getPcfContext() {
+        return this._getProps().context;
+    }
+    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;
+    }
+    isEditingEnabled() {
+        return this.getParameters().EnableEditing?.raw === true;
+    }
+    getGroupType() {
+        return this.getParameters().GroupType?.raw ?? 'nested';
+    }
+    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: editing ? BaseControls.GetControlNameForDataType(column.dataType) : '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, recordCommands) {
+        //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.RecordCommands = {
+            raw: recordCommands ?? [],
+            type: DataTypes.Object
+        };
+        parameters.IsInlineNewEnabled = {
+            raw: false,
+            type: DataTypes.TwoOptions
+        };
+        parameters.EnableTypeSuffix = {
+            raw: false,
+            type: DataTypes.TwoOptions
+        };
+        parameters.EnableOptionSetColors = {
+            raw: this.optionSetColorsEnabled(),
+            type: DataTypes.TwoOptions
+        };
+        parameters.ShouldStopEditWhenOutputChanges = {
+            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, columnName);
+        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, columnName) {
+        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() {
+        return this._cachedColumns;
+    }
+    getGridColumnByName(columnName) {
+        return this._cachedColumnsMap.get(columnName);
+    }
+    refreshGridColumns() {
+        if (!this._hasFirstDataBeenLoaded) {
+            return {
+                haveColumnsOrderBeenUpdated: false,
+                columns: []
+            };
+        }
+        const gridColumns = this._getGridColumnsFromDataset();
+        const gridColumnNames = this._getVisibleColumnNames(gridColumns);
+        const cachedGridColumnNames = this._getVisibleColumnNames(this._cachedColumns);
+        if (!deepEqual(gridColumnNames, cachedGridColumnNames)) {
+            this._cachedColumns = gridColumns;
+            return {
+                haveColumnsOrderBeenUpdated: true,
+                columns: gridColumns
+            };
+        }
+        else {
+            this._cachedColumns = gridColumns;
+            return {
+                haveColumnsOrderBeenUpdated: false,
+                columns: this._cachedColumns
+            };
+        }
+    }
+    getColumnByName(columnName) {
+        return this.getDataset().getDataProvider().getColumnsMap()[columnName];
+    }
+    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._dataset.getDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._setAggregationDecorator(() => {
+                this._totalRow.addAggregation(columnName, aggregationFunction);
+            });
+        });
+    }
+    removeAggregation(alias) {
+        this._dataset.getDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._setAggregationDecorator(() => {
+                this._totalRow.removeAggregation(alias);
+            });
+        });
+    }
+    toggleColumnGroup(columnName) {
+        this._dataset.getDataProvider().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._dataset.getDataProvider().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._dataset.getDataProvider().executeWithUnsavedChangesBlocker(() => {
+            this._sorting.getColumnSorting(columnName).setSortValue(descending ? 1 : 0, hotkeys.getPressedKeyString().includes('⇧'));
+            this._dataset.refresh();
+        });
+    }
+    clearColumnSorting(columnName) {
+        this._dataset.getDataProvider().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() {
+        hotkeys.unbind();
+    }
+    _getVisibleColumnNames(columns) {
+        const names = [];
+        for (const column of columns) {
+            if (!column.isHidden) {
+                //we also need to push the group state
+                //to force ag grid to set new columns when grouping
+                names.push(`${column.name}_${column.grouping?.isGrouped}`);
+            }
+        }
+        return names;
+    }
+    _setAggregationDecorator(fn) {
+        fn();
+        if (this._dataset.grouping.getGroupBys().length > 0) {
+            this._dataset.refresh();
+        }
+        else {
+            this._totalRow?.refresh();
+            this._dataset.render();
+        }
+    }
+    _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
+        };
+    }
+    _getGridColumnsFromDataset() {
+        const gridColumns = this.getDataset().columns.map(column => {
+            const sorted = this.getDataset().sorting?.find(sort => sort.name === column.name);
+            const gridColumn = {
+                ...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
+            };
+            this._cachedColumnsMap.set(column.name, gridColumn);
+            return gridColumn;
+        });
+        return gridColumns;
+    }
+    _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('onInitialDataLoaded', () => this.init());
+        this._dataset.addEventListener('onRecordColumnValueChanged', (record) => this._autoSaveRecord(record));
+        this._setGroupingInterceptor();
+    }
+    _autoSaveRecord(record) {
+        if (this.isAutoSaveEnabled() && record.isDirty()) {
+            record.save();
+        }
+    }
+    //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 originalGrouping = [];
+        let originalAggregation = [];
+        this._dataset.addEventListener('onBeforeNewDataLoaded', () => {
+            originalGrouping = this._dataset.grouping.getGroupBys();
+            originalAggregation = this._dataset.aggregation.getAggregations();
+            if (originalGrouping.length > 1) {
+                this._dataset.grouping.clear();
+                const groupBy = originalGrouping[0];
+                const column = this._dataset.getDataProvider().getColumnsMap()[groupBy.columnName];
+                this._dataset.grouping.addGroupBy(originalGrouping[0], column.order);
+                //clear all grouping aggregations except the first one
+                for (let i = 1; i < originalGrouping.length; i++) {
+                    const column = this._dataset.getDataProvider().getColumnsMap()[originalGrouping[i].columnName];
+                    this._dataset.aggregation.removeAggregation(column?.aggregation?.alias);
+                }
+            }
+        });
+        this._dataset.addEventListener('onNewDataLoaded', () => {
+            originalGrouping.map((group) => {
+                const column = this._dataset.getDataProvider().getColumnsMap()[group.columnName];
+                this._dataset.grouping.addGroupBy(group, column.order);
+            });
+            originalAggregation.map((aggr) => {
+                this._dataset.aggregation.addAggregation(aggr);
+            });
+        });
+    }
+    get _dataset() {
+        return this.getDataset();
+    }
+    get _sorting() {
+        if (!this.__sorting) {
+            throw new Error('Sorting is not initialized. Call init() method first.');
+        }
+        return this.__sorting;
+    }
+    get _filtering() {
+        if (!this.__filtering) {
+            throw new Error('Filtering is not initialized. Call init() method first.');
+        }
+        return this.__filtering;
+    }
+    get _totalRow() {
+        if (!this.__totalRow) {
+            throw new Error('Aggregation is not initialized. Call init() method first.');
+        }
+        return this.__totalRow;
+    }
+    get _grouping() {
+        if (!this.__grouping) {
+            throw new Error('Grouping is not initialized. Call init() method first.');
+        }
+        return this.__grouping;
+    }
+}
+
+export { GridModel };
+//# sourceMappingURL=GridModel.js.map