@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,913 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
+/** @typedef {Array<ColumnGroupingPlugin~GroupDefinition>} ColumnGroupingPlugin~Options
+* @description This options can be specified by `columnGrouping` property of the main grid's options or extension options.
+*/
+
+/** @typedef {Array<ColumnGroupingPlugin~GroupDefinition>} ColumnGroupingPlugin~GroupDefinitions
+* @description A collection of group definition objects
+*/
+
+/** @typedef {Object} ColumnGroupingPlugin~GroupDefinition
+* @description Definition object that defined relationship of its children and how to render its content
+* @property {string} id Group id
+* @property {string} name Display group name
+* @property {(boolean|string)=} tooltip=true Show tooltip in column's header
+* @property {Array<string>} children Child member in this group
+* @property {string=} alignment eg. left, center, right
+* @property {Function=} render render function handler
+*/
+
+/** @constructor
+* @extends {GridPlugin}
+* @param {ColumnGroupingPlugin~Options=} options
+*/
+
+var ColumnGroupingPlugin = function ColumnGroupingPlugin(options) {
+  var t = this;
+  t._hosts = [];
+  t._onColumnChanged = t._onColumnChanged.bind(t);
+  t._onPostSectionRender = t._onPostSectionRender.bind(t);
+  t._groupDefs = [];
+  t._groupMap = {};
+  t._childToParent = {};
+
+  if (options) {
+    t.config({
+      "columnGrouping": options
+    });
+  }
+};
+
+Ext.inherits(ColumnGroupingPlugin, GridPlugin);
+/** @type {!ColumnGroupingPlugin~GroupDefinitions}
+* @description An array of group definition objects
+* @private
+*/
+
+ColumnGroupingPlugin.prototype._groupDefs;
+/** @type {!Object.<string, ColumnGroupingPlugin~GroupDefinition>}
+* @description A map of group id to group defintion
+* @private
+*/
+
+ColumnGroupingPlugin.prototype._groupMap;
+/** @type {!Object.<string, string>}
+* @description A map of child id to parent id
+* @private
+*/
+
+ColumnGroupingPlugin.prototype._childToParent;
+/** @type {number}
+* @private
+*/
+
+ColumnGroupingPlugin.prototype._maxDepth = -1;
+/** @type {boolean}
+* @private
+*/
+
+ColumnGroupingPlugin.prototype._restructuring = false;
+/** @private
+* @param {ColumnGroupingPlugin~GroupDefinition} groupingOptions
+* @return {string}
+*/
+
+ColumnGroupingPlugin._getTooltip = function (groupingOptions) {
+  var tooltip = groupingOptions["tooltip"];
+  var title = groupingOptions["title"] || groupingOptions["name"];
+
+  if (tooltip != null) {
+    if (typeof tooltip === "string") {
+      return tooltip; // There is a custom tooltip
+    } else if (tooltip === true) {
+      return title;
+    } else if (tooltip === false) {
+      return "";
+    }
+  }
+
+  return title;
+};
+/** Prevent built-in config
+* @public
+* @param {string} optionName
+* @param {Object} optionValue
+* @return {*}
+*/
+
+
+ColumnGroupingPlugin.prototype.beforeProcessOption = function (optionName, optionValue) {
+  if (optionName === "columnGroups") {
+    this._legacyColumnGroups = optionValue;
+    return false; // eslint-disable-line
+  }
+
+  return; // eslint-disable-line
+};
+/** @public
+* @return {string}
+*/
+
+
+ColumnGroupingPlugin.prototype.getName = function () {
+  return "ColumnGroupingPlugin"; // Read Only
+};
+/**
+* @override
+* @return {boolean}
+*/
+
+
+ColumnGroupingPlugin.prototype.hasMultiTableSupport = function () {
+  return true;
+};
+/** @public
+* @param {Object} host core grid object
+* @param {Object=} options
+*/
+
+
+ColumnGroupingPlugin.prototype.initialize = function (host, options) {
+  if (this._hosts.indexOf(host) >= 0) {
+    return;
+  }
+
+  this._hosts.push(host);
+
+  if (this._hosts.length === 1) {
+    host.listen("columnAdded", this._onColumnChanged);
+    host.listen("columnMoved", this._onColumnChanged);
+    host.listen("columnRemoved", this._onColumnChanged);
+    host.listen("columnVisibilityChanged", this._onColumnChanged);
+    host.listen("postSectionRender", this._onPostSectionRender);
+  }
+
+  this.config(options);
+  this._legacyColumnGroups = null;
+
+  if (this._initializedGrid && host.getSection("title")) {
+    // For run-time loading
+    this._applyGrouping();
+  } // TODO: wrong render group in hide/show column
+
+};
+/**
+* @protected
+* @ignore
+*/
+
+
+ColumnGroupingPlugin.prototype._afterInit = function () {
+  this._applyGrouping();
+};
+/** @public
+* @param {Object} host core grid object
+*/
+
+
+ColumnGroupingPlugin.prototype.unload = function (host) {
+  var at = this._hosts.indexOf(host);
+
+  if (at < 0) {
+    return;
+  }
+
+  this._hosts.splice(at, 1);
+
+  host.unlisten("columnAdded", this._onColumnChanged);
+  host.unlisten("columnMoved", this._onColumnChanged);
+  host.unlisten("columnRemoved", this._onColumnChanged);
+  host.unlisten("postSectionRender", this._onPostSectionRender);
+
+  this._dispose();
+};
+/** @public
+* @param {Object} options
+*/
+
+
+ColumnGroupingPlugin.prototype.config = function (options) {
+  if (!options) {
+    return;
+  }
+
+  var extOptions = options["columnGrouping"];
+
+  if (Array.isArray(extOptions)) {
+    this._groupDefs = extOptions.filter(ColumnGroupingPlugin._isValidGroup); // Shallow copy
+  }
+
+  this._migrateLegacyStructure(options["columns"]);
+};
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+
+
+ColumnGroupingPlugin.prototype.getConfigObject = function (gridOptions) {
+  var obj = gridOptions || {}; // TODO: Handle legacyRender method that has been migrated
+
+  obj.columnGrouping = this.getGroupDefinitions();
+  return obj;
+};
+/** Legacy group structure from composite grid will be converted to the new structure
+* @private
+* @param {Object.<string, Array>} objMap
+* @param {string} parentId
+* @param {string} childId
+* @return {boolean} Returns true if there is any change
+*/
+
+
+ColumnGroupingPlugin._mapParentToChildren = function (objMap, parentId, childId) {
+  if (parentId && childId) {
+    var ary = objMap[parentId];
+
+    if (!ary) {
+      ary = objMap[parentId] = [];
+    }
+
+    ary.push(childId);
+    return true;
+  }
+
+  return false;
+};
+/** Legacy group structure from composite grid will be converted to the new structure
+* @private
+* @param {Array.<Object>} colModels
+*/
+
+
+ColumnGroupingPlugin.prototype._migrateLegacyStructure = function (colModels) {
+  var legacyColumnGroups = this._legacyColumnGroups;
+
+  if (!legacyColumnGroups || !this._compositeGrid) {
+    return;
+  } // Collecting parent groups from col models (leaf node)
+
+
+  var colCount = colModels.length;
+  var groupMap = {}; // Parent-children pair map
+
+  for (var c = 0; c < colCount; ++c) {
+    var colModel = colModels[c];
+
+    if (colModel) {
+      ColumnGroupingPlugin._mapParentToChildren(groupMap, colModel.columnGroup, colModel.id);
+    }
+  } // Collecting parent groups from the group list (groups can have parent as well)
+
+
+  var groupCount = legacyColumnGroups.length;
+  var i, groupDef;
+
+  for (i = 0; i < groupCount; ++i) {
+    groupDef = legacyColumnGroups[i];
+
+    if (groupDef) {
+      ColumnGroupingPlugin._mapParentToChildren(groupMap, groupDef.parent, groupDef.id);
+    }
+  } // TODO: Merge child relationship to existing group structure
+  // Add new definitions and structure to the given legacy objects
+
+
+  for (i = 0; i < groupCount; ++i) {
+    groupDef = legacyColumnGroups[i];
+
+    if (groupDef && groupDef.id) {
+      // WARNING: Modify user's object
+      var childAry = groupMap[groupDef.id];
+      groupDef.children = childAry ? childAry : [];
+
+      if (groupDef["formatter"] && groupDef["formatter"]["render"]) {
+        groupDef["legacyRender"] = groupDef["formatter"]["render"];
+        delete groupDef["formatter"];
+      }
+
+      this._groupDefs.push(groupDef);
+    }
+  }
+};
+/** Consolidate and process configuration. Force rerendering on column adding, removing, moving, initializaing, and run-time API execution.
+* @private
+*/
+
+
+ColumnGroupingPlugin.prototype._applyGrouping = function () {
+  if (this._restructuring) {
+    return;
+  }
+
+  this._restructuring = true;
+
+  this._evaluateGroupStructure();
+
+  var i;
+  var hostCount = this._hosts.length;
+
+  for (i = hostCount; --i >= 0;) {
+    var host = this._hosts[i];
+    var titleSection = host.getSection("title");
+
+    if (titleSection) {
+      var rowCount = this._maxDepth + 1;
+      titleSection.setRowCount(rowCount); // This will cause postSectionRender event to be fired
+
+      titleSection.clearCellSpans();
+
+      this._spanGroupVertically(titleSection); // TODO: Some calculation in here should not be done in this loop
+
+
+      this._spanGroupHorizontally(titleSection);
+    }
+  }
+
+  this._restructuring = false; // Request re-rendering
+
+  for (i = hostCount; --i >= 0;) {
+    var settings = this._hosts[i].getSectionSettings("title");
+
+    if (settings) {
+      settings.rerender();
+    }
+  }
+};
+/** @private
+* @param {Object=} titleSection
+*/
+
+
+ColumnGroupingPlugin.prototype._spanGroupVertically = function (titleSection) {
+  var api = this.getGridApi();
+
+  if (!api) {
+    return;
+  }
+
+  var core = this._hosts[0];
+  var maxDepth = this._maxDepth;
+  var rowCount = maxDepth + 1;
+  var colCount = api.getColumnCount();
+
+  for (var col = 0; col < colCount; col++) {
+    var toSpan = maxDepth + 1;
+
+    var parentNode = this._getParentGroup(this.getColumnId(col));
+
+    if (parentNode) {
+      var depth = parentNode["onRow"] + 1;
+      toSpan = maxDepth - depth + 1;
+    } // Note that invisible column cannot have row span
+
+
+    if (core.isColumnVisible(col) && toSpan > 1) {
+      titleSection.setCellRowSpan(col, rowCount - toSpan, toSpan);
+    }
+  }
+};
+/** @private
+* @param {Object} titleSection
+*/
+
+
+ColumnGroupingPlugin.prototype._spanGroupHorizontally = function (titleSection) {
+  var section = titleSection;
+  var groupTable = this._groupMap; // Span column of column group
+
+  for (var id in groupTable) {
+    var node = groupTable[id];
+
+    var colSpans = this._findColumnSpans(node); // find appropriate span
+
+
+    for (var col = 0; col < colSpans.length; col++) {
+      var spanIndexes = colSpans[col];
+
+      if (spanIndexes.length > 0) {
+        // This could be unnecessary
+        var start = spanIndexes[0];
+        var end = spanIndexes[1];
+        section.setCellColSpan(start, node["onRow"], end - start + 1);
+        node["colIndex"] = start;
+      }
+    }
+  }
+};
+/** @private
+*/
+
+
+ColumnGroupingPlugin.prototype._renderGroups = function () {
+  var hostCount = this._hosts.length;
+  var groupMap = this._groupMap;
+
+  for (var i = 0; i < hostCount; ++i) {
+    var section = this._hosts[i].getSection("title");
+
+    if (!section) {
+      continue;
+    }
+
+    var arg = {};
+
+    for (var id in groupMap) {
+      var node = groupMap[id];
+      var colIndex = node["colIndex"];
+      var rowIndex = node["onRow"];
+      var cell = section.getCell(colIndex, rowIndex);
+
+      if (cell) {
+        cell.setStyle("text-align", node["alignment"] || "");
+        cell.setTooltip(ColumnGroupingPlugin._getTooltip(node));
+        cell.setContent(node["title"] || node["name"]);
+        cell.addClass("no-sort"); // TODO: This should be removed after rerendering
+
+        if (node["legacyRender"]) {
+          // Built-in version if render receive colIndex, cell, groupDefinition as arguments
+          node["legacyRender"](colIndex, cell, node);
+        }
+
+        if (node["render"]) {
+          arg["cell"] = cell;
+          arg["colIndex"] = colIndex;
+          arg["groupNode"] = node;
+          node["render"](arg);
+        }
+      }
+    }
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+ColumnGroupingPlugin.prototype._onPostSectionRender = function (e) {
+  if (e.sectionType === "title" && !this._restructuring) {
+    this._renderGroups();
+  }
+};
+/** @private
+*/
+
+
+ColumnGroupingPlugin.prototype._onColumnChanged = function () {
+  this._applyGrouping();
+};
+/** Deprecated. Column should be directly added through grid APIs.
+* @deprecated
+* @public
+* @param {Object} column Grid's Column definition object
+* @param {string} groupId
+* @param {number} colIndex Column index
+*/
+
+
+ColumnGroupingPlugin.prototype.addColumnToGroup = function (column, groupId, colIndex) {
+  if (!column || !groupId) return;
+  var columnIndex = colIndex || this.getColumnCount();
+
+  this._addGroupChild(column.id, groupId);
+
+  if (this._realTimeGrid) {
+    this._realTimeGrid.insertColumn(column, columnIndex);
+  } else if (this._compositeGrid) {
+    this._compositeGrid.insertColumn(columnIndex, column);
+  }
+};
+/** Add new group definition to existing group structure. Inexisting or duplicate group id is not allowed
+* @public
+* @param {ColumnGroupingPlugin~GroupDefinition} groupDef Group definition object
+* @return {boolean} Return true if there is any change
+*/
+
+
+ColumnGroupingPlugin.prototype.addGroup = function (groupDef) {
+  if (groupDef && groupDef.id) {
+    var curDef = this.getGroupDefinition(groupDef.id);
+
+    if (!curDef) {
+      this._groupDefs.push(groupDef);
+
+      this._applyGrouping();
+
+      return true;
+    }
+  }
+
+  return false;
+};
+/** Deprecated. Use addGroup() method instead
+* @deprecated
+* @public
+* @function
+* @param {ColumnGroupingPlugin~GroupDefinition} groupDef Group definition object
+* @see {@link ColumnGroupingPlugin#addGroup}
+*/
+
+
+ColumnGroupingPlugin.prototype.addColumnGrouping = ColumnGroupingPlugin.prototype.addGroup;
+/** @public
+* @param {string} groupId
+* @return {Object} Return removed group definition object.
+*/
+
+ColumnGroupingPlugin.prototype.removeGroup = function (groupId) {
+  var curDef = this.getGroupDefinition(groupId);
+
+  if (curDef) {
+    var at = this._groupDefs.indexOf(curDef);
+
+    this._groupDefs.splice(at, 1);
+
+    this._applyGrouping();
+  }
+
+  return curDef;
+};
+/** 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.filter(ColumnGroupingPlugin._isValidGroup);
+
+    if (!groupDefs.length) {
+      groupDefs = null;
+    }
+  } else {
+    groupDefs = null;
+  }
+
+  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) {
+      if (!groupDef.children) {
+        groupDef.children = []; // WARNING: Modify user's object
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+};
+/** 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.id = groupId;
+    this._groupDefs[at] = newDef;
+
+    this._applyGrouping();
+  }
+};
+/** @public
+* @param {number} 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);
+
+  if (groupDef) {
+    if (Array.isArray(newChildList)) {
+      groupDef.children = newChildList.slice();
+
+      this._applyGrouping();
+    } else if (!newChildList && groupDef.children.length) {
+      groupDef.children = [];
+
+      this._applyGrouping();
+    }
+  }
+};
+/** @public
+* @param {number} groupId
+* @return {ColumnGroupingPlugin~GroupDefinition}
+*/
+
+
+ColumnGroupingPlugin.prototype.getGroupChildren = function (groupId) {
+  var groupDef = this.getGroupDefinition(groupId);
+
+  if (groupDef) {
+    return groupDef.children.slice(); // Shallow copy
+  }
+
+  return null;
+};
+/** @private
+*/
+
+
+ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
+  // Clear existing group structure
+  this._groupMap = {};
+  this._childToParent = {};
+  this._maxDepth = -1; // Flatten tree to dictionary
+
+  var columnGroups = this._groupDefs;
+  var inUsedGroup = {};
+  var node;
+
+  for (var cg = 0; cg < columnGroups.length; cg++) {
+    // node can be a root or child
+    node = columnGroups[cg]; // skip tree that don't have a child
+
+    if (node.children && node.children.length) {
+      this._flattenTree(node, inUsedGroup);
+    }
+  }
+
+  var id; // Apply parent id to columnGroup for easy to find depth
+
+  for (id in this._groupMap) {
+    node = this._groupMap[id];
+
+    if (this._childToParent[node.id]) {
+      var parentId = this._childToParent[node.id];
+      node["parent"] = parentId;
+    }
+  } // find depth of each group
+
+
+  for (id in this._groupMap) {
+    node = this._groupMap[id];
+
+    var depth = this._findGroupTreeDepth(node, 1);
+
+    node["onRow"] = depth - 1; // Modify user's object
+  } // Calculate max depth
+
+
+  var maxDepth = 0;
+
+  for (id in this._groupMap) {
+    node = this._groupMap[id];
+    depth = node["onRow"] + 1;
+
+    if (depth > maxDepth) {
+      maxDepth = depth;
+    }
+  }
+
+  this._maxDepth = maxDepth;
+};
+/** @private
+* @param {Object} node
+* @param {boolean} inUsedGroup
+*/
+
+
+ColumnGroupingPlugin.prototype._flattenTree = function (node, inUsedGroup) {
+  var childrens = node.children;
+
+  if (childrens && childrens.length > 0) {
+    var childId;
+
+    for (var c = 0; c < childrens.length; c++) {
+      var child = childrens[c];
+
+      if (child.id) {
+        // child is group object
+        childId = child.id;
+
+        this._flattenTree(child, inUsedGroup);
+      } else {
+        // child can be column id or group id
+        childId = child;
+
+        if (inUsedGroup[childId] || this._getColumnIndexById(childId) !== -1) {
+          inUsedGroup[node.id] = true;
+        }
+      }
+
+      if (!this._childToParent[childId] && childId != node.id) {
+        this._childToParent[childId] = node.id;
+      }
+    } // Create Tree node for only in-used group
+
+
+    if (!this._groupMap[node.id] && inUsedGroup[node.id]) {
+      // need to change
+      this._groupMap[node.id] = node; // TODO: Check if we need to clone
+    }
+  }
+};
+/** @private
+* @param {Object} node
+* @param {number} currentDepth
+* @return {number}
+*/
+
+
+ColumnGroupingPlugin.prototype._findGroupTreeDepth = function (node, currentDepth) {
+  var parentId = node["parent"];
+  var parentNode = this._groupMap[parentId];
+
+  if (parentNode) {
+    return this._findGroupTreeDepth(parentNode, currentDepth + 1);
+  } else {
+    return currentDepth;
+  }
+};
+/** This version exclude invisible column unlike the one in GridPlugin
+* @private
+* @param {string} id
+* @return {number} index of the column
+*/
+
+
+ColumnGroupingPlugin.prototype._getColumnIndexById = function (id) {
+  var api = this.getGridApi();
+
+  if (api && id) {
+    var core = this._hosts[0];
+    var colCount = core.getColumnCount();
+
+    for (var c = 0; c < colCount; c++) {
+      if (this.getColumnId(c) === id && core.isColumnVisible(c)) {
+        return c;
+      }
+    }
+  }
+
+  return -1;
+};
+/** @private
+* @param {Object} node
+* @param {Array} cluster
+*/
+
+
+ColumnGroupingPlugin.prototype._findColumnIndexArr = function (node, cluster) {
+  if (node) {
+    var childrens = node.children;
+
+    if (childrens && childrens.length) {
+      for (var i = 0; i < childrens.length; i++) {
+        var child = childrens[i];
+
+        if (!child.id) {
+          if (!this._groupMap[child]) {
+            var colIndex = this._getColumnIndexById(child);
+
+            if (colIndex !== -1) {
+              cluster.push(colIndex);
+            }
+          } else {
+            this._findColumnIndexArr(this._groupMap[child], cluster);
+          }
+        } else {
+          // skip children that has same id as parent
+          if (child.id === node.id) {
+            return;
+          }
+
+          this._findColumnIndexArr(this._groupMap[child.id], cluster);
+        }
+      }
+    }
+  }
+};
+/** @private
+* @param {Object} node
+* @return {Array} group of span index
+*/
+
+
+ColumnGroupingPlugin.prototype._findColumnSpans = function (node) {
+  var cluster = [];
+
+  this._findColumnIndexArr(node, cluster); // Recursively get column index
+
+
+  return ColumnGroupingPlugin._groupConsecutiveArr(cluster);
+};
+/** @private
+* @param {Array} arr
+* @return {Array} group of Consecutive number
+*/
+
+
+ColumnGroupingPlugin._groupConsecutiveArr = function (arr) {
+  var result = [];
+
+  if (!arr || !arr.length) {
+    return result;
+  }
+
+  var array = arr.sort(function (a, b) {
+    return a - b;
+  });
+  var start = array[0];
+  var stop = start; // start at second member of array
+
+  for (var i = 1; i <= array.length; i++) {
+    var next = array[i];
+
+    if (next === stop + 1) {
+      // move to next member
+      stop = next;
+    } else {
+      if (start === stop) {
+        result.push([start, start]);
+      } else {
+        result.push([start, stop]);
+      } // reset the start and stop pointers
+
+
+      start = array[i];
+      stop = start;
+    }
+  }
+
+  return result;
+};
+/** @private
+* @param {string} childId
+* @param {string} groupId
+*/
+
+
+ColumnGroupingPlugin.prototype._addGroupChild = function (childId, groupId) {
+  var groupDef = this.getGroupDefinition(groupId);
+
+  if (childId && groupDef) {
+    var chdr = groupDef.children;
+
+    if (chdr && chdr.indexOf(childId) < 0) {
+      this._childToParent[childId] = groupId;
+      chdr.push(childId);
+    }
+  }
+};
+/** @private
+* @param {number} childId
+* @return {ColumnGroupingPlugin~GroupDefinition}
+*/
+
+
+ColumnGroupingPlugin.prototype._getParentGroup = function (childId) {
+  return this.getGroupDefinition(this._childToParent[childId]);
+};
+
+export default ColumnGroupingPlugin;
+export { ColumnGroupingPlugin, ColumnGroupingPlugin as ColumnGrouping, ColumnGroupingPlugin as ColumnGroupingExtension };