@refinitiv-ui/efx-grid 6.0.12 → 6.0.14

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

@@ -1231,7 +1231,7 @@ DataCache.prototype._cloneRowData = function (obj, ric, newSubId) {
 
 /** @protected
  * @ignore
- * @type {!Object.<string, Object.<string, *>>}
+ * @type {!Object.<string, Object>}
  */
 DataCache.prototype._rows;
 

package/lib/core/es6/data/DataTable.d.ts

@@ -1,6 +1,7 @@
 import Ext from "../../../tr-grid-util/es6/Ext.js";
 import DataCache from "./DataCache.js";
 import Util from "../grid/util/util.js";
+import Segment from "./Segment.js"; // eslint-disable-line
 import SegmentCollection from "./SegmentCollection.js";
 
 declare namespace DataTable {
@@ -41,7 +42,7 @@ declare class DataTable extends DataCache {
 
     public unshiftRow(opt_values?: { [key: string]:  any }|null, opt_rid?: string|null|null): string;
 
-    public insertRow(rowRef?: string|number|null|null, values?: { [key: string]:  any }|null, rid?: string|null|null): string;
+    public insertRow(rowRef?: (string|number|null)|null, values?: { [key: string]:  any }|null, rid?: string|null|null): string;
 
     public insertAfter(rowRef: string|number|null, opt_values?: any, opt_rid?: string|null): string;
 
@@ -83,6 +84,10 @@ declare class DataTable extends DataCache {
 
     public isSegmentSeparator(rid: string): boolean;
 
+    public getSegment(rid: string): Segment|null;
+
+    public getSegmentLevel(rid: string): number;
+
     public getSegmentParentRowId(rid: string): string;
 
     public getSegmentValues(rids?: (string)[]|null): (number)[]|null;
@@ -91,7 +96,7 @@ declare class DataTable extends DataCache {
 
     public fillSegments(): boolean;
 
-    public addSegmentChild(segmentId: string, rid: string): boolean;
+    public addSegmentChild(segmentId: string, rid: string, dataId?: string|null): boolean;
 
     public addSegmentChildren(segmentId: string, rids: (string)[]|null): boolean;
 
@@ -105,7 +110,15 @@ declare class DataTable extends DataCache {
 
     public getSegmentChildIds(segmentId: string): (string)[]|null;
 
-    public sortSegments(compare: ((...params: any[]) => any)|null): void;
+    public sortSegments(compare: ((...params: any[]) => any)|null): boolean;
+
+    public setClassificationSource(dc: DataCache|null): void;
+
+    public setSegmentClassification(segmentId: string, fields: string|(string)[]|null): boolean;
+
+    public classifySegments(): boolean;
+
+    public requestClassifying(): void;
 
     public dispatchGlobalChange(suppressEvent?: boolean|null): void;
 
@@ -119,6 +132,8 @@ declare function prevFrozen(ary: (any)[][], opt_cidList?: (string)[]|null, opt_r
 
 declare function cid(): null;
 
+declare function removalList(sortingDefs: (any[])[]|null): boolean;
+
 declare function logic(a: number, b: number, order: number, sortingDefs: (any[])[]|null): number;
 
 export default DataTable;

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

@@ -1,6 +1,7 @@
 import Ext from "../../../tr-grid-util/es6/Ext.js";
 import DataCache from "./DataCache.js";
 import Util from "../grid/util/util.js";
+import Segment from "./Segment.js"; // eslint-disable-line
 import SegmentCollection from "./SegmentCollection.js";
 
 /** Trigger when data within the table has been changed
@@ -23,11 +24,15 @@ var DataTable = function() {
 
 	this._removeRows = this._removeRows.bind(this);
 	this._bySegmentSeparator = this._bySegmentSeparator.bind(this);
+	this._onClassifyingTimer = this._onClassifyingTimer.bind(this);
+	this._onSubSegmentChanged = this._onSubSegmentChanged.bind(this);
 
 	this._prevData = {};
 	this._rids = [];
 
 	this._compMap = {};
+
+	this._addEvent("subSegmentChanged");
 };
 Ext.inherits(DataTable, DataCache);
 
@@ -70,6 +75,14 @@ DataTable.prototype._removedRows = null;
 * @type {Function}
 */
 DataTable.prototype._userSegmentComparer = null;
+/** @private
+* @type {Object.<string, Object>}
+*/
+DataTable.prototype._clsSource = null;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._classifyingTimer = 0;
 
 
 /** @typedef {Function} DataTable~SortLogic
@@ -98,8 +111,17 @@ DataTable.prototype.dispose = function() {
 	this.unlistenAll();
 	this.clearAllData(true);
 
+	if(this._classifyingTimer) {
+		clearTimeout(this._onClassifyingTimer);
+		this._classifyingTimer = 0;
+	}
+
 	this._compMap = null; // Release user function that may be bound
-	this._segments = null;
+	this._clsSource = null;
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+	}
 };
 
 /** {@link DataCache#getColumnData}
@@ -217,7 +239,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			this._prevData[rid] = {};
 			if(eventArg) {
 				var nextRid = /** @type{string} */(eventArg["nextRid"]); // Used for insertion only
-				var rowIndex = (nextRid != null) ? this.getRowIndex(nextRid) : -1;
+				var rowIndex = (nextRid) ? this.getRowIndex(nextRid) : -1;
 				if(rowIndex < 0) {
 					rowIndex = /** @type{number} */(eventArg["fallback"]);
 				}
@@ -249,6 +271,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 				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;
@@ -256,12 +279,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 					}
 				}
 			}
-			for(var i = this._rids.length; --i >= 0;) {
-				if(this._rids[i] === rid) {
-					this._rids.splice(i, 1);
-					break;
-				}
-			}
+			DataTable._removeArrayItem(this._rids, rid);
 			dirty = true;
 		}
 	}
@@ -280,7 +298,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			}
 			this._dispatchDataChange(e);
 		}
-
+		this.requestClassifying(); // TODO: Check if needFiring method should have an effect on this request
 	}
 	return dirty;
 };
@@ -483,7 +501,7 @@ DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
 	return this.insertRow(0, opt_values, opt_rid);
 };
 /** @public
-* @param {string|number|null=} rowRef
+* @param {(string|number|null)=} rowRef
 * @param {Object.<string, *>=} values Key/value pair object map
 * @param {string|null=} rid If the given row Id already exists, data is updated and no new row is added. Leave blank or null to let DataTable generate unique row Id
 * @return {string} Return Row id that has been inserted or changed
@@ -492,11 +510,13 @@ DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
 * @see {@link DataTable#removeRow}
 */
 DataTable.prototype.insertRow = function(rowRef, values, rid) {
-	var arg = {};
+	var arg = null;
 	if(typeof rowRef === "number") {
+		arg = {};
 		arg["nextRid"] = this._rids[rowRef];
 		arg["fallback"] = rowRef; // Fallback index in case of no nextRid found
-	} else {
+	} else if(rowRef) {
+		arg = {};
 		arg["nextRid"] = /** @type{string} */(rowRef);
 	}
 
@@ -581,12 +601,34 @@ DataTable.prototype.removeRows = function(refs) {
 DataTable.prototype._removeRows = function(rid) {
 	return !this._removedRows[rid];
 };
+
+/** @private
+* @param {Array} ary
+* @param {*} item
+* @return {boolean}
+*/
+DataTable._removeArrayItem = function(ary, item) {
+	var at = ary.indexOf(item);
+	if(at >= 0) {
+		if(at >= ary.length) {
+			ary.pop(); // Array.pop is 100 times faster than Array.splice
+		} else {
+			ary.splice(at, 1);
+		}
+		return true;
+	}
+	return false;
+};
 /** Remove all existing rows
 * @override
 */
 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
+	}
 
 	if(this._rids.length) {
 		this._rids.length = 0;
@@ -893,6 +935,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 		if(enabled !== false) {
 			if(!this._segments) {
 				this._segments = new SegmentCollection();
+				this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
 			}
 			if(this._autoSegmentFilling) {
 				var parentId = this._segments.getParentRowId(rid);
@@ -965,6 +1008,29 @@ DataTable.prototype.isSegmentSeparator = function(rid) {
 	}
 	return false;
 };
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegment = function(rid) {
+	if(this._segments) {
+		return this._segments.getSegment(rid);
+	}
+	return null;
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegmentLevel = function(rid) {
+	var segment = this.getSegment(rid);
+	if(segment) {
+		return segment.getSegmentLevel() + 1;
+	}
+	return 0;
+};
 /**
 * @public
 * @param {string} rid
@@ -1038,6 +1104,7 @@ DataTable.prototype.fillSegment = function(segmentId) {
 	if(this._segments) {
 		this._segments.fillSegment(segmentId, this._rids);
 		this.dispatchGlobalChange();
+		this.requestClassifying();
 	}
 };
 /** Remove all existing segment children in each segment and fill the segments with all contnet rows before the next segment separator
@@ -1049,6 +1116,7 @@ DataTable.prototype.fillSegments = function() {
 		var dirty = this._segments.fillSegments(this._rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -1057,15 +1125,17 @@ DataTable.prototype.fillSegments = function() {
 /** @public
 * @param {string} segmentId Row id
 * @param {string} rid Row id
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataTable.prototype.addSegmentChild = function(segmentId, rid) {
+DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChild(segmentId, rid);
+		var dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -1083,6 +1153,7 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -1098,6 +1169,7 @@ DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 		var dirty = this._segments.removeSegmentChild(segmentId, rid);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -1113,6 +1185,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 		var dirty = this._segments.removeSegmentChildren(segmentId, rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -1123,7 +1196,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 */
 DataTable.prototype.removeAllSegmentChildren = function() {
 	if(this._segments) {
-		var dirty = this._segments.removeAllSegmentChildren();
+		var dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
 		if (dirty) {
 			this.dispatchGlobalChange();
 		}
@@ -1159,10 +1232,15 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
+* @return {boolean}
 */
 DataTable.prototype.sortSegments = function (compare) {
-	if(!this._segments || typeof compare !== "function") {
-		return;
+	if(!this._segments) {
+		return false;
+	}
+	if(typeof compare !== "function") {
+		this._segments.calcSegmentOrder(this._rids);
+		return false;
 	}
 	var rids = this._rids;
 	var segments = this._segments;
@@ -1206,7 +1284,9 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
+		return true;
 	}
+	return false;
 };
 /** Sort all of existing segments by given compare function
 * @private
@@ -1221,6 +1301,112 @@ DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
 	));
 };
 
+/** A data source to be used with segment classification
+* @public
+* @param {DataCache} dc
+*/
+DataTable.prototype.setClassificationSource = function(dc) {
+	this._clsSource = null;
+
+	if(dc && dc._rows) {
+		this._clsSource = dc._rows;
+	}
+};
+/**
+* @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataTable.prototype.setSegmentClassification = function(segmentId, fields) {
+	if(this._segments) {
+		var dirty = this._segments.setSegmentClassification(segmentId, fields);
+		if(dirty) {
+			return this.classifySegments();
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+DataTable.prototype.classifySegments = function() {
+	if(this._segments) {
+		if(this._rids.length) {
+			return this._segments.classify(this._clsSource || this._rows);
+		}
+	}
+	return false;
+};
+
+/** @public
+*/
+DataTable.prototype.requestClassifying = function() {
+	if(this._segments && !this._classifyingTimer) {
+		if(this._segments.hasClassification()) {
+			this._classifyingTimer = setTimeout(this._onClassifyingTimer, 10);
+		}
+	}
+};
+/** @private
+*/
+DataTable.prototype._onClassifyingTimer = function() {
+	this._classifyingTimer = 0;
+	this.classifySegments();
+};
+/** @private
+* @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 = {};
+	for(i = 0; i < removalCount; i++) {
+		var rid = removalList[i];
+		if(rows[rid]) {
+			removedRows[rid] = prevData[rid] = rows[rid];
+			delete rows[rid];
+			DataTable._removeArrayItem(rids, rid);
+			dirty = true;
+			// TODO: Remove classification source
+		}
+	}
+
+	var insertionCount = insertionList.length;
+	for(i = 0; i < insertionCount; i++) {
+		var segment = insertionList[i];
+		var parentId = segment.getParentId();
+		var segmentId = segment.getId();
+
+		if(!rows[segmentId]) {
+			prevData[segmentId] = {};
+			segment.setRowData(rows, clsSource);
+
+			var parentAt = rids.indexOf(parentId);
+			if(parentAt < 0 || parentAt + 1 >= rids.length) {
+				rids.push(segmentId);
+			} else {
+				rids.splice(parentAt + 1, 0, segmentId);
+			}
+			dirty = true;
+		}
+	}
+	if(dirty) {
+		e["removedRows"] = removedRows;
+		this._dispatch("subSegmentChanged", e);
+		this.dispatchGlobalChange(); // Rerender everything
+	}
+};
+
 
 /**
 * @public

package/lib/core/es6/data/DataView.d.ts

@@ -3,6 +3,7 @@ import DataCache from "./DataCache.js";
 import DataTable from "./DataTable.js";
 import WrappedView from "./WrappedView.js"; // eslint-disable-line
 import ColumnStats from "./ColumnStats.js";
+import Segment from "./Segment.js"; // eslint-disable-line
 import EventDispatcher from "../grid/event/EventDispatcher.js";
 import Util from "../grid/util/util.js";
 import { Conflator } from "../../../tr-grid-util/es6/Conflator.js";
@@ -233,6 +234,10 @@ declare class DataView extends EventDispatcher {
 
     public isSegmentSeparator(rid: string): boolean;
 
+    public getSegment(rid: string): Segment|null;
+
+    public getSegmentLevel(rid: string): number;
+
     public getSegmentParentRowId(rid: string): string;
 
     public collapseSegment(rowRef: string|number|null, collapsed?: boolean|null): boolean;
@@ -247,7 +252,7 @@ declare class DataView extends EventDispatcher {
 
     public fillSegments(): void;
 
-    public addSegmentChild(segmentRef: string|number|null, rowRef: string|number|null): boolean;
+    public addSegmentChild(segmentRef: string|number|null, rowRef: string|number|null, dataId?: string|null): boolean;
 
     public addSegmentChildren(segmentRef: string|number|null, rowRefs: (string|number)[]|null): boolean;
 
@@ -263,6 +268,8 @@ declare class DataView extends EventDispatcher {
 
     public sortSegments(compare: ((...params: any[]) => any)|null): void;
 
+    public setSegmentClassification(segmentRef: string|number|null, fields: string|(string)[]|null): boolean;
+
     public getWrapSize(): number;
 
     public getWrappedViews(): (WrappedView)[]|null;

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

@@ -3,6 +3,7 @@ import DataCache from "./DataCache.js";
 import DataTable from "./DataTable.js";
 import WrappedView from "./WrappedView.js"; // eslint-disable-line
 import ColumnStats from "./ColumnStats.js";
+import Segment from "./Segment.js"; // eslint-disable-line
 import EventDispatcher from "../grid/event/EventDispatcher.js";
 import Util from "../grid/util/util.js";
 import { Conflator } from "../../../tr-grid-util/es6/Conflator.js";
@@ -2347,6 +2348,22 @@ DataView.prototype.isSegmentSeparator = function(rid) {
 	return this._dt.isSegmentSeparator(rid);
 };
 
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegment = function(rid) {
+	return this._dt.getSegment(rid);
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid Row id
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegmentLevel = function(rid) {
+	return this._dt.getSegmentLevel(rid);
+};
 /**
 * @public
 * @param {string} rid
@@ -2428,13 +2445,14 @@ DataView.prototype.fillSegments = function() {
 /** @public
 * @param {string|number} segmentRef Row id or row index
 * @param {string|number} rowRef Row id, row index
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataView.prototype.addSegmentChild = function(segmentRef, rowRef) {
+DataView.prototype.addSegmentChild = function(segmentRef, rowRef, dataId) {
 	if(this._dt._getSegmentSeparators()) {
 		var segmentId = this._toRowId(segmentRef);
 		var rowId = this._toRowId(rowRef);
-		return this._dt.addSegmentChild(segmentId, rowId);
+		return this._dt.addSegmentChild(segmentId, rowId, dataId);
 	}
 	return false;
 };
@@ -2506,6 +2524,16 @@ DataView.prototype.sortSegments = function (compare) {
 	this._dt.sortSegments(compare);
 };
 
+/**
+* @public
+* @param {string|number} segmentRef Row id or row index
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataView.prototype.setSegmentClassification = function(segmentRef, fields) {
+	return this._dt.setSegmentClassification(this._toRowId(segmentRef), fields);
+};
+
 /** @public
 * @ignore
 * @return {Object}

package/lib/core/es6/data/Segment.d.ts

@@ -1,20 +1,27 @@
-
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../../../tr-grid-util/es6/EventDispatcher.js";
 
 declare class Segment {
 
-    constructor(rid: string);
+    constructor(rid: string, sharedObj: any);
+
+    public dispose(): void;
 
     public getId(): string;
 
-    public addChild(rid: string, objMap?: any): boolean;
+    public getParentId(): string;
+
+    public getSubSegmentIds(out_ary?: (string)[]|null): (string)[]|null;
 
-    public addChildren(rids: (string)[]|null, objMap?: any): boolean;
+    public addChild(rid: string, dataId?: string|null): boolean;
+
+    public addChildren(rids: (string)[]|null): boolean;
 
     public containsChild(rid: string): boolean;
 
-    public removeChild(rid: string, objMap?: any): boolean;
+    public removeChild(rid: string): boolean;
 
-    public removeChildren(rids: (string)[]|null, objMap?: any): boolean;
+    public removeChildren(rids: (string)[]|null): boolean;
 
     public removeAllChildren(objMap?: any): boolean;
 
@@ -22,22 +29,40 @@ declare class Segment {
 
     public getChildCount(): number;
 
+    public getClassification(): (string)[]|null;
+
+    public setClassification(fields: string|(string)[]|null): boolean;
+
+    public classify(rows?: { [key: string]:  any }|null): boolean;
+
+    public hasSubSegments(): boolean;
+
+    public isSubSegment(): boolean;
+
+    public getFirstAncestor(): Segment|null;
+
+    public getAllSubSegments(out_ary?: (Segment)[]|null): (Segment)[]|null;
+
+    public getSegmentLevel(): number;
+
+    public setRowData(rows?: any, clsSource?: any): void;
+
+    public getSubSegmentName(row?: any): string;
+
     public collapse(bool?: boolean|null): boolean;
 
     public expand(bool?: boolean|null): boolean;
 
     public isCollapsed(): boolean;
 
-    public getCollapsingStates(objMap?: any): any;
-
-    public getValue(): number;
-
-    public setValue(val: number): void;
+    public getCollapsingStates(objMap?: any, parentState?: boolean|null): number;
 
     public getOrder(): number;
 
     public setOrder(val: number): void;
 
+    public log(lines: (string)[]|null): (string)[]|null;
+
 }
 
 export default Segment;