@refinitiv-ui/efx-grid 6.0.37 → 6.0.39

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

@@ -89,6 +89,10 @@ declare class ColumnGroupingPlugin extends GridPlugin {
 
     public moveColumnById(srcCol: number|string|null, destCol?: (number|string)|null): boolean;
 
+    public pinGroup(groupId: string, side?: string|null): void;
+
+    public unpinGroup(groupId: string, dest?: (number|string)|null): void;
+
 }
 
 export default ColumnGroupingPlugin;

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

@@ -36,6 +36,7 @@ var ColumnGroupingPlugin = function ColumnGroupingPlugin(options) {
   t._requestApplyAddChildGroup = t._requestApplyAddChildGroup.bind(this);
   t._onPostSectionRender = t._onPostSectionRender.bind(t);
   t._onBeforeColumnBoundUpdate = t._onBeforeColumnBoundUpdate.bind(t);
+  t._onPinningChanged = t._onPinningChanged.bind(this);
   t._groupDefs = new GroupDefinitions();
   if (options) {
     t.config({
@@ -83,6 +84,10 @@ ColumnGroupingPlugin.prototype._addingEvents = null;
 * @private
 */
 ColumnGroupingPlugin.prototype._legacyColumnGroups = null;
+/** @type {boolean}
+* @private
+*/
+ColumnGroupingPlugin.prototype._inPinning = false;
 
 /** @private
 * @param {number} a
@@ -237,6 +242,7 @@ ColumnGroupingPlugin.prototype.initialize = function (host, options) {
     host.listen("columnVisibilityChanged", this._onColumnChanged);
     host.listen("postSectionRender", this._onPostSectionRender);
     host.listen("beforeColumnBoundUpdate", this._onBeforeColumnBoundUpdate);
+    host.listen("pinningChanged", this._onPinningChanged);
   }
   this.config(options);
   this._legacyColumnGroups = null;
@@ -290,6 +296,7 @@ ColumnGroupingPlugin.prototype.unload = function (host) {
   host.unlisten("columnRemoved", this._onColumnRemoved);
   host.unlisten("postSectionRender", this._onPostSectionRender);
   host.unlisten("beforeColumnBoundUpdate", this._onBeforeColumnBoundUpdate);
+  host.unlisten("pinningChanged", this._onPinningChanged);
   if (!this._hosts.length) {
     if (this._rerenderTimerId) {
       clearTimeout(this._rerenderTimerId);
@@ -408,7 +415,50 @@ ColumnGroupingPlugin.prototype._migrateLegacyStructure = function (groupDefs, co
   }
   return groupDefs.filter(ColumnGroupingPlugin._hasGroupId);
 };
-
+/** @private
+* @param {number} frozenColIndex
+* @param {number=} numRightColumn
+*/
+ColumnGroupingPlugin.prototype._freezeColumn = function (frozenColIndex, numRightColumn) {
+  this._inPinning = true;
+  var hosts = this._hosts;
+  for (var i = 0; i < hosts.length; i++) {
+    hosts[i].freezeColumn(frozenColIndex, numRightColumn);
+  }
+  this._inPinning = false;
+};
+/** @private
+*/
+ColumnGroupingPlugin.prototype._applyPinning = function () {
+  var colCount = this.getColumnCount();
+  var columnIds = this.getColumnIds();
+  var leftPinnedIndex = this._hosts[0].getFrozenColumnCount() - 1;
+  var rightPinnedIndex = this._hosts[0].getFirstPinnedRightIndex();
+  var i, groupId, groupDef;
+  var dirty = false;
+  for (i = colCount; i > leftPinnedIndex; i--) {
+    groupId = this._groupDefs.getParentId(columnIds[i]);
+    groupDef = this._visibleGroupMap[groupId];
+    if (groupDef && groupDef.leftPinned) {
+      leftPinnedIndex = i;
+      dirty = true;
+      break;
+    }
+  }
+  for (i = leftPinnedIndex; i < rightPinnedIndex; i++) {
+    groupId = this._groupDefs.getParentId(columnIds[i]);
+    groupDef = this._visibleGroupMap[groupId];
+    if (groupDef && groupDef.rightPinned) {
+      rightPinnedIndex = i;
+      dirty = true;
+      break;
+    }
+  }
+  if (dirty) {
+    var rightPinnedCount = colCount - rightPinnedIndex;
+    this._freezeColumn(leftPinnedIndex, rightPinnedCount);
+  }
+};
 /** Consolidate and process configuration. Force rerendering on column adding, removing, moving, initializaing, and run-time API execution.
 * @private
 */
@@ -419,6 +469,9 @@ ColumnGroupingPlugin.prototype._applyGrouping = function () {
   }
   this._restructuring = true;
   this._evaluateGroupStructure();
+
+  // Apply column pinning
+  this._applyPinning();
   var i, c, r, cell, section, colCount;
   var rowCount = this._maxDepth + 1;
   var hostCount = this._hosts.length;
@@ -462,6 +515,7 @@ ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
   // Clone group definitions for rendering
   var visibleGroupMap = this._visibleGroupMap = this._groupDefs.cloneGroupMap();
   this._verifySingleChild(visibleGroupMap);
+  this._verifyColumnPinning(visibleGroupMap);
 
   // Update depth (onRow) and parentId
   var maxDepth = this._maxDepth = -1;
@@ -483,6 +537,65 @@ ColumnGroupingPlugin.prototype._evaluateGroupStructure = function () {
   this._maxDepth = maxDepth + 1; // Column header depth = maximum group depth + 1
 };
 
+/** @private Add pinning state to group definition for further verification.
+* @param {Object} groupDef
+* @param {string} side
+*/
+ColumnGroupingPlugin.prototype._setGroupPinning = function (groupDef, side) {
+  if (!groupDef || groupDef.leftPinned || groupDef.rightPinned) {
+    return;
+  }
+  if (side === "left") {
+    groupDef.leftPinned = true;
+  } else {
+    groupDef.rightPinned = true;
+  }
+  var children = groupDef["children"];
+  for (var i = 0; i < children.length; i++) {
+    var child = children[i];
+    var group = this._visibleGroupMap[child];
+    if (group) {
+      this._setGroupPinning(group, side);
+    }
+  }
+};
+
+/** @private
+* @param {Object} groupMap
+*/
+ColumnGroupingPlugin.prototype._verifyColumnPinning = function (groupMap) {
+  var host = this._hosts[0];
+  var leftPinnedIndex = host.getFrozenColumnCount() - 1;
+  var rightPinnedIndex = host.getFirstPinnedRightIndex();
+  var colCount = this.getColumnCount();
+  var i, groupId, rootGroup, colId;
+  var groupDefs = this._groupDefs;
+  var visibleGroupMap = this._visibleGroupMap;
+  if (leftPinnedIndex >= 0) {
+    for (i = leftPinnedIndex; i >= 0; i--) {
+      colId = this.getColumnId(i);
+      groupId = groupDefs.getParentId(colId);
+      if (groupId && visibleGroupMap[groupId]) {
+        rootGroup = groupDefs.getRootGroup(groupId);
+        if (rootGroup) {
+          this._setGroupPinning(visibleGroupMap[rootGroup["id"]], "left");
+        }
+      }
+    }
+  }
+  if (rightPinnedIndex < colCount) {
+    for (i = rightPinnedIndex; i < colCount; i++) {
+      colId = this.getColumnId(i);
+      groupId = groupDefs.getParentId(colId);
+      if (groupId && visibleGroupMap[groupId]) {
+        rootGroup = groupDefs.getRootGroup(groupId);
+        if (rootGroup) {
+          this._setGroupPinning(visibleGroupMap[rootGroup["id"]], "right");
+        }
+      }
+    }
+  }
+};
 /** @private
 * @param {Object} groupMap
 */
@@ -814,6 +927,22 @@ ColumnGroupingPlugin.prototype._onColumnRemoved = function (e) {
 /** @private
 * @param {Object} e
 */
+ColumnGroupingPlugin.prototype._onPinningChanged = function (e) {
+  if (!this._inPinning) {
+    // Clear current pinning states
+    var groupMap = this._visibleGroupMap;
+    for (var groupId in groupMap) {
+      var groupDef = groupMap[groupId];
+      groupDef.leftPinned = false;
+      groupDef.rightPinned = false;
+    }
+    this._verifyColumnPinning();
+    this._applyPinning();
+  }
+};
+/** @private
+* @param {Object} e
+*/
 ColumnGroupingPlugin.prototype._onBeforeColumnBoundUpdate = function (e) {
   var selectedColumns = e.selectedColumns; // Hidden columns are included
 
@@ -1362,7 +1491,12 @@ ColumnGroupingPlugin.prototype.removeGroupChild = function (parentId, childRef)
   if (!colId) {
     return false;
   }
-  var leafIndices = this.getChildColumnIndices(parentId);
+  var rootId = parentId;
+  var group = this._visibleGroupMap[parentId];
+  if (group.onRow !== 0) {
+    rootId = this._groupDefs.getParentId(parentId, 0);
+  }
+  var leafIndices = this.getChildColumnIndices(rootId);
   if (this._groupDefs.removeGroupChild(parentId, colId)) {
     if (leafIndices && leafIndices.length > 1) {
       if (this.moveColumnById(colId, leafIndices[leafIndices.length - 1] + 1)) {
@@ -1510,5 +1644,90 @@ ColumnGroupingPlugin.prototype.moveColumnById = function (srcCol, destCol) {
   this._autoGrouping = true;
   return dirty;
 };
+/** @public
+* @param {string} groupId
+* @param {string=} side Available values are: left|right. If no value is supplied, all columns will be pinned to the left.
+*/
+ColumnGroupingPlugin.prototype.pinGroup = function (groupId, side) {
+  if (!groupId) {
+    return;
+  }
+  var groupDef = this._visibleGroupMap[groupId];
+  if (!groupDef) {
+    return;
+  }
+  var host = this._hosts[0];
+  var leftPinnedIndex = host.getFrozenColumnCount() - 1;
+  var rightPinnedCount = host.getPinnedRightColumnCount();
+  var colCount = this.getColumnCount();
+  var colList = this.getChildColumnIndices(groupId);
+  var len = colList.length;
+  var dest;
+  if (side === "right") {
+    if (groupDef.rightPinned) {
+      return;
+    }
+    if (groupDef.leftPinned) {
+      this.unpinGroup(groupId);
+      leftPinnedIndex = host.getFrozenColumnCount() - 1;
+    }
+    groupDef.rightPinned = true;
+    dest = colCount - rightPinnedCount;
+    rightPinnedCount = rightPinnedCount + len;
+  } else {
+    if (groupDef.leftPinned) {
+      return;
+    }
+    if (groupDef.rightPinned) {
+      this.unpinGroup(groupId);
+      rightPinnedCount = host.getPinnedRightColumnCount();
+    }
+    groupDef.leftPinned = true;
+    dest = leftPinnedIndex === -1 ? 0 : leftPinnedIndex + 1;
+    leftPinnedIndex = leftPinnedIndex + len;
+  }
+  this.moveGroup(groupId, dest);
+  this._freezeColumn(leftPinnedIndex, rightPinnedCount);
+};
+/** @public
+* @param {string} groupId
+* @param {(number|string)=} dest The unpinned group will be placed before the destination position after the operation
+*/
+ColumnGroupingPlugin.prototype.unpinGroup = function (groupId, dest) {
+  if (!groupId) {
+    return;
+  }
+  var groupDef = this._visibleGroupMap[groupId];
+  if (!groupDef) {
+    return;
+  }
+  if (!groupDef.leftPinned && !groupDef.rightPinned) {
+    return;
+  }
+  var host = this._hosts[0];
+  var leftPinnedCount = host.getFrozenColumnCount();
+  var rightPinnedCount = host.getPinnedRightColumnCount();
+  var colCount = this.getColumnCount();
+  var firstRightPinnedIndex = colCount - rightPinnedCount;
+  var colList = this.getChildColumnIndices(groupId);
+  var len = colList.length;
+  var destId = null;
+  if (dest != null) {
+    var destIdx = this.getColumnIndex(dest);
+    destId = this.getColumnId(destIdx);
+  }
+  if (groupDef.leftPinned) {
+    groupDef.leftPinned = false;
+    this.moveGroup(groupId, leftPinnedCount);
+    this._freezeColumn(leftPinnedCount - (1 + len));
+  } else if (groupDef.rightPinned) {
+    groupDef.rightPinned = false;
+    this.moveGroup(groupId, firstRightPinnedIndex);
+    this._freezeColumn(leftPinnedCount - 1, rightPinnedCount - len);
+  }
+  if (destId != null) {
+    this.moveGroup(groupId, destId);
+  }
+};
 export default ColumnGroupingPlugin;
 export { ColumnGroupingPlugin, ColumnGroupingPlugin as ColumnGrouping, ColumnGroupingPlugin as ColumnGroupingExtension };

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

@@ -84,7 +84,7 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public isColumnActive(colIndex: number): boolean;
 
-    public getStackId(colIndex: number): string;
+    public getStackId(colRef: number|string|null): string;
 
     public stackColumns(colRefs?: (number|string)[]|null, stackId?: string|null, options?: ColumnStackPlugin.StackConfiguration|null): boolean;
 
@@ -96,6 +96,8 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public removeAllStacks(enableUpdateUI?: boolean|null): boolean;
 
+    public setActiveColumn(activeColumn: number|string|null): boolean;
+
     public swapColumn(colRef: number|Event|null, swappingIndex: number): boolean;
 
     public getStackMemberIndices(stackId: string): (number)[];
@@ -140,6 +142,10 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public moveStack(stackId: string, destCol?: (number|string)|null): boolean;
 
+    public pinStack(stackId: string, side?: string|null): void;
+
+    public unpinStack(stackId: string, dest?: (number|string)|null): void;
+
 }
 
 export default ColumnStackPlugin;