@refinitiv-ui/efx-grid 6.0.91 → 6.0.92

package/lib/core/es6/data/DataTable.js

@@ -19,7 +19,7 @@ import SegmentCollection from "./SegmentCollection.js";
 /** @constructor
 * @extends {DataCache}
 */
-var DataTable = function() {
+let DataTable = function() {
 	DataTable.base(this, 'constructor');
 
 	this._removeRows = this._removeRows.bind(this);
@@ -104,7 +104,7 @@ DataTable.prototype._classifyingTimer = 0;
 * @property {number=} order 1 indicates ascending order, and -1 indicates descending order
 * @property {*=} contextObject Any given user context
 * @example
-* var customComparer = function(a, b, order) {
+* let customComparer = function(a, b, order) {
 *   if(a + 10 < b) { return -order; }
 *   if(b + 10 < a) { return order; }
 *   return 0; // a and b are less than 10 difference apart
@@ -137,8 +137,8 @@ DataTable.prototype.dispose = function() {
 * @override
 */
 DataTable.prototype.getColumnData = function(cid) {
-	var rows = new Array(this._rids.length);
-	for(var i = this._rids.length; --i >= 0;) {
+	let rows = new Array(this._rids.length);
+	for(let i = this._rids.length; --i >= 0;) {
 		rows[i] = this._rows[this._rids[i]][cid];
 	}
 	return rows;
@@ -195,7 +195,7 @@ DataTable.prototype.getRowDataAt = function(rowIndex) {
 * @return {Object.<string, *>}
 */
 DataTable.prototype.getPreviousData = function(rid, cid) {
-	var row = this._prevData[rid] || null;
+	let row = this._prevData[rid] || null;
 	if(row) {
 		return row[cid];
 	}
@@ -214,19 +214,45 @@ DataTable.prototype.setData = function(rid, cid, value) { // Data changed event
 	if(!this._needFiring()) {
 		return this._setData(rid, cid, value);
 	}
-	var values = {};
+	let values = {};
 	values[cid] = value;
 	return this.setRowData(rid, values);
 };
+/** @private
+* @param {string} rid Row Id
+* @returns {boolean}
+*/
+DataTable.prototype._removeRidFromSegments = function(rid) {
+	if(this._segments) {
+		let segment = this._segments.getSegment(rid);
+		if(segment) {
+			if(this._segments.removeSegment(rid)) {
+				// TODO: Handle sub segment removal
+				if(!this._segments.getSegmentCount()) {
+					this._segments.dispose();
+					this._segments = null;
+				}
+				return true;
+			}
+		} else {
+			let segmentParentId = this._segments.getParentRowId(rid);
+			if(segmentParentId) {
+				this._segments.removeSegmentChild(segmentParentId, rid);
+			}
+		}
+	}
+	return false;
+};
 /** Set data in row manner
 * @override
+* @public
 * @param {string} rid Row Id
 * @param {Object.<string, *>=} values Object where the key is column Id and value is the data to be set
 * @param {Object=} eventArg Additional arguments to be attached to the event fired
 * @return {boolean} Return true if there is any change, and false otherwise
 * @fires DataTable#dataChanged
 * @example
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.setRowData("row 1", {"column 1": "a", "column 2": 1, "column 3": null});
 * dt.log(); // See console for the results
 */
@@ -235,10 +261,10 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 		return false;
 	}
 
-	var row = this.getRowData(rid);
-	var dirty = false;
-	var type = "updated";
-	var segmentChanged = false;
+	let row = this.getRowData(rid);
+	let dirty = false;
+	let type = "updated";
+	let segmentChanged = false;
 
 	if(values) {
 		if(!row) {
@@ -247,8 +273,8 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			this._rows[rid] = row; // WARNING: Dangerous use of external reference. User may modify data without using DataTable's API
 			this._prevData[rid] = {};
 			if(eventArg) {
-				var nextRid = /** @type{string} */(eventArg["nextRid"]); // Used for insertion only
-				var rowIndex = (nextRid) ? this.getRowIndex(nextRid) : -1;
+				let nextRid = /** @type{string} */(eventArg["nextRid"]); // Used for insertion only
+				let rowIndex = (nextRid) ? this.getRowIndex(nextRid) : -1;
 				if(rowIndex < 0) {
 					rowIndex = /** @type{number} */(eventArg["fallback"]);
 				}
@@ -262,8 +288,8 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 				this._rids.push(rid);
 			}
 		} else {
-			var prevData = this._prevData[rid];
-			for (var cid in values) {
+			let prevData = this._prevData[rid];
+			for (let cid in values) {
 				prevData[cid] = row[cid];
 				row[cid] = values[cid];
 			}
@@ -276,18 +302,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			// delete this._prevData[rid];
 			this._prevData[rid] = this._rows[rid]; // Move reference from the removed row to history
 			delete this._rows[rid];
-			if(this._segments) {
-				var segment = this._segments.getSegment(rid);
-				if(segment) {
-					if(this._segments.removeSegment(rid)) {
-						// TODO: Handle sub segment removal
-						segmentChanged = true;
-						if(!this._segments.getSegmentCount()) {
-							this._segments = null;
-						}
-					}
-				}
-			}
+			segmentChanged = this._removeRidFromSegments(rid);
 			DataTable._removeArrayItem(this._rids, rid);
 			dirty = true;
 		}
@@ -297,7 +312,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 		if(this._autoFillSegments()) {
 			this.dispatchGlobalChange();
 		} else {
-			var e = eventArg || {};
+			let e = eventArg || {};
 			e["rid"] = rid;
 			e["changes"] = values; // WARNING: External user data is passed along
 			e["rowData"] = row;
@@ -317,19 +332,19 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 * @param {Array.<*>} valueList
 * @param {Array.<string>=} opt_ridList Specify row id to be set corresponding to the data item
 * @example
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.setColumnData("column 1", ["1st row data", "2nd row data", "3rd row data"]);
 * dt.log(); // See console for the results
 */
 DataTable.prototype.setColumnData = function(cid, valueList, opt_ridList) { // Data changed event may be dispatched
-	var rLen = (valueList) ? valueList.length : 0;
+	let rLen = (valueList) ? valueList.length : 0;
 	if(rLen < 0) { return; }
 
-	var prevFrozen = this._frozen;
+	let prevFrozen = this._frozen;
 	this.freeze();
-	var rids = this._generateRids(rLen, opt_ridList);
+	let rids = this._generateRids(rLen, opt_ridList);
 
-	for(var r = 0; r < rLen; ++r) {
+	for(let r = 0; r < rLen; ++r) {
 		this._setData(rids[r], cid, valueList[r]);
 	}
 
@@ -344,12 +359,12 @@ Row id with null value will cause a removal of the row with the same id.
 * @see {@link DataTable#addRows}
 * @see {@link DataTable#setDataFrom2DArray}
 * @example
-* var data = {
+* let data = {
 *   "rowId 1": {"column 1": "a", "column 2": 1, "column 3": 2},
 *   "rowId 2": {"column 1": "b", "column 2": 3, "column 3": 4},
 *   "rowId 4": {"column 1": "d", "group_criteria": 1} // Rows don't need to be in uniform structure
 * };
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.setDataFromObjectMap(data);
 * dt.log(); // See console for the results
 * dt.setDataFromObjectMap({"rowId 1": null}); // Remove the row with "rowId 1"
@@ -364,10 +379,10 @@ DataTable.prototype.setDataFromObjectMap = function(obj) {
 		return;
 	}
 
-	var prevFrozen = this._frozen;
+	let prevFrozen = this._frozen;
 	this.freeze();
 
-	for(var rid in obj) {
+	for(let rid in obj) {
 		this.setRowData(rid, obj[rid]);
 	}
 
@@ -381,28 +396,28 @@ DataTable.prototype.setDataFromObjectMap = function(obj) {
 * @see {@link DataTable#addRows}
 * @see {@link DataTable#setDataFromObjectMap}
 * @example
-* var data = [
+* let data = [
 *   ["a", 1, 2],
 *   ["b", 3, 4],
 *   ["c", 5, 6]
 * ];
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.setDataFrom2DArray(data, ["column 1", "column 2", "column 3"]);
 * dt.log(); // See console for the results
 */
 DataTable.prototype.setDataFrom2DArray = function(ary, opt_cidList, opt_ridList) {
-	var rLen = (ary) ? ary.length : 0;
+	let rLen = (ary) ? ary.length : 0;
 	if(rLen < 0) { return; }
 
-	var prevFrozen = this._frozen;
+	let prevFrozen = this._frozen;
 	this.freeze();
 
-	var c = 0;
-	var rids = this._generateRids(rLen, opt_ridList);
+	let c = 0;
+	let rids = this._generateRids(rLen, opt_ridList);
 
-	for(var r = 0; r < rLen; ++r) {
-		var row = ary[r];
-		var rid = rids[r];
+	for(let r = 0; r < rLen; ++r) {
+		let row = ary[r];
+		let rid = rids[r];
 		if(opt_cidList) {
 			for(c = row.length; --c >= 0;) {
 				this._setData(rid, opt_cidList[c], row[c]);
@@ -426,7 +441,7 @@ DataTable.prototype.setDataFrom2DArray = function(ary, opt_cidList, opt_ridList)
 * @fires DataTable#dataChanged
 */
 DataTable.prototype.setDataAt = function(rowIndex, cid, value) { // Data changed event may be dispatched
-	var rid = this.getRowId(rowIndex);
+	let rid = this.getRowId(rowIndex);
 	return (rid) ? this.setData(rid, cid, value) : false;
 };
 /** @public
@@ -437,7 +452,7 @@ DataTable.prototype.setDataAt = function(rowIndex, cid, value) { // Data changed
 * @fires DataTable#dataChanged
 */
 DataTable.prototype.setRowDataAt = function(rowIndex, values, opt_eventArg) { // Data changed event may be dispatched
-	var rid = this.getRowId(rowIndex);
+	let rid = this.getRowId(rowIndex);
 	return (rid) ? this.setRowData(rid, values, opt_eventArg) : false;
 };
 /** Add new row of data to the end of the Data Table
@@ -447,7 +462,7 @@ DataTable.prototype.setRowDataAt = function(rowIndex, values, opt_eventArg) { //
 * @return {string} Return Row id that has been inserted or changed
 * @fires DataTable#dataChanged
 * @example
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.addRow({"column 1": "a", "column 2": 1, "column 3": null});
 * dt.addRow({"column 1": "b", "column 2": 5, "column 3": {"someKey": 10}});
 * dt.log(); // See console for the results
@@ -467,7 +482,7 @@ DataTable.prototype.addRow = function(values, rid) {
 * @see {@link DataTable#setDataFrom2DArray}
 * @see {@link DataTable#setDataFromObjectMap}
 * @example
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.addRows([
 *   {"field1": "a", "field2": 1, "field3": null},
 *   {"field1": "b", "field2": 5, "field3": {"someKey": 10}},
@@ -480,7 +495,7 @@ DataTable.prototype.addRows = function(rows, rids) {
 	if(!Array.isArray(rows)) {
 		return;
 	}
-	var len = rows.length;
+	let len = rows.length;
 	if(!len) {
 		return;
 	} else if(len === 1) {
@@ -490,9 +505,9 @@ DataTable.prototype.addRows = function(rows, rids) {
 	if(!rids) {
 		rids = [];
 	}
-	var prevFrozen = this._frozen;
+	let prevFrozen = this._frozen;
 	this.freeze();
-	for(var i = 0; i < len; ++i) {
+	for(let i = 0; i < len; ++i) {
 		this.addRow(rows[i], rids[i]);
 	}
 	this.freeze(prevFrozen);
@@ -519,7 +534,7 @@ DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
 * @see {@link DataTable#removeRow}
 */
 DataTable.prototype.insertRow = function(rowRef, values, rid) {
-	var arg = null;
+	let arg = null;
 	if(typeof rowRef === "number") {
 		arg = {};
 		arg["nextRid"] = this._rids[rowRef];
@@ -543,7 +558,7 @@ DataTable.prototype.insertRow = function(rowRef, values, rid) {
  * @fires DataTable#dataChanged
  */
 DataTable.prototype.insertAfter = function(rowRef, opt_values, opt_rid) {
-	var rowIndex = (typeof rowRef === "string") ? this.getRowIndex(rowRef) : /** @type{number}*/ (rowRef);
+	let rowIndex = (typeof rowRef === "string") ? this.getRowIndex(rowRef) : /** @type{number}*/ (rowRef);
 
 	if(!(rowIndex >= 0) || rowIndex >= this._rids.length - 1) {
 		return this.addRow(opt_values, opt_rid);
@@ -567,8 +582,9 @@ DataTable.prototype.removeRow = function(rowRef) { // Data changed event may be
 * @see {@link DataTable#removeAllRows}
 */
 DataTable.prototype.removeRows = function(refs) {
+	let rid;
 	if(refs.length === 1) {
-		var rid = refs[0];
+		rid = refs[0];
 		if (typeof rid === "number") {
 			this.removeRow(rid);
 		} else {
@@ -577,8 +593,8 @@ DataTable.prototype.removeRows = function(refs) {
 		return;
 	}
 
-	var i;
-	var dirty = false;
+	let i;
+	let dirty = false;
 	this._removedRows = {};
 	for (i = refs.length; --i >= 0;) {
 		rid = refs[i];
@@ -586,12 +602,12 @@ DataTable.prototype.removeRows = function(refs) {
 			rid = this.getRowId(rid);
 		}
 
-		var row = this.getRowData(rid);
+		let row = this.getRowData(rid);
 		if(row) {
 			this._prevData[rid] = this._rows[rid];
 			this._removedRows[rid] = 1;
 			delete this._rows[rid];
-			// TODO: remove segments
+			this._removeRidFromSegments(rid);
 			dirty = true;
 		}
 	}
@@ -617,7 +633,7 @@ DataTable.prototype._removeRows = function(rid) {
 * @return {boolean}
 */
 DataTable._removeArrayItem = function(ary, item) {
-	var at = ary.indexOf(item);
+	let at = ary.indexOf(item);
 	if(at >= 0) {
 		if(at >= ary.length) {
 			ary.pop(); // Array.pop is 100 times faster than Array.splice
@@ -634,9 +650,10 @@ DataTable._removeArrayItem = function(ary, item) {
 DataTable.prototype.clearAllData = function(suppressEvent) {
 	DataTable.base(this, "clearAllData", true);
 	this._prevData = {};
-	// TODO: Clear all segments
+
 	if(this._segments) {
-		this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
+		this._segments.dispose();
+		this._segments = null;
 	}
 
 	if(this._rids.length) {
@@ -666,18 +683,18 @@ DataTable._ascendingOrder = function(a, b) { return a - b; };
 * @return {Array.<string>|string} Return row id(s). Return null if nothing has changed
 */
 DataTable.prototype.moveRow = function(fromIndex, toIndex, suppressEvent) {
-	var output = null;
-	var rid = "";
+	let output = null;
+	let rid = "";
 	if(!(toIndex >= 0 && toIndex < this._rids.length)) {
 		toIndex = this._rids.length;
 	}
 
 	if (Array.isArray(fromIndex)) {
-		var fromIndices = fromIndex;
+		let fromIndices = fromIndex;
 		fromIndices.sort(DataTable._ascendingOrder);
-		var movedRids = [];
-		for (var i = fromIndices.length; --i >= 0;) {
-			var idx = fromIndices[i];
+		let movedRids = [];
+		for (let i = fromIndices.length; --i >= 0;) {
+			let idx = fromIndices[i];
 			rid = this._rids[idx];
 			if(rid) {
 				movedRids.unshift(rid);
@@ -725,17 +742,17 @@ DataTable.prototype.moveRow = function(fromIndex, toIndex, suppressEvent) {
 * @return {Array.<string>|string} rid
 */
 DataTable.prototype._moveRow = function(fromRids, toRid, suppressEvent) {
-	var len = fromRids.length;
+	let len = fromRids.length;
 	if(!len) {
 		return null;
 	}
 
-	var fromIndices = new Array(len);
-	for(var i = 0; i < len; ++i) {
+	let fromIndices = new Array(len);
+	for(let i = 0; i < len; ++i) {
 		fromIndices[i] = this.getRowIndex(fromRids[i]);
 	}
 
-	var toIndex = (toRid) ? this.getRowIndex(toRid) : this._rids.length;
+	let toIndex = (toRid) ? this.getRowIndex(toRid) : this._rids.length;
 	if(len > 1) {
 		return this.moveRow(fromIndices, toIndex, suppressEvent);
 	}
@@ -762,8 +779,8 @@ DataTable.prototype.moveRows = function(startIndex, toIndex, opt_count, suppress
 	if(toIndex < 0) { toIndex = this._rids.length; }
 	if(!opt_count) { opt_count = 1; }
 
-	var endIndex = startIndex + opt_count - 1;
-	var targetIndex = toIndex;
+	let endIndex = startIndex + opt_count - 1;
+	let targetIndex = toIndex;
 	if (toIndex >= startIndex) {
 		if (toIndex <= endIndex) {
 			targetIndex = startIndex;
@@ -777,8 +794,8 @@ DataTable.prototype.moveRows = function(startIndex, toIndex, opt_count, suppress
 			targetIndex = this._rids.length;
 		}
 
-		var rows = this._rids.splice(startIndex, opt_count);
-		var args = [targetIndex, 0].concat(rows);
+		let rows = this._rids.splice(startIndex, opt_count);
+		let args = [targetIndex, 0].concat(rows);
 		Array.prototype.splice.apply(this._rids, args);
 
 		if(this._segments) {
@@ -797,11 +814,11 @@ DataTable.prototype.moveRows = function(startIndex, toIndex, opt_count, suppress
 * @param {number} toIndex
 */
 DataTable.prototype.swapRow = function(fromIndex, toIndex) { // No event is fired. No effect on other views
-	var len = this._rids.length;
+	let len = this._rids.length;
 	if(fromIndex < 0 || fromIndex >= len) { return; }
 	if(toIndex < 0 || toIndex >= len) { return; }
 
-	var rid = this._rids[fromIndex];
+	let rid = this._rids[fromIndex];
 	this._rids[fromIndex] = this._rids[toIndex];
 	this._rids[toIndex] = rid;
 };
@@ -815,11 +832,11 @@ DataTable.prototype.clearRowData = DataTable.prototype.removeRow;
 * @override
 */
 DataTable.prototype.clearColumnData = function(colId, suppressEvent) {
-	var cids = (typeof colId === "string") ? [/** @type {string} */(colId)] : /** @type {Array.<string>} */(colId);
-	for(var i = cids.length; --i >= 0;) {
-		var cid = cids[i];
+	let cids = (typeof colId === "string") ? [/** @type {string} */(colId)] : /** @type {Array.<string>} */(colId);
+	for(let i = cids.length; --i >= 0;) {
+		let cid = cids[i];
 		if(cid) {
-			for(var rid in this._rows) {
+			for(let rid in this._rows) {
 				delete this._rows[rid][cid];
 				delete this._prevData[rid][cid];
 			}
@@ -858,7 +875,7 @@ DataTable.prototype.getSortingLogics = function() {
 * @fires DataTable#dataChanged
 */
 DataTable.prototype.sortOnce = function(cid, sortOrders, customComparer, contextObj) {
-	var sortingDefs = DataTable._buildSortContext(
+	let sortingDefs = DataTable._buildSortContext(
 		[],
 		cid,
 		sortOrders,
@@ -878,7 +895,7 @@ DataTable.prototype.sortOnce = function(cid, sortOrders, customComparer, context
 * customLogic = function(a, b, sortOrder) {
 *   return (a - b) * sortOrder; // for numeric comparison
 * };
-* var dt = new DataTable();
+* let dt = new DataTable();
 * dt.setSortingLogic(customLogic);
 * dt.sortOnce("Column id", "ascending");
 */
@@ -902,7 +919,7 @@ DataTable.prototype.setColumnSortingLogic = function(cid, func) {
 */
 DataTable.prototype.getColumnSortingLogic = function(cid) {
 	if(cid) {
-		var logic = this._compMap[cid];
+		let logic = this._compMap[cid];
 		if(logic) {
 			return logic;
 		}
@@ -917,15 +934,15 @@ DataTable.prototype.getColumnSortingLogic = function(cid) {
 * @return {boolean} Previous freeze state before the execution
 * @fires DataTable#dataChanged
 * @example
-* var prevState = dt.freeze();
-* for(var i = 0; i < 100; ++i) {
+* let prevState = dt.freeze();
+* for(let i = 0; i < 100; ++i) {
 *   dt.insertRow(); // no event is fired
 * }
 * dt.freeze(prevState); // Restore previous freeze states
 */
 DataTable.prototype.freeze = function(bool) {
 	bool = bool !== false;
-	var prevState = this._frozen;
+	let prevState = this._frozen;
 	if(prevState !== bool) {
 		this._frozen = bool;
 		this._autoFillSegments();
@@ -955,8 +972,8 @@ DataTable.prototype.isFrozen = function() {
 * @return {boolean} Return true if there is any change
 */
 DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
-	var change = false;
-	var memberCount = 0;
+	let change = false;
+	let memberCount = 0;
 	if(rid && typeof rid === "string") {
 		if(enabled !== false) {
 			if(!this._segments) {
@@ -964,7 +981,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 				this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
 			}
 			if(this._autoSegmentFilling) {
-				var parentId = this._segments.getParentRowId(rid);
+				let parentId = this._segments.getParentRowId(rid);
 				if(parentId) {
 					this._segments.removeSegmentChild(parentId, rid);
 				}
@@ -974,7 +991,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 				change = true;
 			}
 		} else if(this._segments) {
-			var segment = this._segments.getSegment(rid);
+			let segment = this._segments.getSegment(rid);
 			if(segment) {
 				memberCount = segment.getChildCount();
 				if(this._segments.removeSegment(rid)) {
@@ -990,7 +1007,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 		if(this._autoFillSegments() || memberCount) {
 			this.dispatchGlobalChange();
 		} else {
-			var rowData = this._rows[rid] || null;
+			let rowData = this._rows[rid] || null;
 			if(rowData) {
 				this._dispatchDataChange({
 					"rid": rid,
@@ -1010,6 +1027,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 */
 DataTable.prototype.unsetAllSegmentSeparators = function() {
 	if(this._segments) {
+		this._segments.dispose();
 		this._segments = null;
 		this.dispatchGlobalChange();
 		return true;
@@ -1048,7 +1066,7 @@ DataTable.prototype.getSegment = function(rid) {
 /**
 * @public
 * @param {string} rid Row id of a segment child
-* @return {string} Returns null if a segment cannot be found
+* @return {Segment} Returns null if a segment cannot be found
 */
 DataTable.prototype.getSegmentParent = function(rid) {
 	if(this._segments) {
@@ -1062,7 +1080,7 @@ DataTable.prototype.getSegmentParent = function(rid) {
 * @return {number} Return 0 if the given rid is not a segment
 */
 DataTable.prototype.getSegmentLevel = function(rid) {
-	var segment = this.getSegment(rid);
+	let segment = this.getSegment(rid);
 	if(segment) {
 		return segment.getSegmentLevel() + 1;
 	}
@@ -1097,11 +1115,11 @@ DataTable.prototype.getSegmentValues = function(rids, partial) {
 * @return {boolean} Return true if the given row is in the last segment
 */
 DataTable.prototype._isLastSegment = function(at) {
-	var segmentSeparators = this._segments;
+	let segmentSeparators = this._segments;
 	if(segmentSeparators) {
-		var rids = this._rids;
-		var rowCount = rids.length;
-		for(var r = at + 1; r < rowCount; ++r) {
+		let rids = this._rids;
+		let rowCount = rids.length;
+		for(let r = at + 1; r < rowCount; ++r) {
 			if(segmentSeparators.containsSegment(rids[r])) {
 				return false;
 			}
@@ -1151,7 +1169,7 @@ DataTable.prototype.fillSegment = function(segmentId) {
 */
 DataTable.prototype.fillSegments = function() {
 	if(this._segments) {
-		var dirty = this._segments.fillSegments(this._rids);
+		let dirty = this._segments.fillSegments(this._rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
 			this.requestClassifying();
@@ -1168,7 +1186,7 @@ DataTable.prototype.fillSegments = function() {
 */
 DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
+		let dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
 			this._sort(null);
 			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
@@ -1187,7 +1205,7 @@ DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 */
 DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
+		let dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
 		if(dirty) {
 			this._sort(null);
 			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
@@ -1205,7 +1223,7 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 */
 DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 	if(this._segments) {
-		var dirty = this._segments.removeSegmentChild(segmentId, rid);
+		let dirty = this._segments.removeSegmentChild(segmentId, rid);
 		if(dirty) {
 			this.dispatchGlobalChange();
 			this.requestClassifying();
@@ -1221,7 +1239,7 @@ DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 */
 DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 	if(this._segments) {
-		var dirty = this._segments.removeSegmentChildren(segmentId, rids);
+		let dirty = this._segments.removeSegmentChildren(segmentId, rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
 			this.requestClassifying();
@@ -1235,7 +1253,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 */
 DataTable.prototype.removeAllSegmentChildren = function() {
 	if(this._segments) {
-		var dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
+		let dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
 		if (dirty) {
 			this.dispatchGlobalChange();
 		}
@@ -1260,9 +1278,9 @@ DataTable.prototype.getSegmentIds = function() {
 */
 DataTable.prototype.getSegmentChildIds = function(segmentId) {
 	if(this._segments) {
-		var segment = this._segments.getSegment(segmentId);
+		let segment = this._segments.getSegment(segmentId);
 		if(segment) {
-			var chdr = segment.getChildIds();
+			let chdr = segment.getChildIds();
 			return chdr.length ? chdr : null;
 		}
 	}
@@ -1276,26 +1294,26 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 * @return {boolean}
 */
 DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
-	var dirty = false;
+	let dirty = false;
 	if(!this._segments){
 		return false;
 	}
 	if(typeof sortLogics === "function"){
 		return this.sortSegments(sortLogics);
 	}
-	var sortingDefs = DataTable._buildSortContext(
+	let sortingDefs = DataTable._buildSortContext(
 		[],
 		cids,
 		sortOrders,
 		sortLogics
 	);
-	var defCount = sortingDefs ? sortingDefs.length : 0;
+	let defCount = sortingDefs ? sortingDefs.length : 0;
 	if(!defCount){
 		return dirty;
 	}
 
-	var sortOrder = 0;
-	var sortLogic, sortContext;
+	let sortOrder = 0;
+	let sortLogic, sortContext;
 	if(defCount > 1) {
 		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
 		sortContext = sortingDefs;
@@ -1326,16 +1344,16 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(this._rids);
 		return false;
 	}
-	var rids = this._rids;
-	var segments = this._segments;
-	var segmentCount = segments.getSegmentCount();
-	var segmentList = [];
-	var origOrder = [];
-	var itemCount = 0;
-	var rowCount = rids.length;
-	var rid = "";
-	var segment = null;
-	var i;
+	let rids = this._rids;
+	let segments = this._segments;
+	let segmentCount = segments.getSegmentCount();
+	let segmentList = [];
+	let origOrder = [];
+	let itemCount = 0;
+	let rowCount = rids.length;
+	let rid = "";
+	let segment = null;
+	let i;
 	for(i = 0; i < rowCount; ++i) {
 		rid = rids[i];
 		segment = segments.getSegment(rid);
@@ -1352,12 +1370,12 @@ DataTable.prototype.sortSegments = function (compare) {
 	segmentList.sort(this._bySegmentSeparator);
 	this._userSegmentComparer = null;
 
-	var dirty = false;
+	let dirty = false;
 	for(i = 0; i < itemCount; ++i) {
-		var idx = origOrder[i];
+		let idx = origOrder[i];
 		rid = rids[idx];
 		segment = segmentList[i];
-		var newRid = segment.getId();
+		let newRid = segment.getId();
 		if(rid !== newRid) {
 			rids[idx] = newRid;
 			dirty = true;
@@ -1406,7 +1424,7 @@ DataTable.prototype.setClassificationSource = function(dc) {
 */
 DataTable.prototype.setSegmentClassification = function(segmentId, fields) {
 	if(this._segments) {
-		var dirty = this._segments.setSegmentClassification(segmentId, fields);
+		let dirty = this._segments.setSegmentClassification(segmentId, fields);
 		if(dirty) {
 			return this.classifySegments();
 		}
@@ -1444,20 +1462,20 @@ DataTable.prototype._onClassifyingTimer = function() {
 * @param {Object} e
 */
 DataTable.prototype._onSubSegmentChanged = function(e) {
-	var insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
-	var removalList = /** @type{Array.<string>} */(e["removalList"]);
-
-	var dirty = false;
-	var rows = this._rows;
-	var clsSource = this._clsSource || rows;
-	var rids = this._rids;
-	var prevData = this._prevData;
-	var i;
-
-	var removalCount = removalList.length;
-	var removedRows = {};
+	let insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
+	let removalList = /** @type{Array.<string>} */(e["removalList"]);
+
+	let dirty = false;
+	let rows = this._rows;
+	let clsSource = this._clsSource || rows;
+	let rids = this._rids;
+	let prevData = this._prevData;
+	let i;
+
+	let removalCount = removalList.length;
+	let removedRows = {};
 	for(i = 0; i < removalCount; i++) {
-		var rid = removalList[i];
+		let rid = removalList[i];
 		if(rows[rid]) {
 			removedRows[rid] = prevData[rid] = rows[rid];
 			delete rows[rid];
@@ -1467,17 +1485,17 @@ DataTable.prototype._onSubSegmentChanged = function(e) {
 		}
 	}
 
-	var insertionCount = insertionList.length;
+	let insertionCount = insertionList.length;
 	for(i = 0; i < insertionCount; i++) {
-		var segment = insertionList[i];
-		var parentId = segment.getParentId();
-		var segmentId = segment.getId();
+		let segment = insertionList[i];
+		let parentId = segment.getParentId();
+		let segmentId = segment.getId();
 
 		if(!rows[segmentId]) {
 			prevData[segmentId] = {};
 			segment.setRowData(rows, clsSource);
 
-			var parentAt = rids.indexOf(parentId);
+			let parentAt = rids.indexOf(parentId);
 			if(parentAt < 0 || parentAt + 1 >= rids.length) {
 				rids.push(segmentId);
 			} else {
@@ -1501,10 +1519,10 @@ DataTable.prototype._onSubSegmentChanged = function(e) {
 * @return {boolean} Return true if there is any change, otherwise false
 */
 DataTable.prototype._sort = function(sortingDefs) {
-	var rids = this._rids;
-	var dataRows = this.getMultipleRowData(rids);
-	var segmentValues = this.getSegmentValues(rids);
-	var change = DataTable._performMultiLevelSorting(dataRows, sortingDefs, segmentValues);
+	let rids = this._rids;
+	let dataRows = this.getMultipleRowData(rids);
+	let segmentValues = this.getSegmentValues(rids);
+	let change = DataTable._performMultiLevelSorting(dataRows, sortingDefs, segmentValues);
 
 	if(change) {
 		this._rids = DataTable._reorderItems(rids, change);
@@ -1554,7 +1572,7 @@ DataTable.prototype.dump = function(opt_options) {
 * @return {boolean} Return true if there is any change, and false otherwise
 */
 DataTable.prototype._setData = function(rid, cid, value) {
-	var row = this.getRowData(rid);
+	let row = this.getRowData(rid);
 
 	if(!row) {
 		row = {};
@@ -1572,12 +1590,12 @@ DataTable.prototype._setData = function(rid, cid, value) {
 * @returns {Array.<string>}
 */
 DataTable.prototype._generateRids = function(len, opt_ridList) {
-	var r = 0, rids;
+	let r = 0, rids;
 	if(opt_ridList) {
 		rids = opt_ridList;
 	} else {
 		rids = [];
-		var rowCount = this._rids.length;
+		let rowCount = this._rids.length;
 		while(r < rowCount && r < len) {
 			rids.push(this._rids[r++]);
 		}
@@ -1645,7 +1663,7 @@ DataTable._positionChangeArg = {"globalChange": true, "positionChangeOnly": true
 * @return {!Array.<Array>}
 */
 DataTable._buildSortContext = function(out_defs, cids, sortOrders, logics, contextObj) {
-	var aryColumnIds, aryOrders;
+	let aryColumnIds, aryOrders;
 	if(Array.isArray(cids)) {
 		aryColumnIds = /** @type{Array.<string>} */(cids);
 		aryOrders = /** @type{Array.<string|number>} */(sortOrders);
@@ -1654,24 +1672,24 @@ DataTable._buildSortContext = function(out_defs, cids, sortOrders, logics, conte
 		aryOrders = (cids) ? [/** @type{string|number} */(sortOrders)] : [0];
 	}
 
-	var logic = null;
-	var logicMap = null;
+	let logic = null;
+	let logicMap = null;
 	if(typeof logics == "function") {
 		logic = logics;
 	} else {
 		logicMap = /** @type{Array.<Function>|Object.<string, DataTable.SortLogic>} */(logics);
 	}
-	var len = aryColumnIds.length;
+	let len = aryColumnIds.length;
 	out_defs.length = len;
-	for(var c = len; --c >= 0;) {
+	for(let c = len; --c >= 0;) {
 		if (Array.isArray(logicMap)) {
 			logic = logicMap[c];
 		}
-		var sortingDef = out_defs[c];
+		let sortingDef = out_defs[c];
 		if(!sortingDef) {
 			sortingDef = out_defs[c] = new Array(5);
 		}
-		var columnId = aryColumnIds[c];
+		let columnId = aryColumnIds[c];
 		sortingDef[0] = columnId; // text field
 		sortingDef[1] = null; // Reserved for row data
 		sortingDef[2] = logic || logicMap[columnId] || logicMap["_default"]; // sort logic
@@ -1694,10 +1712,10 @@ DataTable._buildSortContext = function(out_defs, cids, sortOrders, logics, conte
 * @return {number}
 */
 DataTable._multiColumnCompareLogic = function(a, b, order, sortingDefs) {
-	var count = sortingDefs.length;
-	var result = 0;
-	for(var c = 0; c < count; ++c) {
-		var sortingDef = sortingDefs[c];
+	let count = sortingDefs.length;
+	let result = 0;
+	for(let c = 0; c < count; ++c) {
+		let sortingDef = sortingDefs[c];
 		result = DataTable._singleColumnCompareLogic(a, b, sortingDef[3], sortingDef);
 		if(result) {
 			return result;
@@ -1716,7 +1734,7 @@ DataTable._multiColumnCompareLogic = function(a, b, order, sortingDefs) {
 * @return {number}
 */
 DataTable._singleColumnCompareLogic = function(a, b, order, sortingDef) {
-	var values = /** @type{Array} */(sortingDef[1]);
+	let values = /** @type{Array} */(sortingDef[1]);
 	return /** @type{number} */(sortingDef[2](
 		values[a], // Value1
 		values[b], // Value2
@@ -1735,10 +1753,10 @@ DataTable._singleColumnCompareLogic = function(a, b, order, sortingDef) {
 * @return {number}
 */
 DataTable._multiColumnSeparatorCompareLogic = function(a, b, order, sortingDefs) {
-	var count = sortingDefs.length;
-	var result = 0;
-	for(var c = 0; c < count; ++c) {
-		var sortingDef = sortingDefs[c];
+	let count = sortingDefs.length;
+	let result = 0;
+	for(let c = 0; c < count; ++c) {
+		let sortingDef = sortingDefs[c];
 		result = DataTable._singleColumnSeparatorCompareLogic(a, b, sortingDef[3], sortingDef);
 		if(result) {
 			return result;
@@ -1757,7 +1775,7 @@ DataTable._multiColumnSeparatorCompareLogic = function(a, b, order, sortingDefs)
 * @return {number}
 */
 DataTable._singleColumnSeparatorCompareLogic = function(a, b, order, sortingDef) {
-	var key = /** @type{string} */(sortingDef[0]);
+	let key = /** @type{string} */(sortingDef[0]);
 	return /** @type{number} */(sortingDef[2](
 		a[key], // Value1
 		b[key], // Value2
@@ -1774,20 +1792,20 @@ DataTable._singleColumnSeparatorCompareLogic = function(a, b, order, sortingDef)
 * @return {Array.<number>} Returns new item positions if there is any change, otherwise returns null
 */
 DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentValues) {
-	var rowCount = dataRows ? dataRows.length : 0;
-	var defCount = sortingDefs ? sortingDefs.length : 0;
+	let rowCount = dataRows ? dataRows.length : 0;
+	let defCount = sortingDefs ? sortingDefs.length : 0;
 	if(!rowCount) {
 		return null;
 	}
 
-	var sortLogic;
+	let sortLogic;
 	// Populate data for each definition
-	for(var c = 0; c < defCount; ++c) {
-		var sortingDef = sortingDefs[c];
-		var rows = sortingDef[1];
+	for(let c = 0; c < defCount; ++c) {
+		let sortingDef = sortingDefs[c];
+		let rows = sortingDef[1];
 		sortLogic = sortingDef[2];
-		var rowSorting = sortLogic["rowSorting"];
-		var r;
+		let rowSorting = sortLogic["rowSorting"];
+		let r;
 		if(rowSorting) {
 			if(rows) {
 				rows.length = rowCount;
@@ -1803,7 +1821,7 @@ DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentVal
 			} else {
 				rows = sortingDef[1] = new Array(rowCount);
 			}
-			var columnId = sortingDef[0];
+			let columnId = sortingDef[0];
 			for(r = 0; r < rowCount; ++r) {
 				rows[r] = dataRows[r][columnId];
 			}
@@ -1811,7 +1829,7 @@ DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentVal
 	}
 
 	if(segmentValues) {
-		var segmentDef = [ // TODO: Make this static variable
+		let segmentDef = [ // TODO: Make this static variable
 			"ROW_SEGMENT", // Dummy column id
 			segmentValues, // Segment values
 			DataTable._segmentComparer,
@@ -1831,8 +1849,8 @@ DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentVal
 		return null;
 	}
 
-	var sortOrder = 0;
-	var sortContext;
+	let sortOrder = 0;
+	let sortContext;
 	if(defCount > 1) {
 		sortLogic = DataTable._multiColumnCompareLogic;
 		sortContext = sortingDefs;
@@ -1856,12 +1874,12 @@ DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentVal
 * @return {Array.<number>} Returns new item positions if there is any change, otherwise returns null
 */
 DataTable._mergeSort = function(len, order, comparer, contextObj) {
-	var change = false;
+	let change = false;
 
-	var grpSize = 1;
-	var iter, lhsFrom, rhsFrom, lhsTo, rhsTo;
-	var subj = DataTable._createIndexArray(len);
-	var obj = subj.slice();
+	let grpSize = 1;
+	let iter, lhsFrom, rhsFrom, lhsTo, rhsTo;
+	let subj = DataTable._createIndexArray(len);
+	let obj = subj.slice();
 
 	while(grpSize <= len) {
 		iter = rhsTo = 0; // start from 0
@@ -1903,7 +1921,7 @@ DataTable._mergeSort = function(len, order, comparer, contextObj) {
 			}
 		}
 
-		var tmp = subj;
+		let tmp = subj;
 		subj = obj;
 		obj = tmp;
 		grpSize <<= 1;
@@ -1921,7 +1939,7 @@ DataTable._mergeSort = function(len, order, comparer, contextObj) {
 */
 DataTable._reorderItems = function (ary, orders) {
 	if(orders) {
-		for(var i = ary.length; --i >= 0;) {
+		for(let i = ary.length; --i >= 0;) {
 			orders[i] = ary[orders[i]];
 		}
 		return orders;
@@ -1936,7 +1954,7 @@ DataTable._reorderItems = function (ary, orders) {
 * @return {!Array.<number>}
 */
 DataTable._createIndexArray = function(len) {
-	var ary = DataTable._idxAryMap[len];
+	let ary = DataTable._idxAryMap[len];
 	if(!ary) {
 		if(DataTable._idxAryCount > 50) { // Clear cache to avoid caching huge memory
 			DataTable._idxAryMap = {};
@@ -1945,7 +1963,7 @@ DataTable._createIndexArray = function(len) {
 		ary = DataTable._idxAryMap[len] = new Array(len);
 		DataTable._idxAryCount++;
 
-		for(var i = 0; i < len; ++i) {
+		for(let i = 0; i < len; ++i) {
 			ary[i] = i;
 		}
 	}