@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,42 @@
+
+
+declare class ColumnStats {
+
+    constructor(source?: any, field?: string);
+
+    public dispose(): void;
+
+    public setDataSource(source: any): void;
+
+    public setField(field: string): void;
+
+    public disableOnDemandMode(opt_disabled?: boolean): void;
+
+    public setColumnDataGetter(func: ((...params: any[]) => any)): void;
+
+    public getColumnDataGetter(): ((...params: any[]) => any);
+
+    public getSum(): number;
+
+    public getDataCount(): number;
+
+    public getMin(): number;
+
+    public getMax(): number;
+
+    public getAbsoluteMax(): number;
+
+    public getAverage(): number;
+
+    public getMean(): number;
+
+    public getMidRange(): number;
+
+    public getCachedColumnData(): (number)[];
+
+    public markDirty(): boolean;
+
+}
+
+export default ColumnStats;
+export { ColumnStats };

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

@@ -0,0 +1,428 @@
+
+/** @constructor
+* @param {*=} source
+* @param {string=} field
+*/
+var ColumnStats = function(source, field) {
+	this._onDataChanged = this._onDataChanged.bind(this);
+
+	this._refs = [];
+	if(source) {
+		this._dt = source;
+		this._dt["listen"]("dataChanged", this._onDataChanged, 0); // Setting priority to be prioritized first
+	}
+	if(field) {
+		this._field = field;
+	}
+};
+
+//#region Public
+/** @public
+*/
+ColumnStats.prototype.dispose = function() {
+	if(this._dt) {
+		this._dt["unlisten"]("dataChanged", this._onDataChanged);
+		this._dt = null;
+	}
+};
+/** @public
+* @param {*} source
+*/
+ColumnStats.prototype.setDataSource = function(source) {
+	if(this._dt === source) { return; }
+
+	if(this._dt) {
+		this._dt["unlisten"]("dataChanged", this._onDataChanged);
+	}
+
+	this._dt = source;
+
+	if(this._dt) {
+		this._dt["listen"]("dataChanged", this._onDataChanged, 0); // Setting priority to be prioritized first
+	}
+
+	this._requestRecalculation();
+};
+/** @public
+* @param {string} field
+*/
+ColumnStats.prototype.setField = function(field) {
+	if(this._field !== field) {
+		this._field = field;
+
+		this._requestRecalculation();
+	}
+};
+/** @public
+* @param {boolean=} opt_disabled
+*/
+ColumnStats.prototype.disableOnDemandMode = function(opt_disabled) {
+	var enabled = opt_disabled === false;
+	if(this._onDemandMode !== enabled) {
+		this._onDemandMode = enabled;
+		this._requestRecalculation();
+	}
+};
+/** @public
+* @param {Function} func
+*/
+ColumnStats.prototype.setColumnDataGetter = function(func) {
+	if(this._colDataGetter !== func) {
+		this._colDataGetter = func;
+		this._requestRecalculation();
+	}
+};
+/** @public
+* @return {Function}
+*/
+ColumnStats.prototype.getColumnDataGetter = function() {
+	return this._colDataGetter;
+};
+/** @public
+* @return {number} Summation of all values
+*/
+ColumnStats.prototype.getSum = function() {
+	this._updateStats();
+
+	return this._sum;
+};
+/** @public
+* @return {number} The count of valid data, excluding all invalid data such as undefined, null, string, and NaN
+*/
+ColumnStats.prototype.getDataCount = function() {
+	this._updateStats();
+
+	return this._count;
+};
+
+/** @public
+* @return {number} Minimum value
+*/
+ColumnStats.prototype.getMin = function() {
+	this._updateStats();
+
+	return this._min;
+};
+/** @public
+* @return {number} Maximum value
+*/
+ColumnStats.prototype.getMax = function() {
+	this._updateStats();
+
+	return this._max;
+};
+/** @public
+* @return {number} Maximum absolute value
+*/
+ColumnStats.prototype.getAbsoluteMax = function() {
+	this._updateStats();
+
+	var absMax = (this._max >= 0) ? this._max : -this._max;
+	var absMin = (this._min >= 0) ? this._min : -this._min;
+
+	return (absMax >= absMin) ? absMax : absMin;
+};
+
+/** @public
+* @return {number} Average. NaN is returned if data count is zero.
+*/
+ColumnStats.prototype.getAverage = function() {
+	this._updateStats();
+
+	return this._sum / this._count;
+};
+/** @function
+* @public
+* @return {number} Mean. NaN is returned if data count is zero.
+*/
+ColumnStats.prototype.getMean = ColumnStats.prototype.getAverage;
+/** @public
+* @return {number} Mid-extreme. The arithmetic mean of the maximum and minimum values in a data set. NaN is returned if there is no valid data.
+*/
+ColumnStats.prototype.getMidRange = function() {
+	this._updateStats();
+
+	return (this._max + this._min) * 0.5;
+};
+/** @public
+* @return {Array.<number>}
+*/
+ColumnStats.prototype.getCachedColumnData = function() {
+	if(this._dirty) {
+		this._recalculate();
+	} else if(!this._cacheData) {
+		this._cacheData = this._getColData();
+	}
+
+	return this._cacheData;
+};
+
+/** Mark this ColumnStats object as dirty to force re-calculation next time the data is retrieved
+* @public
+* @return {boolean}
+*/
+ColumnStats.prototype.markDirty = function() {
+	if(this._onDemandMode) {
+		this._dirty = true;
+		return this._dirty;
+	}
+	return false;
+};
+
+//#endregion Public
+
+//#region Private
+/** @private
+* @return {Array.<number>}
+*/
+ColumnStats.prototype._getColData = function() {
+	if(this._colDataGetter) {
+		return /** @type{Array.<number>} */(this._colDataGetter(this._field, this._dt));
+	}
+
+	return /** @type{Array.<number>} */(this._dt["getColumnData"](this._field));
+};
+/** @private
+*/
+ColumnStats.prototype._requestRecalculation = function() {
+	if(!this.markDirty()) {
+		this._recalculate();
+	}
+};
+/** @private
+*/
+ColumnStats.prototype._updateStats = function() {
+	if(this._dirty) {
+		this._recalculate();
+	}
+};
+/** @private
+*/
+ColumnStats.prototype._recalculate = function() {
+	this._dirty = false;
+	this._cacheData = null;
+	this._sum = 0;
+	this._min = NaN;
+	this._max = NaN;
+	this._count = 0;
+
+	if (!this._dt || !this._field) {
+		return;
+	}
+
+	var cacheData = this._cacheData = this._getColData();
+	var len = cacheData.length;
+
+	if (!len) {
+		return;
+	}
+
+	var isDataNumeric = ColumnStats._isDataNumeric;
+
+	var i = 0;
+	var data;
+
+	while (i < len) { // Find first valid index for max and min value
+		data = +cacheData[i++];
+
+		if (isDataNumeric(data)) {
+			this._sum = this._min = this._max = data;
+			++this._count;
+
+			break;
+		}
+	}
+
+	while (i < len) {
+		data = +cacheData[i];
+
+		if (isDataNumeric(data)) {
+			this._sum += data;
+
+			if (data < this._min) {
+				this._min = data;
+			} else if (data > this._max) {
+				this._max = data;
+			}
+
+			++this._count;
+		}
+
+		++i;
+	}
+};
+
+/** @private
+* @param {Object} e
+*/
+ColumnStats.prototype._onDataChanged = function(e) {
+	if(e["rid"]) {
+		if(!this._colDataGetter && e["changes"]) {
+			if(e["changes"][this._field] == null) {
+				return; // No change in the interested field
+			}
+		}
+
+		if(this.markDirty()) {
+			return;
+		}
+
+		this._updateRowData(e["rid"]);
+	} else if(e["rids"]) {
+		if(this.markDirty()) {
+			return;
+		}
+
+		var rids = e["rids"];
+		if(rids.length === 1) {
+			this._updateRowData(rids[0]);
+		} else {
+			this._recalculate();
+		}
+	} else if(e["globalChange"]) {
+		if(e["positionChangeOnly"]) {
+			this._cacheData = null;
+			return; // No data change in this update
+		}
+
+		this._requestRecalculation();
+	}
+};
+/** @private
+ * @param {string} rid
+ * @returns {void}
+*/
+ColumnStats.prototype._updateRowData = function(rid) {
+	var prevData = this._dt["getPreviousData"](rid, this._field);
+	var newData = this._dt["getData"](rid, this._field);
+	if(prevData === newData) {
+		return;
+	}
+
+	var newValid = ColumnStats._isDataNumeric(newData);
+
+	if(ColumnStats._isDataNumeric(prevData)) {
+		if(this._min === prevData) {
+			if(!newValid || newData > this._min) { // New value is actually greater than previous data
+				this._recalculate();
+				return;
+			}
+		}
+		if(this._max === prevData) {
+			if(!newValid || newData < this._max) { // New value is actually lesser than previous data
+				this._recalculate();
+				return;
+			}
+		}
+
+		this._sum -= prevData;
+		--this._count;
+	}
+
+	if(newValid) {
+		this._sum += newData;
+		if(!(newData >= this._min)) { // this._min can be NaN
+			this._min = newData;
+		}
+		if(!(newData <= this._max)) { // this._max can be NaN
+			this._max = newData;
+		}
+		++this._count;
+	}
+};
+/**
+* @private
+* @function
+* @param {*} data
+* @return {boolean}
+*/
+ColumnStats._isDataNumeric = function(data) {
+	return (typeof data === "number") && (data === data);
+};
+
+/** @public
+* @ignore
+* @param {string=} ref
+* @return {number}
+*/
+ColumnStats.prototype.addRef = function(ref) {
+	if(ref) {
+		if(this._refs.indexOf(ref) < 0) {
+			this._refs.push(ref);
+		}
+	}
+	return this._refs.length;
+};
+/** @public
+* @ignore
+* @param {string=} ref
+* @return {number}
+*/
+ColumnStats.prototype.deRef = function(ref) {
+	if(ref) {
+		var at = this._refs.indexOf(ref);
+		if(at >= 0) {
+			this._refs.splice(at, 1);
+		}
+	}
+	return this._refs.length;
+};
+/** @public
+* @ignore
+* @return {number}
+*/
+ColumnStats.prototype.getRefCount = function() {
+	return this._refs.length;
+};
+
+
+/** @private
+* @type {*}
+*/
+ColumnStats.prototype._dt = null;
+/** @private
+* @type {string}
+*/
+ColumnStats.prototype._field = "";
+/** @private
+* @type {boolean}
+*/
+ColumnStats.prototype._onDemandMode = true;
+/** @private
+* @type {boolean}
+*/
+ColumnStats.prototype._dirty = true;
+
+/** @private
+* @type {Array.<number>}
+*/
+ColumnStats.prototype._cacheData = null;
+
+/** @private
+* @type {number}
+*/
+ColumnStats.prototype._sum = 0;
+/** @private
+* @type {number}
+*/
+ColumnStats.prototype._min = NaN;
+/** @private
+* @type {number}
+*/
+ColumnStats.prototype._max = NaN;
+/** @private
+* @type {number}
+*/
+ColumnStats.prototype._count = 0;
+/** @private
+* @type {Function}
+*/
+ColumnStats.prototype._colDataGetter = null;
+/** @private
+* @type {!Array.<string>}
+*/
+ColumnStats.prototype._refs;
+//#endregion Private
+
+export default ColumnStats;
+export { ColumnStats };

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

@@ -0,0 +1,81 @@
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../grid/event/EventDispatcher.js";
+
+declare class DataCache extends EventDispatcher {
+
+    constructor();
+
+    public dispose(): void;
+
+    public setSubscriptions(subs: any): void;
+
+    public getSubscriptions(): any;
+
+    public addSubscription(sub: any, opt_primaryRic?: string, opt_values?: any): void;
+
+    public removeSubscription(sub: any): void;
+
+    public startAllSubscriptions(): void;
+
+    public stopAllSubscriptions(): void;
+
+    public getSubscription(sub_id: string): any;
+
+    public getPrimaryRic(sub_id: string): string;
+
+    public clearAllData(opt_suppressEvent?: boolean): void;
+
+    public clearColumnData(colId: (string)[]|string, opt_suppressEvent?: boolean): void;
+
+    public getData(rid: string, cid: string): any;
+
+    public getAllRics(): { [key: string]:  any };
+
+    public getAllRowIds(): (string)[];
+
+    public hasRowId(rid: string): boolean;
+
+    public getColumnData(cid: string): (any)[];
+
+    public getRowData(rid: string): { [key: string]:  any };
+
+    public getMultipleRowData(rids: (string)[], opt_from?: number, opt_to?: number): (any)[];
+
+    public getAllRowData(): ({ [key: string]:  any })[];
+
+    public setData(rid: string, cid: string, value: any): boolean;
+
+    public hasDataCloudData(rid: string): boolean;
+
+    public setRowData(rid: string, values?: { [key: string]:  any }, opt_eventArg?: any): boolean;
+
+    public cloneRowData(rid: string): any;
+
+    public addStaticFields(fields: (string)[]): void;
+
+    public removeStaticFields(fields: (string)[]): void;
+
+    public resetStaticFields(): void;
+
+    public getStaticFields(): { [key: string]:  number };
+
+    public dump(options?: any): (any)[];
+
+    public log(opt_options?: any): void;
+
+    public setDataCloudSettings(userId: string, productId: string, url: string, opt_lang?: string): void;
+
+    public getDataCloudFields(): (string)[];
+
+    public addDataCloudFields(fields: (string)[]|string): boolean;
+
+    public removeDataCloudField(field: string): boolean;
+
+}
+
+declare function cid(rid: string, cid: string): any;
+
+declare function ricMap(field: string): boolean;
+
+export default DataCache;
+export { DataCache };