@refinitiv-ui/efx-grid 6.0.16 → 6.0.17

package/lib/grid/index.js

@@ -1,3 +1,3 @@
 import {Grid} from "./lib/efx-grid.js";
 export {Grid}
-window.EFX_GRID = { version: "6.0.16" };
+window.EFX_GRID = { version: "6.0.17" };

package/lib/tr-grid-column-grouping/es6/ColumnGrouping.d.ts

@@ -24,12 +24,12 @@ declare class ColumnGroupingPlugin extends GridPlugin {
 
     constructor(options?: ColumnGroupingPlugin.Options|null);
 
-    public beforeProcessOption(optionName: string, optionValue: any): any;
-
     public getName(): string;
 
     public initialize(host: any, options?: any): void;
 
+    public beforeProcessOption(optionName: string, optionValue: any): any;
+
     public unload(host: any): void;
 
     public config(options: any): void;
@@ -66,9 +66,9 @@ declare class ColumnGroupingPlugin extends GridPlugin {
 
     public getCellInfo(e: Element|Event|MouseEvent|null): any;
 
-    public moveColumnIntoGroup(from: number|string|null, to: number, groupId: string): void;
+    public moveColumnIntoGroup(colRef: number|string|null, to: number, groupId: string): void;
 
-    public setColumnParent(columnIndex: number|string|null, groupId: string): void;
+    public setColumnParent(colRef: number|string|null, groupId: string): void;
 
 }
 

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

@@ -31,6 +31,7 @@ var ColumnGroupingPlugin = function ColumnGroupingPlugin(options) {
   t._onColumnChanged = t._onColumnChanged.bind(t);
   t._onColumnAdded = t._onColumnAdded.bind(t);
   t._onColumnMoved = t._onColumnMoved.bind(t);
+  t._onColumnRemoved = t._onColumnRemoved.bind(t);
   t._requestApplyAddChildGroup = t._requestApplyAddChildGroup.bind(this);
   t._onPostSectionRender = t._onPostSectionRender.bind(t);
   t._onBeforeColumnBoundUpdate = t._onBeforeColumnBoundUpdate.bind(t);
@@ -55,6 +56,11 @@ ColumnGroupingPlugin.prototype._groupDefs;
 * @private
 */
 ColumnGroupingPlugin.prototype._groupMap;
+/** @type {!Object.<string, ColumnGroupingPlugin~GroupDefinition>}
+* @description A map of visible group id to group defintion
+* @private
+*/
+ColumnGroupingPlugin.prototype._visibleGroupMap;
 /** @type {!Object.<string, string>}
 * @description A map of child id to parent id
 * @private
@@ -99,20 +105,6 @@ ColumnGroupingPlugin._getTooltip = function (groupingOptions) {
   }
   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}
 */
@@ -142,7 +134,7 @@ ColumnGroupingPlugin.prototype.initialize = function (host, options) {
   if (this._hosts.length === 1) {
     host.listen("columnAdded", this._onColumnAdded);
     host.listen("columnMoved", this._onColumnMoved);
-    host.listen("columnRemoved", this._onColumnChanged);
+    host.listen("columnRemoved", this._onColumnRemoved);
     host.listen("columnVisibilityChanged", this._onColumnChanged);
     host.listen("postSectionRender", this._onPostSectionRender);
     host.listen("beforeColumnBoundUpdate", this._onBeforeColumnBoundUpdate);
@@ -162,6 +154,20 @@ ColumnGroupingPlugin.prototype.initialize = function (host, options) {
   }
   // TODO: wrong render group in hide/show column
 };
+/** 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
+};
 /**
 * @protected
 * @ignore
@@ -180,7 +186,7 @@ ColumnGroupingPlugin.prototype.unload = function (host) {
   this._hosts.splice(at, 1);
   host.unlisten("columnAdded", this._onColumnChanged);
   host.unlisten("columnMoved", this._onColumnMoved);
-  host.unlisten("columnRemoved", this._onColumnChanged);
+  host.unlisten("columnRemoved", this._onColumnRemoved);
   host.unlisten("postSectionRender", this._onPostSectionRender);
   host.unlisten("beforeColumnBoundUpdate", this._onBeforeColumnBoundUpdate);
   if (!this._hosts.length) {
@@ -205,8 +211,20 @@ ColumnGroupingPlugin.prototype.config = function (options) {
   }
   var extOptions = options["columnGrouping"];
   if (Array.isArray(extOptions)) {
-    this._groupDefs = extOptions.filter(ColumnGroupingPlugin._isValidGroup).map(ColumnGroupingPlugin._cloneObject);
+    var groupDefs = extOptions.map(ColumnGroupingPlugin._cloneObject);
+    this._groupDefs = groupDefs.filter(ColumnGroupingPlugin._isValidGroup);
+  }
+  var columns = options["columns"];
+  if (!columns) {
+    return;
   }
+  var len = columns.length;
+  for (var i = 0; i < len; ++i) {
+    this._setColumnGrouping(i, {
+      id: columns[i].id
+    }); // used for columnRemoved event
+  }
+
   this._migrateLegacyStructure(options["columns"]);
 };
 /** @public
@@ -218,13 +236,26 @@ ColumnGroupingPlugin.prototype.getConfigObject = function (gridOptions) {
 
   // TODO: Handle legacyRender method that has been migrated
   var columnGroupingDefs = this.getGroupDefinitions();
-  for (var i = 0; i < columnGroupingDefs.length; i++) {
-    columnGroupingDefs[i] = this._groupMap[columnGroupingDefs[i].id];
-  }
   obj.columnGrouping = columnGroupingDefs;
   return obj;
 };
 
+/** @private
+* @param {number} colIndex
+* @param {Object} data
+*/
+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
@@ -274,7 +305,7 @@ ColumnGroupingPlugin.prototype._migrateLegacyStructure = function (colModels) {
 
   // Add new definitions and structure to the given legacy objects
   for (i = 0; i < groupCount; ++i) {
-    groupDef = legacyColumnGroups[i];
+    groupDef = cloneObject(legacyColumnGroups[i]);
     if (groupDef && groupDef.id) {
       // WARNING: Modify user's object
       var childAry = groupMap[groupDef.id];
@@ -313,6 +344,7 @@ ColumnGroupingPlugin.prototype._applyGrouping = function () {
         for (r = 0; r < rowCount; r++) {
           cell = section.getCell(c, r, false);
           if (cell) {
+            cell.reset();
             cell.removeClass("no-sort");
             cell.removeAttribute("group-id");
           }
@@ -333,6 +365,173 @@ ColumnGroupingPlugin.prototype._applyGrouping = function () {
     }
   }
 };
+/** @private
+*/
+ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
+  // Clear existing group structure
+  var groupMap = this._groupMap = {};
+  var childToParent = this._childToParent = {};
+  var visibleGroupMap = this._visibleGroupMap = {};
+  this._maxDepth = -1;
+
+  // Flatten tree structure to simple dictionary
+  var groupDefs = this._groupDefs;
+  var len = groupDefs.length;
+  var i;
+  for (i = 0; i < len; i++) {
+    this._flattenGroupDefs(groupDefs[i], groupDefs);
+  }
+
+  // Create group map
+  var groupDef;
+  len = groupDefs.length; // length can be changed after flattening
+  for (i = 0; i < len; i++) {
+    groupDef = groupDefs[i];
+    groupMap[groupDef.id] = groupDef;
+
+    // Clone group definitions for rendering
+    visibleGroupMap[groupDef.id] = cloneObject(groupDef);
+    visibleGroupMap[groupDef.id].children = groupDef.children.slice();
+  }
+
+  // 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;
+    }
+  }
+
+  // Apply a parent id to group definition to make it easier to find depth
+  var parentId;
+  for (gid in visibleGroupMap) {
+    parentId = childToParent[gid];
+    if (parentId) {
+      visibleGroupMap[gid].parent = parentId;
+      groupMap[gid].parent = parentId;
+    }
+  }
+
+  // Filter invisible groups out
+  var rootGroup = [];
+  for (gid in visibleGroupMap) {
+    groupDef = visibleGroupMap[gid];
+    if (this._findGroupTreeDepth(groupDef, 1) === 1) {
+      rootGroup.push(groupDef);
+    }
+  }
+  len = rootGroup.length;
+  for (i = 0; i < len; i++) {
+    this._verifySingleChild(rootGroup[i]);
+  }
+
+  // Determine the depth of each group
+  var depth;
+  for (gid in visibleGroupMap) {
+    groupDef = visibleGroupMap[gid];
+    depth = this._findGroupTreeDepth(groupDef, 1);
+    groupDef["onRow"] = depth - 1;
+  }
+
+  // Calculate the maximum depth
+  var maxDepth = -1;
+  for (gid in visibleGroupMap) {
+    groupDef = visibleGroupMap[gid];
+    depth = groupDef["onRow"];
+    if (depth > maxDepth) {
+      maxDepth = depth;
+    }
+  }
+  this._maxDepth = maxDepth + 1; // Column header depth = maximum group depth + 1
+};
+
+/** Flatten group definition structure by using group ID instead of nested group definitions.
+*  @private
+* @param {Object} groupDef
+* @param {Array} groupDefs
+*/
+ColumnGroupingPlugin.prototype._flattenGroupDefs = function (groupDef, groupDefs) {
+  if (groupDef && groupDef.children) {
+    var children = groupDef.children;
+    var member, groupId;
+    for (var i = 0; i < children.length; i++) {
+      member = children[i];
+      if (typeof member !== "string") {
+        // member is nested group definition
+        groupId = member.id;
+        if (groupId) {
+          children[i] = groupId; // Use group ID instead of nested group definition
+          if (groupDefs.indexOf(member) < 0) {
+            groupDefs.push(member);
+          }
+          this._flattenGroupDefs(member, groupDefs);
+        }
+      }
+    }
+  }
+};
+
+/** @private
+* @param {Object} groupDef
+* @param {number} currentDepth
+* @return {number}
+*/
+ColumnGroupingPlugin.prototype._findGroupTreeDepth = function (groupDef, currentDepth) {
+  var parentId = groupDef["parent"];
+  var parentNode = this._visibleGroupMap[parentId];
+  if (parentNode) {
+    return this._findGroupTreeDepth(parentNode, currentDepth + 1);
+  } else {
+    return currentDepth;
+  }
+};
+
+/** @private
+* @param {Object} groupDef
+* @return {boolean}
+*/
+ColumnGroupingPlugin.prototype._verifySingleChild = function (groupDef) {
+  var children = groupDef.children;
+  var visibleChildCount = 0;
+  var visibleChildGroupCount = 0;
+  var invisibleMembers = [];
+  var i, member;
+  for (i = 0; i < children.length; i++) {
+    member = children[i];
+    if (this._visibleGroupMap[member]) {
+      if (this._verifySingleChild(this._visibleGroupMap[member])) {
+        ++visibleChildCount;
+        ++visibleChildGroupCount;
+      } else {
+        invisibleMembers.push(member);
+      }
+    } else {
+      if (this._getColumnIndexById(member) > -1) {
+        ++visibleChildCount;
+      } else {
+        invisibleMembers.push(member);
+      }
+    }
+  }
+
+  // Remove invisible members, keep only visible members
+  if (invisibleMembers.length) {
+    for (i = 0; i < invisibleMembers.length; i++) {
+      member = invisibleMembers[i];
+      groupDef.children.splice(children.indexOf(member), 1);
+    }
+  }
+  if (visibleChildCount > 1 || visibleChildGroupCount > 1) {
+    return true;
+  } else {
+    delete this._visibleGroupMap[groupDef.id];
+    return false;
+  }
+};
+
 /** Set a timer to call applyGrouping only once to avoid performance issue
 * @private
 */
@@ -404,7 +603,7 @@ ColumnGroupingPlugin.prototype._spanGroupVertically = function (titleSection) {
 */
 ColumnGroupingPlugin.prototype._spanGroupHorizontally = function (titleSection) {
   var section = titleSection;
-  var groupTable = this._groupMap;
+  var groupTable = this._visibleGroupMap;
 
   // Span column of column group
   for (var id in groupTable) {
@@ -427,7 +626,7 @@ ColumnGroupingPlugin.prototype._spanGroupHorizontally = function (titleSection)
 */
 ColumnGroupingPlugin.prototype._renderGroups = function () {
   var hostCount = this._hosts.length;
-  var groupMap = this._groupMap;
+  var groupMap = this._visibleGroupMap;
   for (var i = 0; i < hostCount; ++i) {
     var section = this._hosts[i].getSection("title");
     if (!section) {
@@ -515,8 +714,8 @@ ColumnGroupingPlugin.prototype._applyTimeSeries = function (e) {
         var parentName = tsParentDef.getName();
         var parentId = tsParentDef.getId();
         var groupId = "timeSerieGroup_" + parentId;
-        var getGroupDefintion = this.getGroupDefinition(groupId);
-        if (getGroupDefintion) {
+        var groupDef = this._groupMap[groupId];
+        if (groupDef) {
           // add children time series field to parent
           for (i = 0; i < children.length; i++) {
             var child = children[i];
@@ -581,6 +780,31 @@ ColumnGroupingPlugin.prototype._onColumnMoved = function (e) {
 /** @private
 * @param {Object} e
 */
+ColumnGroupingPlugin.prototype._onColumnRemoved = function (e) {
+  var colData = e.columnData;
+  if (colData && colData.columnGrouping) {
+    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();
+        }
+      }
+    }
+  }
+};
+/** @private
+* @param {Object} e
+*/
 ColumnGroupingPlugin.prototype._onBeforeColumnBoundUpdate = function (e) {
   var selectedColumns = e.selectedColumns;
   var parentMap = this._childToParent;
@@ -721,6 +945,7 @@ ColumnGroupingPlugin.prototype.removeGroup = function (groupId) {
 */
 ColumnGroupingPlugin.prototype.setGroupDefinitions = function (groupDefs) {
   if (Array.isArray(groupDefs)) {
+    groupDefs = groupDefs.map(ColumnGroupingPlugin._cloneObject);
     groupDefs = groupDefs.filter(ColumnGroupingPlugin._isValidGroup);
     if (!groupDefs.length) {
       groupDefs = null;
@@ -777,6 +1002,7 @@ ColumnGroupingPlugin.prototype.setGroupDefinition = function (groupId, newDef) {
   var curDef = this.getGroupDefinition(groupId);
   if (curDef) {
     var at = this._groupDefs.indexOf(curDef);
+    newDef = cloneObject(newDef);
     newDef.id = groupId;
     this._groupDefs[at] = newDef;
     this._applyGrouping();
@@ -832,11 +1058,11 @@ ColumnGroupingPlugin.prototype.getChildColumnIndices = function (groupId) {
   if (group) {
     var colIds = this._getGroupMembers(group);
     var colIndices = [];
-    var id;
+    var index;
     for (var i = 0; i < colIds.length; i++) {
-      id = this._getColumnIndexById(colIds[i]);
-      if (id > -1) {
-        colIndices.push(id);
+      index = this.getColumnIndex(colIds[i]);
+      if (index > -1) {
+        colIndices.push(index);
       }
     }
     return colIndices.sort();
@@ -860,7 +1086,7 @@ ColumnGroupingPlugin.prototype.getGroupIds = function (colRef) {
         var groupIds = [groupId];
         var group = this._groupMap[groupId];
         while (group && group.parent) {
-          group = this.getGroupDefinition(group.parent);
+          group = this._groupMap[group.parent];
           if (group) {
             groupIds.push(group.id);
           }
@@ -886,7 +1112,7 @@ ColumnGroupingPlugin.prototype.getMaxGroupLevel = function () {
 * @return {number}
 */
 ColumnGroupingPlugin.prototype.getGroupLevel = function (groupId) {
-  var group = this._groupMap[groupId];
+  var group = this._visibleGroupMap[groupId];
   if (group) {
     return group.onRow;
   }
@@ -927,106 +1153,11 @@ ColumnGroupingPlugin.prototype._getRootGroup = function (groupId) {
   }
   var group = this._groupMap[groupId];
   while (group.parent) {
-    group = this.getGroupDefinition(group.parent);
+    group = this._groupMap[group.parent];
   }
   return group;
 };
 
-/** @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]) {
-      this._groupMap[node.id] = cloneObject(node); // clone node
-    }
-  }
-};
-/** @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
@@ -1056,20 +1187,20 @@ ColumnGroupingPlugin.prototype._findColumnIndexArr = function (node, cluster) {
       for (var i = 0; i < childrens.length; i++) {
         var child = childrens[i];
         if (!child.id) {
-          if (!this._groupMap[child]) {
+          if (!this._visibleGroupMap[child]) {
             var colIndex = this._getColumnIndexById(child);
             if (colIndex !== -1) {
               cluster.push(colIndex);
             }
           } else {
-            this._findColumnIndexArr(this._groupMap[child], cluster);
+            this._findColumnIndexArr(this._visibleGroupMap[child], cluster);
           }
         } else {
           // skip children that has same id as parent
           if (child.id === node.id) {
             return;
           }
-          this._findColumnIndexArr(this._groupMap[child.id], cluster);
+          this._findColumnIndexArr(this._visibleGroupMap[child.id], cluster);
         }
       }
     }
@@ -1123,11 +1254,10 @@ ColumnGroupingPlugin._groupConsecutiveArr = function (arr) {
 * @param {string} groupId
 */
 ColumnGroupingPlugin.prototype._addGroupChild = function (childId, groupId) {
-  var groupDef = this.getGroupDefinition(groupId);
+  var groupDef = this._groupMap[groupId];
   if (childId && groupDef) {
     var chdr = groupDef.children;
     if (chdr && chdr.indexOf(childId) < 0) {
-      this._childToParent[childId] = groupId;
       chdr.push(childId);
     }
   }
@@ -1137,7 +1267,7 @@ ColumnGroupingPlugin.prototype._addGroupChild = function (childId, groupId) {
 * @return {ColumnGroupingPlugin~GroupDefinition}
 */
 ColumnGroupingPlugin.prototype._getParentGroup = function (childId) {
-  return this.getGroupDefinition(this._childToParent[childId]);
+  return this._visibleGroupMap[this._childToParent[childId]];
 };
 /** @private
 * @param {string} colId
@@ -1195,16 +1325,16 @@ ColumnGroupingPlugin.prototype.getCellInfo = function (e) {
   return cellInfo;
 };
 /** @public
-* @param {number|string} from //Column index or id that should be moved
+* @param {number|string} colRef //Column index or id that should be moved
 * @param {number} to
 * @param {string} groupId
 */
-ColumnGroupingPlugin.prototype.moveColumnIntoGroup = function (from, to, groupId) {
+ColumnGroupingPlugin.prototype.moveColumnIntoGroup = function (colRef, to, groupId) {
   var fromIndex = -1;
-  if (typeof from == "string") {
-    fromIndex = this._getColumnIndexById(from);
+  if (typeof colRef == "string") {
+    fromIndex = this._getColumnIndexById(colRef);
   } else {
-    fromIndex = from;
+    fromIndex = colRef;
   }
   if (fromIndex == -1) {
     return;
@@ -1280,17 +1410,17 @@ ColumnGroupingPlugin.prototype.moveColumnIntoGroup = function (from, to, groupId
   this._requestApplyGrouping();
 };
 /** @public
-* @param {number|string} columnIndex //Column index or id that should be moved
+* @param {number|string} colRef //Column index or id that should be moved
 * @param {string} groupId
 */
-ColumnGroupingPlugin.prototype.setColumnParent = function (columnIndex, groupId) {
+ColumnGroupingPlugin.prototype.setColumnParent = function (colRef, groupId) {
   var api = this.getGridApi();
   if (!api) {
     return;
   }
   var grid = this._hosts[0];
   var colCount = grid.getColumnCount();
-  this.moveColumnIntoGroup(columnIndex, colCount, groupId);
+  this.moveColumnIntoGroup(colRef, colCount, groupId);
 };
 export default ColumnGroupingPlugin;
 export { ColumnGroupingPlugin, ColumnGroupingPlugin as ColumnGrouping, ColumnGroupingPlugin as ColumnGroupingExtension };

package/lib/tr-grid-column-stack/es6/ColumnStack.d.ts

@@ -11,7 +11,8 @@ declare namespace ColumnStackPlugin {
 
     type Options = {
         fields: (string)[]|null,
-        stacks: (ColumnStackPlugin.StackDefinition)[]|null
+        stacks: (ColumnStackPlugin.StackDefinition)[]|null,
+        autoStacking?: boolean|null
     };
 
     type ColumnOptions = {
@@ -30,6 +31,7 @@ declare namespace ColumnStackPlugin {
         spreading?: boolean|null,
         collapsed?: boolean|null,
         children: (string)[]|null,
+        fields: (string)[]|null,
         name?: string|null,
         activeColumn?: string|null
     };
@@ -100,6 +102,8 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public getColumnIndicesByColumnIds(columnId: string|(string)[]|null): (string)[];
 
+    public getColumnIdsByFields(field: string|(string)[]|null): (string)[];
+
     public addColumnToStack(colRef: number|string|null, stackId: string): void;
 
     public removeColumnFromStack(colRef: number|string|null): void;
@@ -110,6 +114,8 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public getStackName(stackId: string): string;
 
+    public getActiveColumnField(stackId: string): string;
+
 }
 
 export default ColumnStackPlugin;