@mui/x-data-grid-premium 5.11.0

package/node/hooks/features/rowGrouping/createGroupingColDef.js

@@ -0,0 +1,341 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGroupingColDefForOneGroupingCriteria = exports.createGroupingColDefForAllGroupingCriteria = void 0;
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+var _GridGroupingCriteriaCell = require("../../../components/GridGroupingCriteriaCell");
+
+var _GridGroupingColumnLeafCell = require("../../../components/GridGroupingColumnLeafCell");
+
+var _gridRowGroupingUtils = require("./gridRowGroupingUtils");
+
+var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["leafField", "mainGroupingCriteria", "hideDescendantCount"],
+      _excluded2 = ["leafField", "mainGroupingCriteria", "hideDescendantCount"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const GROUPING_COL_DEF_DEFAULT_PROPERTIES = (0, _extends2.default)({}, _xDataGridPro.GRID_STRING_COL_DEF, {
+  disableReorder: true
+});
+const GROUPING_COL_DEF_FORCED_PROPERTIES = {
+  type: 'rowGroupByColumnsGroup',
+  editable: false,
+  groupable: false
+};
+/**
+ * When sorting two cells with different grouping criteria, we consider that the cell with the grouping criteria coming first in the model should be displayed below.
+ * This can occur when some rows don't have all the fields. In which case we want the rows with the missing field to be displayed above.
+ * TODO: Make this index comparator depth invariant, the logic should not be inverted when sorting in the "desc" direction (but the current return format of `sortComparator` does not support this behavior).
+ */
+
+const groupingFieldIndexComparator = (v1, v2, cellParams1, cellParams2) => {
+  const model = (0, _gridRowGroupingSelector.gridRowGroupingSanitizedModelSelector)(cellParams1.api.state, cellParams1.api.instanceId);
+  const groupingField1 = cellParams1.rowNode.groupingField;
+  const groupingField2 = cellParams2.rowNode.groupingField;
+
+  if (groupingField1 === groupingField2) {
+    return 0;
+  }
+
+  if (groupingField1 == null) {
+    return -1;
+  }
+
+  if (groupingField2 == null) {
+    return 1;
+  }
+
+  if (model.indexOf(groupingField1) < model.indexOf(groupingField2)) {
+    return -1;
+  }
+
+  return 1;
+};
+
+const getLeafProperties = leafColDef => {
+  var _leafColDef$headerNam, _leafColDef$filterOpe;
+
+  return {
+    headerName: (_leafColDef$headerNam = leafColDef.headerName) != null ? _leafColDef$headerNam : leafColDef.field,
+    sortable: leafColDef.sortable,
+    filterable: leafColDef.filterable,
+    filterOperators: (_leafColDef$filterOpe = leafColDef.filterOperators) == null ? void 0 : _leafColDef$filterOpe.map(operator => (0, _extends2.default)({}, operator, {
+      getApplyFilterFn: (filterItem, column) => {
+        const originalFn = operator.getApplyFilterFn(filterItem, column);
+
+        if (!originalFn) {
+          return null;
+        }
+
+        return params => {
+          // We only want to filter leaves
+          if (params.rowNode.groupingField != null) {
+            return true;
+          }
+
+          return originalFn(params);
+        };
+      }
+    })),
+    sortComparator: (v1, v2, cellParams1, cellParams2) => {
+      // We only want to sort the leaves
+      if (cellParams1.rowNode.groupingField === null && cellParams2.rowNode.groupingField === null) {
+        return leafColDef.sortComparator(v1, v2, cellParams1, cellParams2);
+      }
+
+      return groupingFieldIndexComparator(v1, v2, cellParams1, cellParams2);
+    }
+  };
+};
+
+const getGroupingCriteriaProperties = (groupedByColDef, applyHeaderName) => {
+  var _groupedByColDef$filt;
+
+  const properties = {
+    sortable: groupedByColDef.sortable,
+    filterable: groupedByColDef.filterable,
+    sortComparator: (v1, v2, cellParams1, cellParams2) => {
+      // We only want to sort the groups of the current grouping criteria
+      if (cellParams1.rowNode.groupingField === groupedByColDef.field && cellParams2.rowNode.groupingField === groupedByColDef.field) {
+        return groupedByColDef.sortComparator(v1, v2, cellParams1, cellParams2);
+      }
+
+      return groupingFieldIndexComparator(v1, v2, cellParams1, cellParams2);
+    },
+    filterOperators: (_groupedByColDef$filt = groupedByColDef.filterOperators) == null ? void 0 : _groupedByColDef$filt.map(operator => (0, _extends2.default)({}, operator, {
+      getApplyFilterFn: (filterItem, column) => {
+        const originalFn = operator.getApplyFilterFn(filterItem, column);
+
+        if (!originalFn) {
+          return null;
+        }
+
+        return params => {
+          // We only want to filter the groups of the current grouping criteria
+          if (params.rowNode.groupingField !== groupedByColDef.field) {
+            return true;
+          }
+
+          return originalFn(params);
+        };
+      }
+    }))
+  };
+
+  if (applyHeaderName) {
+    var _groupedByColDef$head;
+
+    properties.headerName = (_groupedByColDef$head = groupedByColDef.headerName) != null ? _groupedByColDef$head : groupedByColDef.field;
+  }
+
+  return properties;
+};
+
+/**
+ * Creates the `GridColDef` for a grouping column that only takes care of a single grouping criteria
+ */
+const createGroupingColDefForOneGroupingCriteria = ({
+  columnsLookup,
+  groupedByColDef,
+  groupingCriteria,
+  colDefOverride
+}) => {
+  var _groupedByColDef$widt, _leafColDef$width;
+
+  const _ref = colDefOverride != null ? colDefOverride : {},
+        {
+    leafField,
+    mainGroupingCriteria,
+    hideDescendantCount
+  } = _ref,
+        colDefOverrideProperties = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+
+  const leafColDef = leafField ? columnsLookup[leafField] : null; // The properties that do not depend on the presence of a `leafColDef` and that can be overridden by `colDefOverride`
+
+  const commonProperties = {
+    width: Math.max(((_groupedByColDef$widt = groupedByColDef.width) != null ? _groupedByColDef$widt : _xDataGridPro.GRID_STRING_COL_DEF.width) + 40, (_leafColDef$width = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width : 0),
+    renderCell: params => {
+      // Render leaves
+      if (params.rowNode.groupingField == null) {
+        if (leafColDef) {
+          const leafParams = (0, _extends2.default)({}, params.api.getCellParams(params.id, leafField), {
+            api: params.api
+          });
+
+          if (leafColDef.renderCell) {
+            return leafColDef.renderCell(leafParams);
+          }
+
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingColumnLeafCell.GridGroupingColumnLeafCell, (0, _extends2.default)({}, leafParams));
+        }
+
+        return '';
+      } // Render current grouping criteria groups
+
+
+      if (params.rowNode.groupingField === groupingCriteria) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingCriteriaCell.GridGroupingCriteriaCell, (0, _extends2.default)({}, params, {
+          hideDescendantCount: hideDescendantCount
+        }));
+      }
+
+      return '';
+    },
+    valueGetter: params => {
+      if (!params.rowNode) {
+        return undefined;
+      }
+
+      if (params.rowNode.groupingField == null) {
+        if (leafColDef) {
+          return params.api.getCellValue(params.id, leafField);
+        }
+
+        return undefined;
+      }
+
+      if (params.rowNode.groupingField === groupingCriteria) {
+        return params.rowNode.groupingKey;
+      }
+
+      return undefined;
+    }
+  }; // If we have a `mainGroupingCriteria` defined and matching the `groupingCriteria`
+  // Then we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `groupedByColDef`.
+  // It can be useful to define a `leafField` for leaves rendering but still use the grouping criteria for the sorting / filtering
+  //
+  // If we have a `leafField` defined and matching an existing column
+  // Then we apply the sorting / filtering on the leaves based on the properties of `leavesColDef`
+  //
+  // By default, we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `groupedColDef`.
+
+  let sourceProperties;
+
+  if (mainGroupingCriteria && mainGroupingCriteria === groupingCriteria) {
+    sourceProperties = getGroupingCriteriaProperties(groupedByColDef, true);
+  } else if (leafColDef) {
+    sourceProperties = getLeafProperties(leafColDef);
+  } else {
+    sourceProperties = getGroupingCriteriaProperties(groupedByColDef, true);
+  } // The properties that can't be overridden with `colDefOverride`
+
+
+  const forcedProperties = (0, _extends2.default)({
+    field: (0, _gridRowGroupingUtils.getRowGroupingFieldFromGroupingCriteria)(groupingCriteria)
+  }, GROUPING_COL_DEF_FORCED_PROPERTIES);
+  return (0, _extends2.default)({}, GROUPING_COL_DEF_DEFAULT_PROPERTIES, commonProperties, sourceProperties, colDefOverrideProperties, forcedProperties);
+};
+
+exports.createGroupingColDefForOneGroupingCriteria = createGroupingColDefForOneGroupingCriteria;
+
+/**
+ * Creates the `GridColDef` for a grouping column that takes care of all the grouping criteria
+ */
+const createGroupingColDefForAllGroupingCriteria = ({
+  apiRef,
+  columnsLookup,
+  rowGroupingModel,
+  colDefOverride
+}) => {
+  var _leafColDef$width2;
+
+  const _ref2 = colDefOverride != null ? colDefOverride : {},
+        {
+    leafField,
+    mainGroupingCriteria,
+    hideDescendantCount
+  } = _ref2,
+        colDefOverrideProperties = (0, _objectWithoutPropertiesLoose2.default)(_ref2, _excluded2);
+
+  const leafColDef = leafField ? columnsLookup[leafField] : null; // The properties that do not depend on the presence of a `leafColDef` and that can be overridden by `colDefOverride`
+
+  const commonProperties = {
+    headerName: apiRef.current.getLocaleText('groupingColumnHeaderName'),
+    width: Math.max(...rowGroupingModel.map(field => {
+      var _columnsLookup$field$;
+
+      return ((_columnsLookup$field$ = columnsLookup[field].width) != null ? _columnsLookup$field$ : _xDataGridPro.GRID_STRING_COL_DEF.width) + 40;
+    }), (_leafColDef$width2 = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width2 : 0),
+    renderCell: params => {
+      // Render the leaves
+      if (params.rowNode.groupingField == null) {
+        if (leafColDef) {
+          const leafParams = (0, _extends2.default)({}, params.api.getCellParams(params.id, leafField), {
+            api: params.api
+          });
+
+          if (leafColDef.renderCell) {
+            return leafColDef.renderCell(leafParams);
+          }
+
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingColumnLeafCell.GridGroupingColumnLeafCell, (0, _extends2.default)({}, leafParams));
+        }
+
+        return '';
+      } // Render the groups
+
+
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridGroupingCriteriaCell.GridGroupingCriteriaCell, (0, _extends2.default)({}, params, {
+        hideDescendantCount: hideDescendantCount
+      }));
+    },
+    valueGetter: params => {
+      if (!params.rowNode) {
+        return undefined;
+      }
+
+      if (params.rowNode.groupingField == null) {
+        if (leafColDef) {
+          return params.api.getCellValue(params.id, leafField);
+        }
+
+        return undefined;
+      }
+
+      return params.rowNode.groupingKey;
+    }
+  }; // If we have a `mainGroupingCriteria` defined and matching one of the `orderedGroupedByFields`
+  // Then we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `columnsLookup[mainGroupingCriteria]`.
+  // It can be useful to use another grouping criteria than the top level one for the sorting / filtering
+  //
+  // If we have a `leafField` defined and matching an existing column
+  // Then we apply the sorting / filtering on the leaves based on the properties of `leavesColDef`
+  //
+  // By default, we apply the sorting / filtering on the groups of the top level grouping criteria based on the properties of `columnsLookup[orderedGroupedByFields[0]]`.
+
+  let sourceProperties;
+
+  if (mainGroupingCriteria && rowGroupingModel.includes(mainGroupingCriteria)) {
+    sourceProperties = getGroupingCriteriaProperties(columnsLookup[mainGroupingCriteria], true);
+  } else if (leafColDef) {
+    sourceProperties = getLeafProperties(leafColDef);
+  } else {
+    sourceProperties = getGroupingCriteriaProperties(columnsLookup[rowGroupingModel[0]], rowGroupingModel.length === 1);
+  } // The properties that can't be overridden with `colDefOverride`
+
+
+  const forcedProperties = (0, _extends2.default)({
+    field: _gridRowGroupingUtils.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD
+  }, GROUPING_COL_DEF_FORCED_PROPERTIES);
+  return (0, _extends2.default)({}, GROUPING_COL_DEF_DEFAULT_PROPERTIES, commonProperties, sourceProperties, colDefOverrideProperties, forcedProperties);
+};
+
+exports.createGroupingColDefForAllGroupingCriteria = createGroupingColDefForAllGroupingCriteria;

package/node/hooks/features/rowGrouping/gridRowGroupingInterfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/hooks/features/rowGrouping/gridRowGroupingSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridRowGroupingStateSelector = exports.gridRowGroupingSanitizedModelSelector = exports.gridRowGroupingModelSelector = void 0;
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+const gridRowGroupingStateSelector = state => state.rowGrouping;
+
+exports.gridRowGroupingStateSelector = gridRowGroupingStateSelector;
+const gridRowGroupingModelSelector = (0, _internals.createSelector)(gridRowGroupingStateSelector, rowGrouping => rowGrouping.model);
+exports.gridRowGroupingModelSelector = gridRowGroupingModelSelector;
+const gridRowGroupingSanitizedModelSelector = (0, _internals.createSelector)(gridRowGroupingModelSelector, _xDataGridPro.gridColumnLookupSelector, (model, columnsLookup) => model.filter(field => !!columnsLookup[field] && columnsLookup[field].groupable));
+exports.gridRowGroupingSanitizedModelSelector = gridRowGroupingSanitizedModelSelector;

package/node/hooks/features/rowGrouping/gridRowGroupingUtils.js

@@ -0,0 +1,172 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setStrategyAvailability = exports.mergeStateWithRowGroupingModel = exports.isGroupingColumn = exports.getRowGroupingFieldFromGroupingCriteria = exports.getRowGroupingCriteriaFromGroupingField = exports.getColDefOverrides = exports.filterRowTreeFromGroupingColumns = exports.ROW_GROUPING_STRATEGY = exports.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
+
+const GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = '__row_group_by_columns_group__';
+exports.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
+const ROW_GROUPING_STRATEGY = 'grouping-columns';
+exports.ROW_GROUPING_STRATEGY = ROW_GROUPING_STRATEGY;
+
+const getRowGroupingFieldFromGroupingCriteria = groupingCriteria => {
+  if (groupingCriteria === null) {
+    return GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
+  }
+
+  return `__row_group_by_columns_group_${groupingCriteria}__`;
+};
+
+exports.getRowGroupingFieldFromGroupingCriteria = getRowGroupingFieldFromGroupingCriteria;
+
+const getRowGroupingCriteriaFromGroupingField = groupingColDefField => {
+  const match = groupingColDefField.match(/^__row_group_by_columns_group_(.*)__$/);
+
+  if (!match) {
+    return null;
+  }
+
+  return match[1];
+};
+
+exports.getRowGroupingCriteriaFromGroupingField = getRowGroupingCriteriaFromGroupingField;
+
+const isGroupingColumn = field => field === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD || getRowGroupingCriteriaFromGroupingField(field) !== null;
+
+exports.isGroupingColumn = isGroupingColumn;
+
+/**
+ * When filtering a group, we only want to filter according to the items related to this grouping column.
+ */
+const shouldApplyFilterItemOnGroup = (columnField, node) => {
+  if (columnField === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
+    return true;
+  }
+
+  const groupingCriteriaField = getRowGroupingCriteriaFromGroupingField(columnField);
+  return groupingCriteriaField === node.groupingField;
+};
+/**
+ * A leaf is visible if it passed the filter
+ * A group is visible if all the following criteria are met:
+ * - One of its children is passing the filter
+ * - It is passing the filter
+ */
+
+
+const filterRowTreeFromGroupingColumns = params => {
+  const {
+    rowTree,
+    isRowMatchingFilters
+  } = params;
+  const visibleRowsLookup = {};
+  const filteredRowsLookup = {};
+  const filteredDescendantCountLookup = {};
+
+  const filterTreeNode = (node, areAncestorsPassingChildren, areAncestorsExpanded) => {
+    var _node$children, _node$children2;
+
+    let isMatchingFilters;
+
+    if (!isRowMatchingFilters) {
+      isMatchingFilters = true;
+    } else {
+      const shouldApplyItem = node.isAutoGenerated ? columnField => shouldApplyFilterItemOnGroup(columnField, node) : undefined;
+      isMatchingFilters = isRowMatchingFilters(node.id, shouldApplyItem);
+    }
+
+    let filteredDescendantCount = 0;
+    (_node$children = node.children) == null ? void 0 : _node$children.forEach(childId => {
+      const childNode = rowTree[childId];
+      const childSubTreeSize = filterTreeNode(childNode, areAncestorsPassingChildren && isMatchingFilters, areAncestorsExpanded && !!node.childrenExpanded);
+      filteredDescendantCount += childSubTreeSize;
+    });
+    let shouldPassFilters;
+
+    if (!areAncestorsPassingChildren) {
+      shouldPassFilters = false;
+    } else if ((_node$children2 = node.children) != null && _node$children2.length) {
+      shouldPassFilters = isMatchingFilters && filteredDescendantCount > 0;
+    } else {
+      shouldPassFilters = isMatchingFilters;
+    }
+
+    visibleRowsLookup[node.id] = shouldPassFilters && areAncestorsExpanded;
+    filteredRowsLookup[node.id] = shouldPassFilters;
+
+    if (!shouldPassFilters) {
+      return 0;
+    }
+
+    filteredDescendantCountLookup[node.id] = filteredDescendantCount;
+
+    if (!node.children) {
+      return filteredDescendantCount + 1;
+    }
+
+    return filteredDescendantCount;
+  };
+
+  const nodes = Object.values(rowTree);
+
+  for (let i = 0; i < nodes.length; i += 1) {
+    const node = nodes[i];
+
+    if (node.depth === 0) {
+      filterTreeNode(node, true, true);
+    }
+  }
+
+  return {
+    visibleRowsLookup,
+    filteredRowsLookup,
+    filteredDescendantCountLookup
+  };
+};
+
+exports.filterRowTreeFromGroupingColumns = filterRowTreeFromGroupingColumns;
+
+const getColDefOverrides = (groupingColDefProp, fields) => {
+  if (typeof groupingColDefProp === 'function') {
+    return groupingColDefProp({
+      groupingName: ROW_GROUPING_STRATEGY,
+      fields
+    });
+  }
+
+  return groupingColDefProp;
+};
+
+exports.getColDefOverrides = getColDefOverrides;
+
+const mergeStateWithRowGroupingModel = rowGroupingModel => state => (0, _extends2.default)({}, state, {
+  rowGrouping: (0, _extends2.default)({}, state.rowGrouping, {
+    model: rowGroupingModel
+  })
+});
+
+exports.mergeStateWithRowGroupingModel = mergeStateWithRowGroupingModel;
+
+const setStrategyAvailability = (apiRef, disableRowGrouping) => {
+  let isAvailable;
+
+  if (disableRowGrouping) {
+    isAvailable = () => false;
+  } else {
+    isAvailable = () => {
+      const rowGroupingSanitizedModel = (0, _gridRowGroupingSelector.gridRowGroupingSanitizedModelSelector)(apiRef);
+      return rowGroupingSanitizedModel.length > 0;
+    };
+  }
+
+  apiRef.current.unstable_setStrategyAvailability('rowTree', ROW_GROUPING_STRATEGY, isAvailable);
+};
+
+exports.setStrategyAvailability = setStrategyAvailability;

package/node/hooks/features/rowGrouping/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD: true,
+  getRowGroupingFieldFromGroupingCriteria: true
+};
+Object.defineProperty(exports, "GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD", {
+  enumerable: true,
+  get: function () {
+    return _gridRowGroupingUtils.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
+  }
+});
+Object.defineProperty(exports, "getRowGroupingFieldFromGroupingCriteria", {
+  enumerable: true,
+  get: function () {
+    return _gridRowGroupingUtils.getRowGroupingFieldFromGroupingCriteria;
+  }
+});
+
+var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
+
+Object.keys(_gridRowGroupingSelector).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridRowGroupingSelector[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridRowGroupingSelector[key];
+    }
+  });
+});
+
+var _gridRowGroupingInterfaces = require("./gridRowGroupingInterfaces");
+
+Object.keys(_gridRowGroupingInterfaces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridRowGroupingInterfaces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridRowGroupingInterfaces[key];
+    }
+  });
+});
+
+var _gridRowGroupingUtils = require("./gridRowGroupingUtils");