@refinitiv-ui/efx-grid 6.0.2 → 6.0.5

package/lib/tr-grid-util/es6/NumberFormatter.js

@@ -13,6 +13,22 @@
 * @property {boolean=} mutiplyBy100=false Alias of multiplyBy100
 */
 
+/** @private
+* @function
+* @param {number} num Absolute number
+* @return {number}
+*/
+var _multiplyByHundred = function(num) {
+	var intPart = num | 0;
+	if(intPart && num > intPart) {
+		var str = num + "";
+		var at = str.indexOf(".");
+		var fracStr = str.slice(at + 1) + "00";
+		return +(str.slice(0, at) + fracStr.slice(0, 2) + "." + fracStr.slice(2));
+	}
+	return num * 100;
+};
+
 /** NumberFormatter provides a way to format the given number quickly.
 * @constructor
 * @param {NumberFormatter~Options=} options
@@ -198,6 +214,24 @@ NumberFormatter.padDecimalPartWithZeroes = function (str, precision) {
 	}
 	return str;
 };
+/** @public
+* @function
+* @param {number} num
+* @return {number}
+* @example
+* NumberFormatter.multiplyByHundred(1); // 1
+* NumberFormatter.multiplyByHundred(1.1); // 110
+* NumberFormatter.multiplyByHundred(1.21); // 121
+* NumberFormatter.multiplyByHundred(1.321); // 132.1
+* NumberFormatter.multiplyByHundred(-1.4321); // -143.21
+*/
+NumberFormatter.multiplyByHundred = function (num) {
+	if(num < 0) {
+		return -(_multiplyByHundred(-num));
+	}
+	return _multiplyByHundred(num);
+};
+
 
 /** @public
 * @param {Object=} options
@@ -206,20 +240,28 @@ NumberFormatter.padDecimalPartWithZeroes = function (str, precision) {
 NumberFormatter.prototype.getOptions = function(options) { // serialize
 	if(!options) { options = {}; }
 
+	var formatType = options["formatType"];
+
 	options["precisionEnabled"] = this._precisionEnabled;
 	options["decimalPlaces"] = this._precision;
 	options["plusSign"] = this._plusSignEnabled;
 	options["separator"] = this._separatorEnabled;
-	options["percentSign"] = this._percentSignEnabled;
-	var su = "";
-	if(this._scaler == "b") {
-		su = "billion";
-	} else if(this._scaler == "m") {
-		su = "million";
+
+	if(formatType === "scaled" || formatType === "scaledvalue") {
+		var su = "";
+		if(this._scaler == "b") {
+			su = "billion";
+		} else if(this._scaler == "m") {
+			su = "million";
+		}
+		options["scalingUnit"] = su;
+	}
+
+	if(formatType === "percent") {
+		options["percentSign"] = this._percentSignEnabled;
+		options["mutiplyBy100"] = this._multiplyBy100Enabled;
+		options["multiplyBy100"] = this._multiplyBy100Enabled;
 	}
-	options["scalingUnit"] = su;
-	options["mutiplyBy100"] = this._multiplyBy100Enabled;
-	options["multiplyBy100"] = this._multiplyBy100Enabled;
 	return options;
 };
 
@@ -240,7 +282,7 @@ NumberFormatter.prototype.format = function(origVal) {
 		}
 	}
 
-	// Make value to be positive value for simpler logic
+	// Simplify logic by making positive value
 	var val, sign;
 	if(origVal >= 0) {
 		val = origVal;
@@ -249,14 +291,18 @@ NumberFormatter.prototype.format = function(origVal) {
 		val = -origVal;
 		sign = "-";
 	}
-	if(this._multiplyBy100Enabled) {
-		val = val * 100;
-	}
-	var absVal = val;
 	var scalingMode = this._percentFormatEnabled ? "" : this._scaler; // Percent formatting overwrite scaling mode
 
-	// Perform rounding
+	if(this._multiplyBy100Enabled) {
+		if(this._precisionEnabled || scalingMode) {
+			val = val * 100; // Since value will be rounded later, there is no need to avoid rounding issue
+		} else {
+			val = _multiplyByHundred(val);
+		}
+	}
 
+	var absVal = val;
+	// Perform scaling
 	if (scalingMode) {
 		if (scalingMode === "b" && val < 1e9) {
 			scalingMode = "m";
@@ -270,11 +316,8 @@ NumberFormatter.prototype.format = function(origVal) {
 		} else if (scalingMode === "b") {
 			val = val / 1e9;
 		}
-
-		if (!this._precisionEnabled) {
-			val = Math.round(val * 100) / 100;
-		}
 	}
+	// Perform rounding
 	if (this._precisionEnabled) {
 		if (this._precision > 0) {
 			var deno = NumberFormatter._denominator[this._precision];
@@ -282,6 +325,8 @@ NumberFormatter.prototype.format = function(origVal) {
 		} else {
 			val = Math.round(val);
 		}
+	} else if(scalingMode) {
+		val = Math.round(val * 100) / 100;
 	}
 
 	// Convert value to string

package/lib/tr-grid-util/es6/RowPainter.js

@@ -13,6 +13,7 @@ var RowPainter = function(options) {
 	this._onCellClicked = options.onCellClicked;
 	this._headerMenuClicked = options.headerMenuClicked;
 	this._menuIconClicked = this._menuIconClicked.bind(this);
+	this._segmentMode = options.segmentMode;
 };
 
 /** @type {string}
@@ -71,6 +72,29 @@ RowPainter._styles = prettifyCss([
 	]
 ]);
 
+/** @private
+* @param {Object} cell
+* @param {string=} className
+*/
+RowPainter._applyColorTagClass = function(cell, className) {
+	if (!cell) {
+		return;
+	}
+	var el = cell.getElement();
+	if (el) {
+		if (el._tagColoringClass !== className) {
+			if (el._tagColoringClass) {
+				el.classList.remove(el._tagColoringClass);
+				el._tagColoringClass = null;
+			}
+			if (className) {
+				el.classList.add(className);
+				el._tagColoringClass = className;
+			}
+		}
+	}
+};
+
 /** @public
 * @param {tr.Grid} grid
 */
@@ -108,10 +132,12 @@ RowPainter.enableHeaderMenu = function(grid, enabled) {
 * @param {number} rowIndex
 * @param {number} checkboxColumnIndex
 */
-RowPainter._clearCellContent = function(section, fromColumnIndex, toColumnIndex, rowIndex, checkboxColumnIndex) {
-	for (var c = fromColumnIndex; c <= toColumnIndex; ++c) {
-		if (section.isColumnVisible(c) && c !== checkboxColumnIndex) {
-			section.getCell(c, rowIndex, false).setContent("");
+RowPainter.prototype._clearCellContent = function(section, fromColumnIndex, toColumnIndex, rowIndex, checkboxColumnIndex) {
+	if(!this._segmentMode) {
+		for (var c = fromColumnIndex; c <= toColumnIndex; ++c) {
+			if (section.isColumnVisible(c) && c !== checkboxColumnIndex) {
+				section.getCell(c, rowIndex, false).setContent("");
+			}
 		}
 	}
 };
@@ -123,6 +149,7 @@ RowPainter._clearCellContent = function(section, fromColumnIndex, toColumnIndex,
 */
 RowPainter.prototype.removeHeaderStyle = function(section, columnIndex, rowIndex) {
 	section.enableRowClass(rowIndex, "header", false); // TODO: Slow
+	section.enableRowClass(rowIndex, "folder", false); // TODO: Slow
 	var cell = section.unstretchCell(columnIndex, rowIndex);
 	this._removeHeaderStyle(cell);
 	cell = section.getCell(columnIndex, rowIndex, false);
@@ -133,18 +160,23 @@ RowPainter.prototype.removeHeaderStyle = function(section, columnIndex, rowIndex
 * @param {Object} cell Cell container
 */
 RowPainter.prototype._removeHeaderStyle = function(cell) {
-	if(!cell || !cell._groupHeaderStyle) {
+	if(!cell) {
 		return;
 	}
-	cell._groupHeaderStyle = false;
-	cell.removeClass("folder");
-	cell.removeClass("closed");
-	cell.removeClass("content-header");
-	cell.removeClass("color-tag");
-	cell.removeClass("main-group");
-	cell.setStyle("paddingLeft", "");
-	cell.removeIcon();
-	cell.unlisten("click", this._onCellClicked);
+
+	RowPainter._applyColorTagClass(cell, "");
+
+	if(cell._groupHeaderStyle) {
+		cell._groupHeaderStyle = false;
+		cell.removeClass("folder");
+		cell.removeClass("closed");
+		cell.removeClass("content-header");
+		cell.removeClass("color-tag");
+		cell.removeClass("main-group");
+		cell.setStyle("paddingLeft", "");
+		cell.removeIcon();
+		cell.unlisten("click", this._onCellClicked);
+	}
 };
 
 /** @public
@@ -165,14 +197,14 @@ RowPainter.prototype.applyHeaderStyle = function(e) {
 	} else {
 		section.unstretchCell(mainCol, r);
 		section.enableRowClass(r, "header", true);
-
+		section.enableRowClass(r, "closed", e.collapsed ? true : false);
 		// Remove content from cell that appear on right side of mainCol
-		RowPainter._clearCellContent(section, mainCol + 1, colCount - 1, r, checkboxColumnIndex);
+		this._clearCellContent(section, mainCol + 1, colCount - 1, r, checkboxColumnIndex);
 	}
 	cell._groupHeaderStyle = true;
 
 	// Remove content from cell that appear on left side of mainCol
-	RowPainter._clearCellContent(section, 0, mainCol - 1, r, checkboxColumnIndex);
+	this._clearCellContent(section, 0, mainCol - 1, r, checkboxColumnIndex);
 
 	// Footer rows and some specific group levels contains no expander (arrow)
 	var newIcon = ExpanderIcon.renderOn(cell, e.hiddenArrow);
@@ -181,7 +213,11 @@ RowPainter.prototype.applyHeaderStyle = function(e) {
 	}
 
 	if (!footerRow) {
-		cell.addClass("folder"); // Required by the fallback arrow from the CSS rules. TODO: Change this
+		if (stretching) {
+			cell.addClass("folder"); // Stretched cell is in the cover-layer
+		} else {
+			section.enableRowClass(r, "folder", true); // Required by the fallback arrow from the CSS rules. TODO: Change this
+		}
 		if (this._clickableCell) {
 			cell.listen("click", this._onCellClicked);
 		}
@@ -201,6 +237,7 @@ RowPainter.prototype.applyHeaderStyle = function(e) {
 	}
 	cell.enableClass("closed", e.collapsed ? true : false);
 	cell.enableClass("color-tag", true);
+	RowPainter._applyColorTagClass(cell, e.colorTagClass);
 	cell.setStyle("paddingLeft", (e.indentSize > 0) ? e.indentSize + "px" : "");
 };
 
@@ -210,7 +247,7 @@ RowPainter.prototype.applyHeaderStyle = function(e) {
 */
 RowPainter.prototype.applyContentAsHeaderStyle = function (e) {
 	var cell = e.cell;
-
+	cell._groupHeaderStyle = true;
 	cell.addClass("folder"); // Required by the fallback arrow from the CSS rules. TODO: Change this
 	cell.enableClass("content-header", true);
 	cell.enableClass("closed", e.collapsed);
@@ -228,6 +265,7 @@ RowPainter.prototype.applyRowStyle = function(e) {
 	var indentSize = e.indentSize;
 	cell.setStyle("paddingLeft", (indentSize > 0) ? indentSize + "px" : "");
 	cell.enableClass("color-tag", e.nonGroupRow ? false : true);
+	RowPainter._applyColorTagClass(cell, e.colorTagClass);
 };
 
 /** @private

package/lib/tr-grid-util/es6/formula/Formula.js

@@ -345,7 +345,15 @@ Formula.toUpperCase = function(exp) {
 	exp = exp.toUpperCase(); // Upper case the remaining
 
 	// May have the new string token from ADC field with parameter
-	exp = exp.replace(/TR\.[\w_ ]+\([^\(\)]*\)(\.[a-zA-Z]+)*/g, Formula._encloseWithTR);
+	// Regex for adc fileds
+	// TR 				: start with tr
+	// (\.[\w]+)+ 		: dot follow by any character at least 1
+	// \( 				: start parentheses
+	// [^\(\)]* 		: any except parentheses
+	// \) 				: end parentheses
+	// (\.[a-zA-Z]+)* 	: dot follow by any character (optional)
+
+	exp = exp.replace(/TR(\.[\w ]+)+\([^\(\)]*\)(\.[a-zA-Z]+)*/g, Formula._encloseWithTR);
 
 	exp = Formula.resolveTokens(exp, tokens, calcHierarchy); // Restore the string
 

package/lib/tr-grid-util/es6/jsx.d.ts

@@ -0,0 +1,223 @@
+export declare namespace JSXInterface {
+	interface ControlHTMLAttributes<T> extends HTMLAttributes<T> {
+	  accept?: string;
+	  alt?: string;
+	  autoComplete?: string;
+	  autocomplete?: string;
+	  autoFocus?: boolean;
+	  autofocus?: boolean | string;
+	  capture?: string;
+	  checked?: boolean;
+	  crossOrigin?: string;
+	  crossorigin?: string;
+	  disabled?: boolean;
+	  form?: string;
+	  formAction?: string;
+	  formaction?: string;
+	  formEncType?: string;
+	  formenctype?: string;
+	  formMethod?: string;
+	  formmethod?: string;
+	  formNoValidate?: boolean;
+	  formnovalidate?: boolean;
+	  formTarget?: string;
+	  formtarget?: string;
+	  height?: number | string;
+	  list?: string;
+	  max?: number | string;
+	  maxLength?: number;
+	  maxlength?: number | string;
+	  min?: number | string;
+	  minLength?: number;
+	  minlength?: number | string;
+	  multiple?: boolean;
+	  name?: string;
+	  pattern?: string;
+	  placeholder?: string;
+	  readOnly?: boolean;
+	  readonly?: boolean | string;
+	  required?: boolean;
+	  size?: number;
+	  src?: string;
+	  step?: number | string;
+	  type?: string;
+	  value?: string | string[] | number;
+	  width?: number | string;
+	}
+	interface HTMLAttributes<T = HTMLElement> extends DOMAttributes<T> {
+	  innerHTML?: string;
+	  key?: string | number;
+	  accessKey?: string;
+	  class?: string | {
+		[className: string]: boolean;
+	  };
+	  contentEditable?: boolean | string;
+	  contenteditable?: boolean | string;
+	  contextMenu?: string;
+	  contextmenu?: string;
+	  dir?: string;
+	  draggable?: boolean;
+	  hidden?: boolean;
+	  id?: string;
+	  lang?: string;
+	  spellCheck?: boolean;
+	  spellcheck?: boolean | string;
+	  style?: {
+		[key: string]: string | undefined;
+	  };
+	  tabIndex?: number;
+	  tabindex?: number | string;
+	  title?: string;
+	  inputMode?: string;
+	  inputmode?: string;
+	  is?: string;
+	  radioGroup?: string;
+	  radiogroup?: string;
+	  part?: string;
+	  role?: string;
+	  about?: string;
+	  datatype?: string;
+	  inlist?: any;
+	  prefix?: string;
+	  property?: string;
+	  resource?: string;
+	  typeof?: string;
+	  vocab?: string;
+	  autoCapitalize?: string;
+	  autocapitalize?: string;
+	  autoCorrect?: string;
+	  autocorrect?: string;
+	  autoSave?: string;
+	  autosave?: string;
+	  color?: string;
+	  itemProp?: string;
+	  itemprop?: string;
+	  itemScope?: boolean;
+	  itemscope?: boolean;
+	  itemType?: string;
+	  itemtype?: string;
+	  itemID?: string;
+	  itemid?: string;
+	  itemRef?: string;
+	  itemref?: string;
+	  results?: number;
+	  security?: string;
+	  unselectable?: boolean;
+	}
+	interface DOMAttributes<T = Element> {
+	  ref?: any;
+	  slot?: string;
+	  children?: any;
+	  onCopy?: (event: ClipboardEvent) => void;
+	  onCopyCapture?: (event: ClipboardEvent) => void;
+	  onCut?: (event: ClipboardEvent) => void;
+	  onCutCapture?: (event: ClipboardEvent) => void;
+	  onPaste?: (event: ClipboardEvent) => void;
+	  onPasteCapture?: (event: ClipboardEvent) => void;
+	  onCompositionEnd?: (event: CompositionEvent) => void;
+	  onCompositionEndCapture?: (event: CompositionEvent) => void;
+	  onCompositionStart?: (event: CompositionEvent) => void;
+	  onCompositionStartCapture?: (event: CompositionEvent) => void;
+	  onCompositionUpdate?: (event: CompositionEvent) => void;
+	  onCompositionUpdateCapture?: (event: CompositionEvent) => void;
+	  onFocus?: (event: FocusEvent) => void;
+	  onFocusCapture?: (event: FocusEvent) => void;
+	  onBlur?: (event: FocusEvent) => void;
+	  onBlurCapture?: (event: FocusEvent) => void;
+	  onChange?: (event: Event) => void;
+	  onChangeCapture?: (event: Event) => void;
+	  onInput?: (event: Event) => void;
+	  onInputCapture?: (event: Event) => void;
+	  onReset?: (event: Event) => void;
+	  onResetCapture?: (event: Event) => void;
+	  onSubmit?: (event: Event) => void;
+	  onSubmitCapture?: (event: Event) => void;
+	  onInvalid?: (event: Event) => void;
+	  onInvalidCapture?: (event: Event) => void;
+	  onLoad?: (event: Event) => void;
+	  onLoadCapture?: (event: Event) => void;
+	  onError?: (event: Event) => void;
+	  onErrorCapture?: (event: Event) => void;
+	  onKeyDown?: (event: KeyboardEvent) => void;
+	  onKeyDownCapture?: (event: KeyboardEvent) => void;
+	  onKeyPress?: (event: KeyboardEvent) => void;
+	  onKeyPressCapture?: (event: KeyboardEvent) => void;
+	  onKeyUp?: (event: KeyboardEvent) => void;
+	  onKeyUpCapture?: (event: KeyboardEvent) => void;
+	  onAuxClick?: (event: MouseEvent) => void;
+	  onClick?: (event: MouseEvent) => void;
+	  onClickCapture?: (event: MouseEvent) => void;
+	  onContextMenu?: (event: MouseEvent) => void;
+	  onContextMenuCapture?: (event: MouseEvent) => void;
+	  onDblClick?: (event: MouseEvent) => void;
+	  onDblClickCapture?: (event: MouseEvent) => void;
+	  onDrag?: (event: DragEvent) => void;
+	  onDragCapture?: (event: DragEvent) => void;
+	  onDragEnd?: (event: DragEvent) => void;
+	  onDragEndCapture?: (event: DragEvent) => void;
+	  onDragEnter?: (event: DragEvent) => void;
+	  onDragEnterCapture?: (event: DragEvent) => void;
+	  onDragExit?: (event: DragEvent) => void;
+	  onDragExitCapture?: (event: DragEvent) => void;
+	  onDragLeave?: (event: DragEvent) => void;
+	  onDragLeaveCapture?: (event: DragEvent) => void;
+	  onDragOver?: (event: DragEvent) => void;
+	  onDragOverCapture?: (event: DragEvent) => void;
+	  onDragStart?: (event: DragEvent) => void;
+	  onDragStartCapture?: (event: DragEvent) => void;
+	  onDrop?: (event: DragEvent) => void;
+	  onDropCapture?: (event: DragEvent) => void;
+	  onMouseDown?: (event: MouseEvent) => void;
+	  onMouseDownCapture?: (event: MouseEvent) => void;
+	  onMouseEnter?: (event: MouseEvent) => void;
+	  onMouseLeave?: (event: MouseEvent) => void;
+	  onMouseMove?: (event: MouseEvent) => void;
+	  onMouseMoveCapture?: (event: MouseEvent) => void;
+	  onMouseOut?: (event: MouseEvent) => void;
+	  onMouseOutCapture?: (event: MouseEvent) => void;
+	  onMouseOver?: (event: MouseEvent) => void;
+	  onMouseOverCapture?: (event: MouseEvent) => void;
+	  onMouseUp?: (event: MouseEvent) => void;
+	  onMouseUpCapture?: (event: MouseEvent) => void;
+	  onTouchCancel?: (event: TouchEvent) => void;
+	  onTouchCancelCapture?: (event: TouchEvent) => void;
+	  onTouchEnd?: (event: TouchEvent) => void;
+	  onTouchEndCapture?: (event: TouchEvent) => void;
+	  onTouchMove?: (event: TouchEvent) => void;
+	  onTouchMoveCapture?: (event: TouchEvent) => void;
+	  onTouchStart?: (event: TouchEvent) => void;
+	  onTouchStartCapture?: (event: TouchEvent) => void;
+	  onPointerDown?: (event: PointerEvent) => void;
+	  onPointerDownCapture?: (event: PointerEvent) => void;
+	  onPointerMove?: (event: PointerEvent) => void;
+	  onPointerMoveCapture?: (event: PointerEvent) => void;
+	  onPointerUp?: (event: PointerEvent) => void;
+	  onPointerUpCapture?: (event: PointerEvent) => void;
+	  onPointerCancel?: (event: PointerEvent) => void;
+	  onPointerCancelCapture?: (event: PointerEvent) => void;
+	  onPointerEnter?: (event: PointerEvent) => void;
+	  onPointerEnterCapture?: (event: PointerEvent) => void;
+	  onPointerLeave?: (event: PointerEvent) => void;
+	  onPointerLeaveCapture?: (event: PointerEvent) => void;
+	  onPointerOver?: (event: PointerEvent) => void;
+	  onPointerOverCapture?: (event: PointerEvent) => void;
+	  onPointerOut?: (event: PointerEvent) => void;
+	  onPointerOutCapture?: (event: PointerEvent) => void;
+	  onGotPointerCapture?: (event: PointerEvent) => void;
+	  onGotPointerCaptureCapture?: (event: PointerEvent) => void;
+	  onLostPointerCapture?: (event: PointerEvent) => void;
+	  onLostPointerCaptureCapture?: (event: PointerEvent) => void;
+	  onScroll?: (event: UIEvent) => void;
+	  onScrollCapture?: (event: UIEvent) => void;
+	  onWheel?: (event: WheelEvent) => void;
+	  onWheelCapture?: (event: WheelEvent) => void;
+	  onAnimationStart?: (event: AnimationEvent) => void;
+	  onAnimationStartCapture?: (event: AnimationEvent) => void;
+	  onAnimationEnd?: (event: AnimationEvent) => void;
+	  onAnimationEndCapture?: (event: AnimationEvent) => void;
+	  onAnimationIteration?: (event: AnimationEvent) => void;
+	  onAnimationIterationCapture?: (event: AnimationEvent) => void;
+	  onTransitionEnd?: (event: TransitionEvent) => void;
+	  onTransitionEndCapture?: (event: TransitionEvent) => void;
+	}
+  }

package/lib/types/es6/Checkbox.d.ts

@@ -1,7 +1,7 @@
 import {Ext} from '../../tr-grid-util/es6/Ext.js';
 import {GridPlugin} from '../../tr-grid-util/es6/GridPlugin.js';
 import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
-import {injectCss, prettifyCss, extendObject} from "../../tr-grid-util/es6/Util.js";
+import {injectCss, prettifyCss} from "../../tr-grid-util/es6/Util.js";
 
 declare namespace CheckboxPlugin {
 
@@ -12,7 +12,8 @@ declare namespace CheckboxPlugin {
         checkboxCreated?: ((...params: any[]) => any),
         checkboxBinding?: ((...params: any[]) => any),
         clicked?: ((...params: any[]) => any),
-        width?: number
+        width?: number,
+        topCheckboxHandler?: boolean
     };
 
     type ColumnOptions = {
@@ -41,7 +42,7 @@ declare class CheckboxPlugin extends GridPlugin {
 
     public getDisplayColumn(): number;
 
-    public getCheckbox(sectionRef: any, rowIndex: number): Element;
+    public getCheckbox(sectionRef: any, rowIndex: number): Element|null;
 
     public selectAll(): void;
 

package/lib/types/es6/ColumnStack.d.ts

@@ -9,6 +9,10 @@ import { preventDefault } from "../../tr-grid-util/es6/EventDispatcher.js";
 
 declare namespace ColumnStackPlugin {
 
+    type Options = {
+        fields: (string)[]
+    };
+
     type ColumnOptions = {
         stackId?: string,
         stack?: (string|StackOptions)
@@ -34,11 +38,11 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public getConfigObject(gridOptions?: any): any;
 
-    public getMemberIndices(colIndex: number): (number)[];
+    public getMemberIndices(colIndex: number): (number)[]|null;
 
-    public collapseGroup(colIndex: number, collapsed?: boolean): (number)[];
+    public collapseGroup(colIndex: number, collapsed?: boolean): (number)[]|null;
 
-    public expandGroup(colIndex: number): (number)[];
+    public expandGroup(colIndex: number): (number)[]|null;
 
     public isColumnStackable(colIndices: (number)[]): boolean;
 
@@ -60,7 +64,7 @@ declare class ColumnStackPlugin extends GridPlugin {
 
     public getStackId(colIndex: number): string;
 
-    public stackColumns(colIndices?: (number)[], stackId?: string, options?: any): boolean;
+    public stackColumns(colRefs?: (number|string)[], stackId?: string, options?: any): boolean;
 
     public setStack(colRefs: (number|string)[]): boolean;
 

package/lib/types/es6/CompositeGrid/ColumnSelectionPlugin.d.ts

@@ -1,6 +1,7 @@
 import Ext from "../../../tr-grid-util/es6/Ext.js";
 import Util from "../Core/grid/util/util.js";
-import { Plugin, ILayoutGrid, Core} from "../Core/index.js";
+import Plugin from "./Plugin.js";
+import { ILayoutGrid, Core} from "../Core/index.js";
 
 declare class ColumnSelectionPlugin extends Plugin {
 
@@ -28,7 +29,7 @@ declare class ColumnSelectionPlugin extends Plugin {
 
     public isSelectedColumn(colIndex: number): boolean;
 
-    public getActiveGrid(): Core;
+    public getActiveGrid(): Core|null;
 
     public enableSingleSelectionMode(bool?: boolean): void;
 

package/lib/types/es6/CompositeGrid/ColumnWidthAdjustingPlugin.d.ts

@@ -1,6 +1,7 @@
 import Ext from "../../../tr-grid-util/es6/Ext.js";
 import Util from "../Core/grid/util/util.js";
-import { Plugin, Conflator } from "../Core/index.js";
+import Plugin from "./Plugin.js";
+import { Conflator } from "../Core/index.js";
 import TextWidthCalculator from "./TextWidthCalculator.js"
 
 declare class ColumnWidthAdjustingPlugin extends Plugin {