@refinitiv-ui/efx-grid 6.0.2 → 6.0.3

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

@@ -49,6 +49,10 @@ var _newArrayOfObject = function (num) {
 * @param {boolean=} bool
 */
 var _toggleInlineElement = function (elem, bool) {
+	if(!elem || elem.style.display === "none") {
+		return;
+	}
+
 	var s = elem.style;
 	if(bool == null) {
 		bool = s.display !== "inline-block";
@@ -68,7 +72,7 @@ var _toggleInlineElement = function (elem, bool) {
 var MultiTableManager = function (gridElem) {
 	this._onDelayedConfiguration = this._onDelayedConfiguration.bind(this);
 	this._onConfiguration = this._onConfiguration.bind(this);
-	this._onDataChanged = this._onDataChanged.bind(this);
+	this._onWrapCountChanged = this._onWrapCountChanged.bind(this);
 
 	this._tables = [];
 	if(gridElem) {
@@ -102,6 +106,10 @@ MultiTableManager.prototype._emeraldGrid = false;
 * @private
 */
 MultiTableManager.prototype._ready = false;
+/** @type {number}
+* @private
+*/
+MultiTableManager.prototype._wrapSize = 0;
 
 
 /** @public
@@ -196,6 +204,7 @@ MultiTableManager._onVScrollbarSynchronization = function(vScrollbarHost, hScrol
 	for(var i = 0; i < gridLen; ++i) {
 		var gridElem = gridElems[i];
 		var core = gridElem.api.getCoreGrid();
+
 		_toggleInlineElement(gridElem, true);
 		if(i > 0) {
 			mainCore.synchronizeVScrollbar(core);
@@ -234,6 +243,8 @@ MultiTableManager.prototype.setGridConfig = function (configObj) {
 * @param {Object} e
 */
 MultiTableManager.prototype._onDelayedConfiguration = function (e) {
+	this._ready = false;
+	// TODO: Handle the case where config is changed at runtime
 	setTimeout(this._onConfiguration, 10); // Add delay to ensure that scrollbars are synchronized first
 };
 /** @private
@@ -245,15 +256,16 @@ MultiTableManager.prototype._onConfiguration = function () {
 	}
 	this._ready = true;
 
-	this.setTableCount(this._tableCount);
+	if(this._wrapSize) {
+		this._wrapTable(this._wrapSize);
+	} else {
+		this._setTableCount(this._tableCount);
+	}
 };
 
 /** @public
 */
 MultiTableManager.prototype.dispose = function () {
-	// var main = this._tables[0];
-	// main.api.getDataSource().unlisten("dataChanged", this._onDataChanged);
-
 	var len = this._tables.length;
 	for(var i = 0; i < len; ++i) {
 		this._tables[i].dispose();
@@ -272,7 +284,8 @@ MultiTableManager.prototype._cloneConfig = function () {
 	if(this._configObj) {
 		obj = cloneObject(this._configObj);
 		if(Array.isArray(obj.columns)) {
-			obj.columns = this._configObj.columns.slice();
+			var runtimeConfig = this._tables[0].api ? this._tables[0].api.getConfigObject() : this._configObj;
+			obj.columns = runtimeConfig.columns.slice();
 		}
 	}
 	return obj || {};
@@ -282,13 +295,12 @@ MultiTableManager.prototype._cloneConfig = function () {
 * @return {number}
 */
 MultiTableManager.prototype.getTableCount = function() {
-	return this._tableCount;
+	return this._tables.length;
 };
-/**
-* @public
+/** @private
 * @param {number} num Number of tables. Number cannot be less than one.
 */
-MultiTableManager.prototype.setTableCount = function(num) {
+MultiTableManager.prototype._setTableCount = function(num) {
 	this._tableCount = num > 0 ? num : 1;
 
 	if(this._ready) {
@@ -301,30 +313,53 @@ MultiTableManager.prototype.setTableCount = function(num) {
 	}
 };
 /**
+* @public
+* @param {number} num Number of tables. Number cannot be less than one.
+*/
+MultiTableManager.prototype.setTableCount = function(num) {
+	if(this._wrapSize) {
+		this._wrapTable(0);
+	}
+	this._setTableCount(num);
+};
+/**
 * @private
+* @param {number} tableIndex
 * @return {Element}
 */
-MultiTableManager.prototype._addTable = function() {
+MultiTableManager.prototype._addTable = function(tableIndex) {
 	var main = this._tables[0];
 	var parentElem = main.parentNode;
+	var core = main.api.getCoreGrid();
 	var mainDataView = main.api.getDataView();
 	// var mainDataTable = main.api.getDataTable();
+	var stp = core.getPlugin("SortableTitlePlugin");
+	var dtp = core.getPlugin("DragAndDropTitlePlugin");
 
 	var configObj = this._cloneConfig();
 	configObj.extensions = this._generateExtensions();
+
 	delete configObj.staticDataRows;
 	delete configObj.rows;
 	delete configObj.dataModel;
 
-	var rowCount = mainDataView.getRowCount();
-
-	var ary = _newArrayOfObject(rowCount);
-	if(this._emeraldGrid) {
-		configObj.dataModel = {
-			data: ary
-		};
+	if(this._wrapSize) {
+		var wrappedViews = mainDataView.getWrappedViews();
+		configObj.dataView = wrappedViews[tableIndex - 1];
+		configObj.grid = main.api;
 	} else {
-		configObj.rows = ary;
+		configObj["SortableTitle"] = stp;
+		configObj["DragAndDropTitle"] = dtp;
+		var rowCount = mainDataView.getRowCount();
+
+		var ary = _newArrayOfObject(rowCount);
+		if(this._emeraldGrid) {
+			configObj.dataModel = {
+				data: ary
+			};
+		} else {
+			configObj.rows = ary;
+		}
 	}
 
 	var sub = document.createElement(main.tagName);
@@ -347,19 +382,22 @@ MultiTableManager.prototype._addTables = function(num) {
 
 	var main = this._tables[0];
 	_toggleInlineElement(main, true); // TODO: Check if we need to do this every time
+
 	// main.api.setFitContentWidth(true);
 
 	for(var i = 0; i < num; ++i) {
-		var grid = this._addTable();
+		var grid = this._addTable(this._tables.length);
 		this._tables.push(grid);
 	}
 
-	if(main._vScrollbarSynchronization) {
-		MultiTableManager.synchronizeVScrollbar(
-			main.api.getCoreGrid().getVScrollbar().getParent(),
-			main.parentNode,
-			this._tables
-		);
+	if(!this._wrapSize) {
+		if(main._vScrollbarSynchronization) {
+			MultiTableManager.synchronizeVScrollbar(
+				main.api.getCoreGrid().getVScrollbar().getParent(),
+				main.parentNode,
+				this._tables
+			);
+		}
 	}
 };
 /**
@@ -381,20 +419,62 @@ MultiTableManager.prototype._removeTables = function(num) {
 			sub.parentNode.removeChild(sub);
 		}
 	}
-	if(this._tables.length === 1) {
-		// TODO: Reset state
-		this._tables[0].style.display = "";
+	// if(this._tables.length === 1) {
+	// TODO: Reset state
+	// this._tables[0].style.display = ""; // Remove display inline
+	// }
+};
+
+
+/** @private
+* @param {number} rowCount Number of row per table. Set number to zero to turn off wrap mode.
+*/
+MultiTableManager.prototype._wrapTable = function(rowCount) {
+	this._wrapSize = rowCount > 0 ? rowCount : 0;
+
+	if(this._ready) {
+		var main = this._tables[0];
+		if(this._wrapSize) {
+			main.style.display =  "none";
+			main.api.getCoreGrid().getVScrollbar().disable();
+		} else {
+			main.style.display =  "";
+			_toggleInlineElement(main, true);
+			main.api.getCoreGrid().getVScrollbar().disable(false);
+		}
+
+		var dv = main.api.getDataView();
+		dv.listen("wrapCountChanged", this._onWrapCountChanged);
+		dv.wrapView(this._wrapSize);
 	}
 };
 /**
-* @private
+* @public
+* @param {number} rowCount Number of row per table. Set number to zero to turn off wrap mode.
+*/
+MultiTableManager.prototype.wrapTable = function(rowCount) {
+	if(rowCount && this._tableCount > 1) {
+		this._setTableCount(1);
+	}
+	if(!rowCount || rowCount < 0) {
+		rowCount = 0;
+	}
+	if(this._wrapSize !== rowCount) {
+		this._wrapTable(rowCount);
+	}
+};
+/** @private
 * @param {Object} e
 */
-MultiTableManager.prototype._onDataChanged = function(e) {
-
+MultiTableManager.prototype._onWrapCountChanged = function(e) {
+	if(e.prevCount < e.newCount) {
+		this._addTables(e.newCount - e.prevCount);
+	}
+	if(e.newCount < e.prevCount) {
+		this._removeTables(e.prevCount - e.newCount);
+	}
 };
 
-
 /** @public
 * @param {number=} at
 * @return {Element}
@@ -445,23 +525,6 @@ MultiTableManager.prototype._execAll = function(methodName, args) {
 	}
 };
 
-/** @private
-* @param {number} num
-*/
-MultiTableManager.prototype._setRtRowCount = function(num) {
-	var tableCount = this._tables.length;
-	// grid.api.getRowCount();
-	for(var i = 1; i < tableCount; ++i) {
-		var sub = this._tables[i];
-		sub.api.insertRows(_newArrayOfObject(num));
-	}
-};
-/** @private
-* @param {number} num
-*/
-MultiTableManager.prototype._addCsRows = function(num) {
-};
-
 /** @public
 * @param {Object=} rowOption
 * @param {number=} at
@@ -471,10 +534,14 @@ MultiTableManager.prototype.insertRow = function(rowOption, at) {
 		return; // TODO
 	}
 
-	var tableCount = this._tables.length;
-	for(var i = 0; i < tableCount; ++i) {
-		var tbl = this._tables[i];
-		tbl.api.insertRow(rowOption, at);
+	if(this._wrapSize) {
+		this.getTable().api.insertRow(rowOption, at);
+	} else {
+		var tableCount = this._tables.length;
+		for(var i = 0; i < tableCount; ++i) {
+			var tbl = this._tables[i];
+			tbl.api.insertRow(rowOption, at);
+		}
 	}
 };
 /** @public
@@ -488,18 +555,58 @@ MultiTableManager.prototype.removeRow = function(at) {
 		at = this.getRowCount() - 1;
 	}
 
+	if(this._wrapSize) {
+		this.getTable().api.removeRow(at);
+	} else {
+		var tableCount = this._tables.length;
+		for(var i = 0; i < tableCount; ++i) {
+			var tbl = this._tables[i];
+			tbl.api.removeRow(at);
+		}
+	}
+};
+
+/** @public
+* @return {number}
+*/
+MultiTableManager.prototype.getRowCount = function() {
+	return this.getTable().api.getRowCount();
+};
+
+/** @public
+* @param {*} columnOption String will be treated as field, while object is treated as the column options
+* @param {number=} idx
+*/
+MultiTableManager.prototype.insertColumn = function(columnOption, idx) {
+	if(this._emeraldGrid) {
+		return; // TODO
+	}
+
 	var tableCount = this._tables.length;
 	for(var i = 0; i < tableCount; ++i) {
 		var tbl = this._tables[i];
-		tbl.api.removeRow(at);
+		tbl.api.insertColumn(columnOption, idx);
+	}
+};
+/** @public
+* @param {*} colRef Column reference
+*/
+MultiTableManager.prototype.removeColumn = function(colRef) {
+	if(this._emeraldGrid) {
+		return; // TODO
+	}
+	var tableCount = this._tables.length;
+	for(var i = 0; i < tableCount; ++i) {
+		var tbl = this._tables[i];
+		tbl.api.removeColumn(colRef);
 	}
 };
 
 /** @public
 * @return {number}
 */
-MultiTableManager.prototype.getRowCount = function() {
-	return this.getTable().api.getRowCount();
+MultiTableManager.prototype.getColumnCount = function() {
+	return this.getTable().api.getColumnCount();
 };
 
 export default MultiTableManager;

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}
@@ -108,10 +109,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 +126,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);
@@ -165,14 +169,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 +185,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);
 		}

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

@@ -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 = {

package/lib/types/es6/Core/data/DataView.d.ts

@@ -7,12 +7,6 @@ import EventDispatcher from "../grid/event/EventDispatcher.js";
 import Util from "../grid/util/util.js";
 import { Conflator } from "../../../../tr-grid-util/es6/Conflator.js";
 
-declare namespace DataView {
-
-    type IDataView = DataTable|WrappedView|DataView;
-
-}
-
 declare class DataView extends EventDispatcher {
 
     constructor(source?: DataTable|DataView);

package/lib/types/es6/Core/data/Segment.d.ts

@@ -20,6 +20,8 @@ declare class Segment {
 
     public getChildIds(): (string)[];
 
+    public getChildCount(): number;
+
     public collapse(bool?: boolean): boolean;
 
     public expand(bool?: boolean): boolean;

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

@@ -3,7 +3,7 @@ import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
 import { Dom } from "../../tr-grid-util/es6/Dom.js";
 import { Popup } from "../../tr-grid-util/es6/Popup.js";
 import { ElfUtil } from "../../tr-grid-util/es6/ElfUtil.js";
-import { isTouchDevice } from "../../tr-grid-util/es6/Util.js";
+import { isTouchDevice, injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
 import { ElfDate } from "../../tr-grid-util/es6/ElfDate.js";
 import { CoralItems } from "../../tr-grid-util/es6/CoralItems.js";