@refinitiv-ui/efx-grid 6.0.20 → 6.0.22

package/lib/tr-grid-column-grouping/es6/ColumnGrouping.js

@@ -74,6 +74,10 @@ ColumnGroupingPlugin.prototype._maxDepth = 0;
 * @private
 */
 ColumnGroupingPlugin.prototype._restructuring = false;
+/** @type {boolean}
+* @private
+*/
+ColumnGroupingPlugin.prototype._autoGrouping = true;
 /** @type {number}
 * @private
 */
@@ -113,6 +117,59 @@ ColumnGroupingPlugin._getTooltip = function (groupingOptions) {
   }
   return title;
 };
+/** @private
+* @function
+* @param {Object} groupDef
+* @return {boolean}
+*/
+ColumnGroupingPlugin._isValidGroup = function (groupDef) {
+  if (groupDef) {
+    if (groupDef.id) {
+      return true;
+    }
+  }
+  return false;
+};
+/** @private
+* @function
+* @param {Array|Object} obj
+* @param {string=} groupId
+* @return {ColumnGroupingPlugin~GroupDefinition}
+*/
+ColumnGroupingPlugin._toGroupDefinition = function (obj, groupId) {
+  var groupDef = null;
+  if (obj) {
+    if (Array.isArray(obj)) {
+      groupDef = {
+        children: obj
+      };
+    } else {
+      groupDef = ColumnGroupingPlugin._cloneObject(obj);
+    }
+    if (groupId) {
+      if (!groupDef.id) {
+        groupDef.name = groupId;
+      }
+      groupDef.id = groupId;
+    }
+  }
+  return groupDef;
+};
+/** @private
+* @function
+* @param {Object} obj
+* @return {Object}
+*/
+ColumnGroupingPlugin._cloneObject = function (obj) {
+  var newObj = cloneObject(obj);
+  if (Array.isArray(newObj.children)) {
+    newObj.children = newObj.children;
+  } else {
+    newObj.children = [];
+  }
+  return newObj;
+};
+
 /** @public
 * @return {string}
 */
@@ -219,8 +276,8 @@ ColumnGroupingPlugin.prototype.config = function (options) {
   }
   var extOptions = options["columnGrouping"];
   if (Array.isArray(extOptions)) {
-    var groupDefs = extOptions.map(ColumnGroupingPlugin._cloneObject);
-    this._groupDefs = groupDefs.filter(ColumnGroupingPlugin._isValidGroup);
+    var groupDefs = extOptions.filter(ColumnGroupingPlugin._isValidGroup);
+    this._groupDefs = groupDefs.map(ColumnGroupingPlugin._cloneObject);
   }
   var columns = options["columns"];
   if (!columns) {
@@ -243,8 +300,10 @@ ColumnGroupingPlugin.prototype.getConfigObject = function (gridOptions) {
   var obj = gridOptions || {};
 
   // TODO: Handle legacyRender method that has been migrated
-  var columnGroupingDefs = this.getGroupDefinitions();
-  obj.columnGrouping = columnGroupingDefs;
+  var groupDefs = this.getGroupDefinitions();
+  if (groupDefs.length) {
+    obj.columnGrouping = groupDefs;
+  }
   return obj;
 };
 
@@ -256,14 +315,6 @@ ColumnGroupingPlugin.prototype._setColumnGrouping = function (colIndex, data) {
   var colData = this._newColumnData(colIndex);
   colData["columnGrouping"] = data;
 };
-/** @private
-* @param {number} colIndex
-* @return {Object}
-*/
-ColumnGroupingPlugin.prototype._getColumnGrouping = function (colIndex) {
-  return this._getColumnOption(colIndex, "columnGrouping");
-};
-
 /** Legacy group structure from composite grid will be converted to the new structure
 * @private
 * @param {Object.<string, Array>} objMap
@@ -378,8 +429,8 @@ ColumnGroupingPlugin.prototype._applyGrouping = function () {
 */
 ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
   // Clear existing group structure
-  var groupMap = this._groupMap = {};
-  var childToParent = this._childToParent = {};
+  var groupMap = this._groupMap = {}; // TODO: This is bad
+  var childToParent = this._childToParent = {}; // TODO: This is bad
   var visibleGroupMap = this._visibleGroupMap = {};
   this._maxDepth = -1;
 
@@ -406,11 +457,12 @@ ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
   // Create child to parent map
   var gid, children, member;
   for (gid in groupMap) {
-    groupDef = groupMap[gid];
-    children = groupDef.children;
-    for (i = 0; i < children.length; i++) {
-      member = children[i];
-      childToParent[member] = gid;
+    children = this._getAvaliableChildren(gid);
+    if (children.length > 1) {
+      for (i = 0; i < children.length; i++) {
+        member = children[i];
+        childToParent[member] = gid;
+      }
     }
   }
 
@@ -424,7 +476,7 @@ ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
     }
   }
 
-  // Filter invisible groups out
+  // Filter out groups that are invisible
   var rootGroup = [];
   for (gid in visibleGroupMap) {
     groupDef = visibleGroupMap[gid];
@@ -478,7 +530,7 @@ ColumnGroupingPlugin.prototype._flattenGroupDefs = function (groupDef, groupDefs
           }
           this._flattenGroupDefs(member, groupDefs);
         }
-      }
+      } // TODO: Invalid group is not flatten
     }
   }
 };
@@ -790,25 +842,27 @@ ColumnGroupingPlugin.prototype._onColumnChanged = function () {
 * @param {Object} e dispatching of columnMoved event object
 */
 ColumnGroupingPlugin.prototype._onColumnMoved = function (e) {
-  var toColIndex = e.toColIndex;
-  var colId = this.getColumnId(toColIndex);
-  var groupId = this._childToParent[colId];
-  if (groupId) {
-    var colIdLeft = this.getColumnId(toColIndex - 1);
-    var colIdRight = this.getColumnId(toColIndex + 1);
-    var groupIdLeft = this._childToParent[colIdLeft];
-    var groupIdRight = this._childToParent[colIdRight];
-    if (groupId != groupIdLeft && groupId != groupIdRight) {
-      // Remove column from previous group
-      var children = this.getGroupChildren(groupId);
-      var removeIndex = children.indexOf(colId);
-      if (removeIndex > -1) {
-        children.splice(removeIndex, 1);
+  if (this._autoGrouping) {
+    var toColIndex = e.toColIndex;
+    var colId = this.getColumnId(toColIndex);
+    var groupId = this._childToParent[colId];
+    if (groupId) {
+      var colIdLeft = this.getColumnId(toColIndex - 1);
+      var colIdRight = this.getColumnId(toColIndex + 1);
+      var groupIdLeft = this._childToParent[colIdLeft];
+      var groupIdRight = this._childToParent[colIdRight];
+      if (groupId != groupIdLeft && groupId != groupIdRight) {
+        // Remove column from previous group
+        var children = this.getGroupChildren(groupId);
+        var removeIndex = children.indexOf(colId);
+        if (removeIndex > -1) {
+          children.splice(removeIndex, 1);
+        }
+        this.setGroupChildren(groupId, children);
       }
-      this.setGroupChildren(groupId, children);
     }
+    this._applyNearestGrouping(toColIndex);
   }
-  this._applyNearestGrouping(toColIndex);
   this._requestApplyGrouping();
 };
 /** @private
@@ -820,19 +874,7 @@ ColumnGroupingPlugin.prototype._onColumnRemoved = function (e) {
     var colId = colData.columnGrouping.id;
     var groupId = this._childToParent[colId];
     if (groupId) {
-      var groupDef = this._groupMap[groupId];
-      if (groupDef) {
-        var children = groupDef.children;
-        var index = children.indexOf(colId);
-        if (index > -1) {
-          if (children.length < 3) {
-            this._groupDefs.splice(this._groupDefs.indexOf(groupDef), 1);
-          } else {
-            children.splice(index, 1);
-          }
-          this._requestApplyGrouping();
-        }
-      }
+      this._requestApplyGrouping();
     }
   }
 };
@@ -940,22 +982,69 @@ ColumnGroupingPlugin.prototype.addColumnToGroup = function (column, groupId, col
   }
 };
 
-/** Add new group definition to existing group structure. Inexisting or duplicate group id is not allowed
+/** Remove each child from another group
+ * @private
+ * @param {Array.<string>} children
+ */
+ColumnGroupingPlugin.prototype._ungroupChildren = function (children) {
+  if (Array.isArray(children)) {
+    var len = children.length;
+    for (var i = 0; i < len; ++i) {
+      this._unsetParent(children[i]);
+    }
+  }
+};
+/** Unset parent of the specified id
+ * @private
+ * @param {string} childId
+ */
+ColumnGroupingPlugin.prototype._unsetParent = function (childId) {
+  var parentId = this._childToParent[childId];
+  if (parentId) {
+    this._childToParent[childId] = "";
+    var grpDef = this._groupMap[parentId];
+    if (grpDef) {
+      var chdr = grpDef.children;
+      if (chdr.length) {
+        var at = chdr.indexOf(childId);
+        if (at >= 0) {
+          chdr.splice(at, 1); // splice is slow
+        }
+      }
+    }
+  }
+};
+/** Remove all children from the specified group
+ * @private
+ * @param {string} grpId
+ */
+ColumnGroupingPlugin.prototype._removeAllChildren = function (grpId) {
+  var grpDef = this._groupMap[grpId];
+  if (grpDef) {
+    var chdr = grpDef.children;
+    var len = chdr.length;
+    if (len) {
+      grpDef.children = [];
+      for (var i = 0; i < len; ++i) {
+        var childId = chdr[i];
+        if (this._childToParent[childId]) {
+          this._childToParent[childId] = "";
+        }
+      }
+    }
+  }
+};
+
+/** Add new group definition to existing group structure. Existing group with the same id will be replaced.
 * @public
 * @param {ColumnGroupingPlugin~GroupDefinition} groupDef Group definition object
-* @return {boolean} Return true if there is any change
+* @return {string} Return group ID
 */
 ColumnGroupingPlugin.prototype.addGroup = function (groupDef) {
-  if (groupDef && groupDef.id) {
-    var curDef = this.getGroupDefinition(groupDef.id);
-    if (!curDef) {
-      var newGroupDef = ColumnGroupingPlugin._cloneObject(groupDef);
-      this._groupDefs.push(newGroupDef);
-      this._applyGrouping();
-      return true;
-    }
+  if (ColumnGroupingPlugin._isValidGroup(groupDef)) {
+    return this.setGroupDefinition(groupDef.id, groupDef);
   }
-  return false;
+  return "";
 };
 /** Deprecated. Use addGroup() method instead
 * @deprecated
@@ -967,10 +1056,10 @@ ColumnGroupingPlugin.prototype.addGroup = function (groupDef) {
 ColumnGroupingPlugin.prototype.addColumnGrouping = ColumnGroupingPlugin.prototype.addGroup;
 /** @public
 * @param {string} groupId
-* @return {Object} Return removed group definition object.
+* @return {ColumnGroupingPlugin~GroupDefinition} Return removed group definition object.
 */
 ColumnGroupingPlugin.prototype.removeGroup = function (groupId) {
-  var curDef = this.getGroupDefinition(groupId);
+  var curDef = this._groupMap[groupId];
   if (curDef) {
     var at = this._groupDefs.indexOf(curDef);
     this._groupDefs.splice(at, 1);
@@ -979,14 +1068,87 @@ ColumnGroupingPlugin.prototype.removeGroup = function (groupId) {
   return curDef;
 };
 
+/** @public
+* @param {string} groupId
+* @return {ColumnGroupingPlugin~GroupDefinition}
+*/
+ColumnGroupingPlugin.prototype.getGroupDefinition = function (groupId) {
+  if (groupId) {
+    // Check for group validility
+    var groupDef = this._groupMap[groupId];
+    if (!groupDef) {
+      return null;
+    }
+    groupDef = ColumnGroupingPlugin._cloneObject(groupDef); // TODO: this is slow
+    var children = this._getAvaliableChildren(groupId);
+    groupDef.children = children;
+    return groupDef;
+  }
+  return null;
+};
+/** Get a shallow copy of all existing group definitions
+* @public
+* @return {!ColumnGroupingPlugin~GroupDefinitions}
+*/
+ColumnGroupingPlugin.prototype.getGroupDefinitions = function () {
+  var validGroupDefs = [];
+  var len = this._groupDefs.length;
+  var groupDef;
+  for (var i = 0; i < len; i++) {
+    groupDef = this.getGroupDefinition(this._groupDefs[i].id);
+    if (groupDef && groupDef.children.length > 1) {
+      validGroupDefs.push(groupDef);
+    }
+  }
+  return validGroupDefs;
+};
+/** Replace and update existing group definition. New group is added if the given id has no match. Existing group will be removed of no new definition is given.
+* @public
+* @param {string} groupId
+* @param {ColumnGroupingPlugin~GroupDefinition=} groupDef
+* @return {string} Group Id
+*/
+ColumnGroupingPlugin.prototype.setGroupDefinition = function (groupId, groupDef) {
+  if (!groupId) {
+    return "";
+  }
+  if (groupDef) {
+    var newDef = ColumnGroupingPlugin._toGroupDefinition(groupDef, groupId);
+    this._ungroupChildren(newDef.children);
+    var curDef = this._groupMap[groupId];
+    if (curDef) {
+      // Replace
+      var at = this._groupDefs.indexOf(curDef);
+      this._groupDefs[at] = newDef;
+    } else {
+      // Add
+      this._groupDefs.push(newDef);
+    }
+    var chdr = newDef.children;
+    var len = chdr.length;
+    // TODO: Filter out group id
+    if (len > 1) {
+      var gridApi = this.getGridApi();
+      if (gridApi && gridApi.reorderColumns) {
+        gridApi.reorderColumns(chdr, chdr[0]); // WARNING: group id doesn't work
+      }
+    }
+
+    this._applyGrouping();
+  } else {
+    // Remove
+    this.removeGroup(groupId);
+  }
+  return groupId;
+};
 /** Remove all existing group definitions and replace with the given definitions.
 * @public
 * @param {ColumnGroupingPlugin~GroupDefinitions} groupDefs Use null or empty array to remove all existing groups
 */
 ColumnGroupingPlugin.prototype.setGroupDefinitions = function (groupDefs) {
   if (Array.isArray(groupDefs)) {
-    groupDefs = groupDefs.map(ColumnGroupingPlugin._cloneObject);
     groupDefs = groupDefs.filter(ColumnGroupingPlugin._isValidGroup);
+    groupDefs = groupDefs.map(ColumnGroupingPlugin._cloneObject);
     if (!groupDefs.length) {
       groupDefs = null;
     }
@@ -996,80 +1158,22 @@ ColumnGroupingPlugin.prototype.setGroupDefinitions = function (groupDefs) {
   if (groupDefs) {
     this._groupDefs = groupDefs;
     this._applyGrouping();
-  } else if (this._groupDefs.length) {
-    this._groupDefs = [];
-    this._applyGrouping();
-  }
-};
-/** @private
-* @function
-* @param {Object} groupDef
-* @return {boolean}
-*/
-ColumnGroupingPlugin._isValidGroup = function (groupDef) {
-  if (groupDef) {
-    if (groupDef.id) {
-      return true;
-    }
-  }
-  return false;
-};
-/** @private
-* @function
-* @param {Object} obj
-* @return {boolean}
-*/
-ColumnGroupingPlugin._cloneObject = function (obj) {
-  var newObj = cloneObject(obj);
-  if (Array.isArray(newObj.children)) {
-    newObj.children = newObj.children;
   } else {
-    newObj.children = [];
-  }
-  return newObj;
-};
-/** Get a shallow copy of all existing group definitions
-* @public
-* @return {!ColumnGroupingPlugin~GroupDefinitions}
-*/
-ColumnGroupingPlugin.prototype.getGroupDefinitions = function () {
-  return this._groupDefs.slice();
-};
-/** Replace and update existing group definition. Existing group id will not be modified
-* @public
-* @param {string} groupId
-* @param {ColumnGroupingPlugin~GroupDefinition} newDef
-*/
-ColumnGroupingPlugin.prototype.setGroupDefinition = function (groupId, newDef) {
-  var curDef = this.getGroupDefinition(groupId);
-  if (curDef) {
-    var at = this._groupDefs.indexOf(curDef);
-    newDef = ColumnGroupingPlugin._cloneObject(newDef);
-    newDef.id = groupId;
-    this._groupDefs[at] = newDef;
+    this._groupDefs = [];
     this._applyGrouping();
   }
 };
-/** @public
-* @param {string} groupId
-* @return {ColumnGroupingPlugin~GroupDefinition}
-*/
-ColumnGroupingPlugin.prototype.getGroupDefinition = function (groupId) {
-  if (groupId) {
-    return this._groupMap[groupId] || null;
-  }
-  return null;
-};
 /** Replace and update existing group definition.
 * @public
 * @param {string} groupId
 * @param {Array.<string>} newChildList If null is given, all existing children in the group will be removed
 */
 ColumnGroupingPlugin.prototype.setGroupChildren = function (groupId, newChildList) {
-  var groupDef = this.getGroupDefinition(groupId);
+  var groupDef = this._groupMap[groupId];
   if (groupDef) {
     if (Array.isArray(newChildList)) {
       groupDef.aaa = 0; // TODO: for testing, need to be removed
+      this._ungroupChildren(newChildList);
       groupDef.children = newChildList.slice();
       this._applyGrouping();
     } else if (!newChildList && groupDef.children.length) {
@@ -1078,14 +1182,37 @@ ColumnGroupingPlugin.prototype.setGroupChildren = function (groupId, newChildLis
     }
   }
 };
+/** @private
+* @param {string} groupId
+* @return {!Array.<string>}
+*/
+ColumnGroupingPlugin.prototype._getAvaliableChildren = function (groupId) {
+  var groupDef = this._groupMap[groupId];
+  var validChildren = [];
+  if (groupDef) {
+    // Filter out columns that do not exist
+    var groupMap = this._groupMap;
+    var children = groupDef.children;
+    var childId;
+    for (var i = 0; i < children.length; i++) {
+      childId = children[i];
+      if (groupMap[childId] || this.getColumnIndex(childId) > -1) {
+        validChildren.push(childId); // TODO: This is slow
+      }
+    }
+  }
+
+  return validChildren;
+};
+
 /** @public
 * @param {string} groupId
 * @return {Array.<string>}
 */
 ColumnGroupingPlugin.prototype.getGroupChildren = function (groupId) {
-  var groupDef = this.getGroupDefinition(groupId);
-  if (groupDef) {
-    return groupDef.children;
+  var children = this._getAvaliableChildren(groupId);
+  if (children.length > 1) {
+    return children;
   }
   return null;
 };
@@ -1164,14 +1291,17 @@ ColumnGroupingPlugin.prototype.getGroupLevel = function (groupId) {
 /** @private
 * @param {Object.<string, ColumnGroupingPlugin~GroupDefinition>} groupMap
 * @param {ColumnGroupingPlugin~GroupDefinition} group Group definition
-* @param {Array=} members
+* @param {Array.<string>=} members
 * @return {Array.<string>}
 */
 ColumnGroupingPlugin.prototype._getGroupMembers = function (groupMap, group, members) {
   if (!members) {
     members = [];
   }
-  var children = group.children;
+  var children = this._getAvaliableChildren(group.id);
+  if (children.length < 2) {
+    return members;
+  }
   var g, id;
   for (var i = 0; i < children.length; i++) {
     id = children[i];
@@ -1311,7 +1441,7 @@ ColumnGroupingPlugin.prototype.moveColumnIntoGroup = function (colRef, to, group
   if (fromIndex == -1) {
     return;
   }
-  var groupDef = this.getGroupDefinition(groupId);
+  var groupDef = this._groupMap[groupId];
   if (!groupDef) {
     for (var j = this._hosts.length; --j >= 0;) {
       var grid = this._hosts[j];
@@ -1369,6 +1499,7 @@ ColumnGroupingPlugin.prototype.moveColumnIntoGroup = function (colRef, to, group
     host.moveColumn(fromIndex, to);
   }
   if (colId) {
+    // TODO:
     // Remove from current group
     var previousGroup = this._childToParent[colId];
     if (previousGroup) {
@@ -1397,8 +1528,7 @@ ColumnGroupingPlugin.prototype.setColumnParent = function (colRef, groupId) {
   if (!api) {
     return;
   }
-  var grid = this._hosts[0];
-  var colCount = grid.getColumnCount();
+  var colCount = this.getColumnCount();
   var toIndex = -1;
   var childIndices = this.getChildColumnIndices(groupId);
 
@@ -1411,5 +1541,107 @@ ColumnGroupingPlugin.prototype.setColumnParent = function (colRef, groupId) {
   }
   this.moveColumnIntoGroup(colRef, toIndex, groupId);
 };
+
+/** @public
+* Get a valid index for moving group/column to specific index
+* @param {string} id group id or column id
+* @param {number|string} destCol destination column index / id
+* @returns {number} destination index
+*/
+ColumnGroupingPlugin.prototype.getValidDestinationIndex = function (id, destCol) {
+  var groupDef, parentGroupDef;
+  groupDef = this._groupMap[id];
+  if (groupDef) {
+    parentGroupDef = this.getGroupDefinition(groupDef["parent"]);
+  } else if (this.getColumnIndex(id) > -1) {
+    parentGroupDef = this._getParentGroup(id);
+  }
+  var startIndex = -1;
+  var endIndex = -1;
+  var destColIndex = typeof destCol === "string" ? this.getColumnIndex(destCol) : destCol;
+  if (parentGroupDef) {
+    // If group/column is a child of a group, it should be move within the parent group
+    var childIndices = this.getChildColumnIndices(parentGroupDef["id"]);
+    if (childIndices && childIndices.length) {
+      startIndex = childIndices[0];
+      endIndex = childIndices[childIndices.length - 1];
+    }
+    if (destColIndex < startIndex && destColIndex != -1) {
+      destColIndex = this.getColumnId(startIndex);
+    } else if (destColIndex > endIndex || destColIndex == -1) {
+      destColIndex = this.getColumnId(endIndex + 1);
+    }
+
+    // handle group/column should not insert between group
+    var groupChildren = this.getGroupChildren(parentGroupDef["id"]);
+    for (var i = 0; i < groupChildren.length; i++) {
+      var childId = groupChildren[i];
+      var childGroupIndices = this.getChildColumnIndices(childId);
+      if (childGroupIndices && childGroupIndices.length) {
+        startIndex = childGroupIndices[0];
+        endIndex = childGroupIndices[childGroupIndices.length - 1];
+        if (destColIndex > startIndex && destColIndex <= endIndex) {
+          destColIndex = endIndex + 1;
+          break;
+        }
+      }
+    }
+  } else {
+    // handle group/column should not insert between group when group/column is not a child of any group
+    var destMemberIndices = [];
+    var destColId = this.getColumnId(destColIndex);
+    var destParent = this._getParentGroup(destColId);
+    if (destParent) {
+      if (destParent["parent"]) {
+        destParent = this._getRootGroup(destParent["id"]);
+      }
+      destMemberIndices = this.getChildColumnIndices(destParent["id"]);
+    }
+    if (destMemberIndices && destMemberIndices.length) {
+      startIndex = destMemberIndices[0];
+      endIndex = destMemberIndices[destMemberIndices.length - 1];
+      if (destColIndex > startIndex && destColIndex <= endIndex) {
+        destColIndex = endIndex + 1;
+      }
+    }
+  }
+  return destColIndex;
+};
+
+/** @public
+* Move group or column to left side of the destination column.
+* Group or column can only be moved within the parent group.
+* If the destination is between other column group, the destination will change to the end of  that group instead.
+* @param {string} id group id or column id
+* @param {number|string} destCol destination column index / id
+*/
+ColumnGroupingPlugin.prototype.moveGroup = function (id, destCol) {
+  var groupDef;
+  var members = [];
+  groupDef = this._groupMap[id];
+  if (groupDef) {
+    var indices = this.getChildColumnIndices(groupDef["id"]);
+    for (var i = 0; i < indices.length; i++) {
+      var index = indices[i];
+      var colId = this.getColumnId(index);
+      members.push(colId);
+    }
+  } else if (this.getColumnIndex(id) > -1) {
+    members.push(id);
+  } else {
+    return;
+  }
+  var destColIndex = this.getValidDestinationIndex(id, destCol);
+  var destColId = this.getColumnId(destColIndex);
+
+  // TODO: create method for toggling autoGrouping flag
+  this._autoGrouping = false;
+  if (this._realTimeGrid) {
+    this._realTimeGrid.reorderColumns(members, destColId);
+  } else if (this._compositeGrid) {
+    this._compositeGrid.reorderColumns(members, destColId);
+  }
+  this._autoGrouping = true;
+};
 export default ColumnGroupingPlugin;
 export { ColumnGroupingPlugin, ColumnGroupingPlugin as ColumnGrouping, ColumnGroupingPlugin as ColumnGroupingExtension };