@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/rt-grid/es6/PredefinedFormula.d.ts

@@ -0,0 +1,16 @@
+
+
+declare class PredefinedFormula {
+
+    constructor();
+
+    public static set(field: string, formula: string): void;
+
+    public static get(field: string): string;
+
+    public static remove(field: string): void;
+
+}
+
+export {PredefinedFormula};
+export default PredefinedFormula;

package/lib/rt-grid/es6/PredefinedFormula.js

@@ -0,0 +1,33 @@
+
+/* @constructor */
+let PredefinedFormula = {};
+/** @private
+* @type {Object<string, string>}
+*/
+PredefinedFormula._formulas = {};
+/** @public
+* @function
+* @param {string} field
+* @param {string} formula
+*/
+PredefinedFormula.set = function(field, formula) {
+	PredefinedFormula._formulas[field] = formula;
+};
+/** @public
+* @function
+* @param {string} field
+* @return {string}
+*/
+PredefinedFormula.get = function(field) {
+	return PredefinedFormula._formulas[field] || "";
+};
+/** @public
+* @function
+* @param {string} field
+*/
+PredefinedFormula.remove = function(field) {
+	delete PredefinedFormula._formulas[field];
+};
+
+export {PredefinedFormula};
+export default PredefinedFormula;

package/lib/rt-grid/es6/ReferenceCounter.d.ts

@@ -0,0 +1,40 @@
+
+
+declare class ReferenceCounter {
+
+    constructor();
+
+    public reset(): void;
+
+    public newSession(): void;
+
+    public getAllReferences(): (string)[];
+
+    public hasReference(): boolean;
+
+    public getAllReferers(): (string)[];
+
+    public getAllReferrers(): (string)[];
+
+    public getSession(): any;
+
+    public addReference(key: string, referer?: string|null): boolean;
+
+    public addRef(key: string): boolean;
+
+    public removeReference(key: string, referer?: string|null, count?: number|null): boolean;
+
+    public release(key: string): void;
+
+    public addReferences(keys: (string|(string)[]|any)|null, referer?: string|null): number;
+
+    public removeReferer(referer?: string|null): number;
+
+    public removeReferrer(referer?: string|null): number;
+
+    public log(): void;
+
+}
+
+export {ReferenceCounter};
+export default ReferenceCounter;

package/lib/rt-grid/es6/ReferenceCounter.js

@@ -0,0 +1,251 @@
+/** @constructor
+*/
+let ReferenceCounter = function() {
+	this._counter = {};
+	this._session = {};
+	this._referers = {};
+};
+
+/** @type {Object.<string, number>}
+* @private
+**/
+ReferenceCounter.prototype._counter = null;
+/** @type {Object.<string, number>}
+* @private
+**/
+ReferenceCounter.prototype._session = null;
+/** @type {Object.<string, Object>}
+* @private
+**/
+ReferenceCounter.prototype._referers = null;
+
+
+/** @public
+*/
+ReferenceCounter.prototype.reset = function() {
+	this._counter = {};
+	this._referers = {};
+	this.newSession();
+};
+/** @public
+*/
+ReferenceCounter.prototype.newSession = function() {
+	this._session = {};
+};
+
+/** @public
+* @return {!Array.<string>}
+*/
+ReferenceCounter.prototype.getAllReferences = function() {
+	return Object.keys(this._counter);
+};
+
+/** @public
+* @return {boolean}
+*/
+ReferenceCounter.prototype.hasReference = function() {
+	for (const key in this._counter) {
+		return true;
+	}
+	return false;
+};
+
+/** @public
+* @return {!Array.<string>}
+*/
+ReferenceCounter.prototype.getAllReferers = function() {
+	return Object.keys(this._referers);
+};
+/** Alias to ReferenceCounter.getAllReferers
+* @public
+* @function
+* @return {!Array.<string>}
+*/
+ReferenceCounter.prototype.getAllReferrers = ReferenceCounter.prototype.getAllReferers;
+
+/** @public
+* @return {Object} Object with newEntries and removedEntries
+*/
+ReferenceCounter.prototype.getSession = function() {
+	let newEntries = [];
+	let removedEntries = [];
+	for(let key in this._session) {
+		let val = this._session[key];
+		if(val > 0) {
+			newEntries.push(key);
+		} else if(val < 0) {
+			removedEntries.push(key);
+		}
+		// else {} // when val 0 do nothing, doesn't change anything
+	}
+	return {
+		newEntries: newEntries.filter(Boolean),
+		removedEntries: removedEntries.filter(Boolean)
+	};
+};
+
+/** @public
+* @param {string} key
+* @param {string=} referer Referer can only add specific key only once
+* @return {boolean} True if new reference is added
+*/
+ReferenceCounter.prototype.addReference = function(key, referer) {
+	if(key) {
+		if(referer) {
+			let counter = this._referers[referer];
+			if(counter) {
+				if(counter[key]) { // Single Referer can only add specific key only once
+					return false;
+				}
+			} else {
+				counter = this._referers[referer] = {};
+			}
+			counter[key] = 1;
+		}
+
+		if(this._counter[key]) {
+			++this._counter[key];
+			// The session will not change when a field already exists and a counter is attempted to be added
+		} else {
+			this._counter[key] = 1;
+			if(this._session[key] === -1) {
+				this._session[key] = 0;
+			} else {
+				this._session[key] = 1;
+			}
+
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @function
+* @param {string} key
+* @return {boolean} True if new reference is added
+*/
+ReferenceCounter.prototype.addRef = ReferenceCounter.prototype.addReference;
+
+/** @public
+* @param {string} key
+* @param {string=} referer Referer can only add specific key only once
+* @param {number=} count Use negative value to remove all counter from the given reference
+* @return {boolean} True if existing reference is removed
+*/
+ReferenceCounter.prototype.removeReference = function(key, referer, count) {
+	if(!key) {
+		return false;
+	}
+	let val = this._counter[key];
+	if(!val) {
+		return false;
+	}
+	if(count == null) {
+		count = 1;
+	} else if(count < 0) {
+		count = val;
+	} else if(!count) {
+		return false;
+	}
+
+	if(referer) {
+		let counter = this._referers[referer];
+		if(!counter) {
+			return false;
+		}
+		if(!counter[key]) {
+			return false;
+		}
+
+		delete counter[key];
+	}
+
+	val -= count;
+	if(!val || val < 0) {
+		delete this._counter[key];
+		if(this._session[key] === 1) {
+			this._session[key] = 0;
+		} else {
+			this._session[key] = -1;
+		}
+		return true;
+	}
+
+	this._counter[key] = val;
+	return false;
+};
+/** @public
+* @function
+* @param {string} key
+*/
+ReferenceCounter.prototype.release = ReferenceCounter.prototype.removeReference;
+
+/** @public
+* @param {(string|Array.<string>|Object)} keys
+* @param {string=} referer
+* @return {number} Number of newly added entries
+*/
+ReferenceCounter.prototype.addReferences = function(keys, referer) {
+	if(!keys) {
+		return 0;
+	}
+	let count = 0;
+	if(Array.isArray(keys)) {
+		let len = keys.length;
+		for(let i = 0; i < len; ++i) {
+			if(this.addReference(keys[i], referer)) {
+				++count;
+			}
+		}
+	} else if (typeof keys == "string") {
+		if(this.addReference(keys, referer)) {
+			++count;
+		}
+	} else {
+		for(let key in keys) {
+			if(this.addReference(key, referer)) {
+				++count;
+			}
+		}
+	}
+	return count;
+};
+
+/** Remove all references from specific referer
+* @public
+* @param {string=} referer
+* @return {number} Number of removed entries
+*/
+ReferenceCounter.prototype.removeReferer = function(referer) {
+	let count = 0;
+	if(referer) {
+		let counter = this._referers[referer];
+		if(counter) {
+			for(let key in counter) {
+				if(this.removeReference(key, referer)) {
+					++count;
+				}
+			}
+			delete this._referers[referer];
+		}
+	}
+	return count;
+};
+/** Alias to ReferenceCounter.removeReferer
+* @public
+* @function
+* @param {string=} referer
+* @return {number} Number of removed entries
+*/
+ReferenceCounter.prototype.removeReferrer = ReferenceCounter.prototype.removeReferer;
+
+/** Log current reference count to dev console
+* @public
+*/
+ReferenceCounter.prototype.log = function() {
+	console.log(this._counter);
+};
+
+
+export {ReferenceCounter};
+export default ReferenceCounter;

package/lib/rt-grid/es6/RowDefSorter.d.ts

@@ -0,0 +1,19 @@
+import { cloneObject } from "../../tr-grid-util/es6/Util.js";
+
+declare class RowDefSorter {
+
+    constructor();
+
+    public dispose(): void;
+
+    public getSorter(): ((...params: any[]) => any)|null;
+
+    public reset(key: string, value: any): void;
+
+    public setContext(key: string, value: any): void;
+
+    public addColumnContext(field: string, logic: ((...params: any[]) => any)|null, rowSorting: boolean, order: string, colIndex: number, colDef: any): void;
+
+}
+
+export default RowDefSorter;

package/lib/rt-grid/es6/RowDefSorter.js

@@ -0,0 +1,231 @@
+import { cloneObject } from "../../tr-grid-util/es6/Util.js";
+
+/** @private
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @return {number}
+*/
+let _defaultCompare = function(a, b, order) {
+	if(a == null || a !== a) {
+		if(b == null || b !== b) {
+			return 0;
+		}
+		return 1;
+	}
+	if(b == null || b !== b) {
+		return -1;
+	}
+
+	if(a < b) {
+		return -order;
+	}
+	if(b < a) {
+		return order;
+	}
+	return 0;
+};
+
+/** @constructor
+*/
+let RowDefSorter = function() {
+	this._defaultSorter = this._defaultSorter.bind(this);
+	this._dataSorter = this._dataSorter.bind(this);
+	this._rowDefSorter = this._rowDefSorter.bind(this);
+	this._multiColumnsSorter = this._multiColumnsSorter.bind(this);
+
+	this._globalContext = {};
+	this._sortParams = [];
+	this._ctxCaches = [];
+};
+
+/** @type {!Object}
+* @private
+*/
+RowDefSorter.prototype._globalContext;
+/** @type {!Array.<Array>}
+* @private
+*/
+RowDefSorter.prototype._sortParams;
+/** @type {!Array.<Object>}
+* @private
+*/
+RowDefSorter.prototype._ctxCaches;
+/** @type {Array}
+* @private
+*/
+RowDefSorter.prototype._primaryParams;
+
+
+/** @public
+*/
+RowDefSorter.prototype.dispose = function() {
+	this._globalContext = {}; // Clear any existing reference
+	this._sortParams.length = 0;
+	this._ctxCaches.length = 0;
+	this._primaryParams = null;
+};
+
+/** @public
+* @return {Function}
+*/
+RowDefSorter.prototype.getSorter = function() {
+	this._primaryParams = null;
+	let sortCount = this._sortParams.length;
+	if(sortCount === 1) {
+		let params = this._primaryParams = this._sortParams[0];
+		let sortLogic = params[1];
+		if(sortLogic) {
+			let rowSorting = params[3];
+			return rowSorting ? this._rowDefSorter : this._dataSorter;
+		} else {
+			return this._defaultSorter;
+		}
+	} else if(sortCount > 1) {
+		return this._multiColumnsSorter;
+	}
+
+	return RowDefSorter._noSorting;
+};
+
+/** @public
+* @param {string} key
+* @param {*} value
+*/
+RowDefSorter.prototype.reset = function() {
+	if(this._sortParams.length) {
+		this._sortParams.length = 0;
+	}
+};
+/** @public
+* @param {string} key
+* @param {*} value
+*/
+RowDefSorter.prototype.setContext = function(key, value) {
+	this._globalContext[key] = value;
+};
+/** @public
+* @param {string} field
+* @param {Function} logic
+* @param {boolean} rowSorting
+* @param {string} order
+* @param {number} colIndex
+* @param {*} colDef
+*/
+RowDefSorter.prototype.addColumnContext = function(field, logic, rowSorting, order, colIndex, colDef) {
+	if(!field) {
+		field = "";
+	}
+	let sortPriority = this._sortParams.length;
+	let ctx = this._ctxCaches[sortPriority];
+	if(!ctx) {
+		ctx = this._ctxCaches[sortPriority] = cloneObject(this._globalContext);
+	}
+	let orderNum = 0;
+	if(order === "a") {
+		orderNum = 1;
+	} else if(order === "d") {
+		orderNum = -1;
+	}
+
+	let params = [
+		field, // 0
+		(typeof logic === "function") ? logic : null,  // 1
+		ctx, // 2
+		rowSorting, // 3
+		orderNum  // 4
+	];
+
+	ctx["colIndex"] = colIndex;
+	ctx["field"] = field;
+	ctx["formattedField"] = field + "_FORMATTED";
+	ctx["colDef"] = colDef;
+
+	this._sortParams.push(params);
+};
+
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
+RowDefSorter._noSorting = function(rowDefA, rowDefB, order) {
+	return 0;
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
+RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
+	let field = this._primaryParams[0];
+	return _defaultCompare(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order
+	);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
+RowDefSorter.prototype._dataSorter = function(rowDefA, rowDefB, order) {
+	let params = this._primaryParams;
+	let field = params[0];
+	let sortLogic = params[1];
+	return sortLogic(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order,
+		params[2]
+	);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
+RowDefSorter.prototype._rowDefSorter = function(rowDefA, rowDefB, order) {
+	let params = this._primaryParams;
+	let sortLogic = params[1];
+	return sortLogic(rowDefA, rowDefB, order, params[2]);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} primaryOrder
+* @return {number}
+*/
+RowDefSorter.prototype._multiColumnsSorter = function(rowDefA, rowDefB, primaryOrder) {
+	let sortParams = this._sortParams;
+	let sortCount = sortParams.length;
+	for(let i = 0; i < sortCount; ++i) {
+		let params = sortParams[i];
+		let field = params[0];
+		let sortLogic = params[1];
+		let ctx = params[2];
+		let rowSorting = params[3];
+		let orderNum = params[4];
+		let ret = 0;
+		if(sortLogic) {
+			if(rowSorting) {
+				ret = sortLogic(rowDefA, rowDefB, orderNum, ctx);
+			} else {
+				ret = sortLogic(rowDefA.getData(field), rowDefB.getData(field), orderNum, ctx);
+			}
+		} else {
+			ret = _defaultCompare(rowDefA.getData(field), rowDefB.getData(field), orderNum);
+		}
+		if(ret) {
+			return ret;
+		}
+	}
+	return 0;
+};
+
+export default RowDefSorter;