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

package/lib/core/es6/grid/util/Conflator.d.ts

@@ -0,0 +1,32 @@
+
+
+declare class Conflator {
+
+    constructor(opt_func?: ((...params: any[]) => any)|number, opt_ms?: number|((...params: any[]) => any), opt_thisObj?: any);
+
+    public reset(): any[];
+
+    public popAllData(): any[];
+
+    public dispose(): void;
+
+    public conflate(opt_data?: any): boolean;
+
+    public isConflating(): boolean;
+
+    public getData(): any[];
+
+    public setFunction(func: ((...params: any[]) => any), opt_thisObj?: any): void;
+
+    public setConflatingTime(ms: number): void;
+
+    public disable(opt_disabled?: boolean): void;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean): void;
+
+}
+
+export default Conflator;
+export { Conflator };

package/lib/core/es6/grid/util/Conflator.js

@@ -0,0 +1,191 @@
+
+/** @description Conflator is used to stop multiple executions of a function in the specified period of time by merging multiple calls into one single call.
+* Conflator guarantees that only one single call will be executed.
+* @constructor
+* @param {Function|number=} opt_func Bound function that will use this conflator
+* @param {number|Function=} opt_ms The delay time in millisecond before executing the function
+* @param {*=} opt_thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+* @example
+* var c = new Conflator(function() { console.log("Executed"); }, 1000);
+* for(var i = 10; --i >= 0;) {
+*   c.conflate(i); // Only one "Executed" text will be logged to console after one second
+* }
+*/
+var Conflator = function (opt_func, opt_ms, opt_thisObj) {
+	this._onConflated = this._onConflated.bind(this);
+
+	this._data = [];
+
+	if(typeof opt_func == "function") {
+		this.setFunction(opt_func, opt_thisObj);
+	} else if (typeof opt_ms == "function") { // Parameter can be swapped places
+		this.setFunction(opt_ms, opt_thisObj);
+	}
+
+	if(typeof opt_ms == "number") {
+		this.setConflatingTime(opt_ms);
+	} else if (typeof opt_func == "number") { // Parameter can be swapped places
+		this.setConflatingTime(opt_func);
+	}
+};
+
+/** @type {!Array}
+* @private
+*/
+Conflator.prototype._data; // Array to store all conflated data
+/** @type {Function}
+* @private
+*/
+Conflator.prototype._func = null;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._delay = 0;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._timerId = 0;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._conflated = false;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._disabled = false;
+
+
+/** @description Any existing timer and stored data will be cleared.
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.reset = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+
+	return this.popAllData();
+};
+/** All stored data will be cleared
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.popAllData = function() {
+	if(this._data.length) {
+		var data = this._data;
+		this._data = [];
+		return data;
+	}
+	return null;
+};
+/** @public
+*/
+Conflator.prototype.dispose = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+	if(this._data.length) {
+		this._data.length = 0;
+	}
+	this._func = null; // Release user bound function
+};
+
+/** @public
+* @param {*=} opt_data
+* @return {boolean}
+*/
+Conflator.prototype.conflate = function (opt_data) {
+	if(this._disabled) {
+		return false;
+	}
+	if(opt_data != null) {
+		this._data.push(opt_data);
+	}
+	if(this._conflated) {
+		return false; // Conflating operation is already completed
+	}
+	if(!this._timerId) {
+		this._timerId = setTimeout(this._onConflated, this._delay);
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isConflating = function () {
+	return (this._timerId > 0 && !this._conflated && !this._disabled);
+};
+
+/** @private
+*/
+Conflator.prototype._onConflated = function () {
+	this._conflated = true;
+
+	try {
+		this._func();
+	} catch (err) {
+		console.error(err.message || err);
+	}
+
+	this._timerId = 0;
+	this._data.length = 0;
+	this._conflated = false;
+};
+
+/** @public
+* @return {!Array}
+*/
+Conflator.prototype.getData = function () {
+	return this._data;
+};
+/** @public
+* @param {Function} func Bound function that will use this conflator
+* @param {*=} opt_thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+*/
+Conflator.prototype.setFunction = function (func, opt_thisObj) {
+	this._func = func;
+	if(func) {
+		if(opt_thisObj) {
+			this._func = func.bind(opt_thisObj);
+		} else {
+			this._func = func;
+		}
+	} else {
+		this._func = null;
+	}
+};
+/** @public
+* @param {number} ms The delay time in millisecond before executing the function
+*/
+Conflator.prototype.setConflatingTime = function (ms) {
+	this._delay = ms || 0;
+	if(this._delay < 0) {
+		this._delay = 0;
+	}
+};
+
+/** @public
+* @param {boolean=} opt_disabled
+*/
+Conflator.prototype.disable = function (opt_disabled) {
+	this._disabled = opt_disabled !== false;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isEnabled = function () {
+	return !this._disabled;
+};
+/** @public
+* @param {boolean=} opt_enabled
+*/
+Conflator.prototype.enable = function (opt_enabled) {
+	this._disabled = opt_enabled === false;
+};
+
+Conflator._proto = Conflator.prototype;
+
+export default Conflator;
+export { Conflator };

package/lib/core/es6/grid/util/ElementFrameWork.d.ts

@@ -0,0 +1,18 @@
+import Util from "./util.js";
+
+declare namespace ElementFrameWork {
+
+    function setElfv3(): void;
+
+    function isElfv3(): boolean;
+
+    function createIcon(iconName: string): Element;
+
+    function createIconButton(iconName: string): Element;
+
+    function createRangeBar(): Element;
+
+}
+
+export { ElementFrameWork };
+export default ElementFrameWork;

package/lib/core/es6/grid/util/ElementFrameWork.js

@@ -0,0 +1,227 @@
+import Util from "./util.js";
+
+/*
+ * Support for ELFv3
+ * https://elf.int.refinitiv.com/index.html
+ */
+
+/**
+* @namespace
+*/
+var ElementFrameWork = {};
+
+/** @private
+ * @static
+ * @description True if the app uses ELFv3, false otherwise
+ * @type {boolean}
+ */
+ElementFrameWork._isElfv3 = false;
+
+/** @public
+ * @description Enable the ELFv3 mode
+ */
+ElementFrameWork.setElfv3 = function() {
+	ElementFrameWork._isElfv3 = true;
+};
+
+/** @public
+ * @description Indicate is the app uses ELFv3
+ * @returns {boolean} True if the app uses ELFv3, false otherwise
+ */
+ElementFrameWork.isElfv3 = function() {
+	return ElementFrameWork._isElfv3;
+};
+
+/** @public
+ * @description Create a icon span
+ * @param {string} iconName
+ * @returns {Element} The created element
+ */
+ElementFrameWork.createIcon = function(iconName) {
+	var element;
+
+	if (ElementFrameWork._isElfv3) {
+		element = document.createElement("ef-icon");
+		element.setAttribute("icon", iconName);
+	} else {
+		element = document.createElement("span");
+		element.classList.add("icon-" + iconName);
+	}
+
+	return element;
+};
+
+/** @public
+ * @description Create a icon button
+ * @param {string} iconName
+ * @returns {Element} The created element
+ */
+ElementFrameWork.createIconButton = function(iconName) {
+	var element;
+
+	if (ElementFrameWork._isElfv3) {
+		element = document.createElement("ef-button");
+		element.setAttribute("icon", iconName);
+	} else {
+		element = document.createElement("button");
+		element.classList.add("icon-" + iconName);
+	}
+
+	return element;
+};
+
+/** @public
+ * @description Create range bar
+ * @returns {Element} The created element
+ */
+ElementFrameWork.createRangeBar = function() {
+	var _slider;
+	var scalebar = document.createElement("div");
+
+	if (ElementFrameWork._isElfv3) {
+		scalebar.className = "tr-range-bar-wrapper";
+		_slider = document.createElement("sapphire-led-gauge");
+		_slider.setAttribute("neutral-color", "");
+		_slider.setAttribute("top-value", "0.00");
+	} else {
+		scalebar.className = "tr-range-bar-scale";
+		_slider = document.createElement("div");
+		_slider.className = "tr-range-bar-slider";
+	}
+
+	_slider.classList.add("tr-range-slider");
+	scalebar.appendChild(_slider);
+
+	/**
+	 * @private
+	 * @param {number} lowValue
+	 * @param {number} lastValue
+	 * @param {number} highValue
+	 * @returns {{sliderValue: number, rangeValue: (null|string)}}
+	 */
+	scalebar._calculateScaleParams = function (lowValue, lastValue, highValue) {
+		var sliderValue;
+		var rightSegmentValue;
+		var leftSegmentValue;
+		var rangeValue = null;
+
+		if (lowValue === highValue) {
+			if (lastValue === highValue) {
+				sliderValue = 0;
+			} else if (lastValue > highValue) {
+				sliderValue = 100;
+			} else {
+				sliderValue = -100;
+			}
+
+			return {
+				"sliderValue": sliderValue,
+				"rangeValue": "[-100,100]"
+			};
+		}
+
+		if (lowValue === lastValue) {
+			return {
+				"sliderValue": -100,
+				"rangeValue": rangeValue
+			};
+		}
+
+		if (lastValue === highValue) {
+			return {
+				"sliderValue": 100,
+				"rangeValue": rangeValue
+			};
+		}
+
+		if (lowValue > highValue) {
+			if (lastValue > lowValue) {
+				rightSegmentValue = Util.calculatePercent(highValue, lastValue - lowValue, lowValue) * 2 - 100;
+
+				sliderValue = -100;
+				rangeValue = "[-100," + rightSegmentValue + "]";
+			} else if(lastValue < highValue) {
+				leftSegmentValue = Util.calculatePercent(highValue, lowValue - lastValue, lowValue) * 2 - 100;
+
+				sliderValue = 100;
+				rangeValue = "[" + leftSegmentValue + ",100]";
+			} else {
+				sliderValue = Util.calculatePercent(highValue, lastValue, lowValue) * 2 - 100;
+			}
+
+			return {
+				"sliderValue": sliderValue,
+				"rangeValue": rangeValue
+			};
+		}
+
+		if (lastValue > highValue) {
+			leftSegmentValue = Util.calculatePercent(lowValue, 2 * highValue - lastValue, highValue) * 2 - 100;
+
+			return {
+				"sliderValue": 100,
+				"rangeValue": "[" + leftSegmentValue + ",100]"
+			};
+		}
+
+		if (lastValue < lowValue) {
+			rightSegmentValue = Util.calculatePercent(lowValue, 2 * lowValue - lastValue, highValue) * 2 - 100;
+
+			return {
+				"sliderValue": -100,
+				"rangeValue": "[-100," + rightSegmentValue + "]"
+			};
+		}
+
+		return {
+			"sliderValue": Util.calculatePercent(lowValue, lastValue, highValue) * 2 - 100,
+			"rangeValue": rangeValue
+		};
+	};
+
+	scalebar._getSliderInstance = function () {
+		return _slider;
+	};
+
+	/**
+	 * @param {number} percent
+	 * @param {number} lowValue
+	 * @param {number} lastValue
+	 * @param {number} highValue
+	 */
+	scalebar.updateScale = function (percent, lowValue, lastValue, highValue) {
+		var sliderParams;
+		var sliderInstance = scalebar._getSliderInstance();
+
+		if (!ElementFrameWork._isElfv3) {
+			sliderInstance.style.left = percent + "%";
+
+			return;
+		}
+
+		sliderParams = scalebar._calculateScaleParams(lowValue, lastValue, highValue);
+		sliderInstance.setAttribute("top-value", sliderParams["sliderValue"].toString());
+
+		if (!sliderParams["rangeValue"]) {
+			sliderInstance.removeAttribute("range");
+
+			return;
+		}
+
+		sliderInstance.setAttribute("range", sliderParams["rangeValue"]);
+	};
+
+	scalebar.setSliderWidth = function (val) {
+		var sliderWidth = (val > 0) ? val : 1;
+
+		if (!ElementFrameWork._isElfv3) {
+			scalebar.style.width = "calc(100% - " + sliderWidth + "px)";
+			scalebar._getSliderInstance().style.width = sliderWidth + "px";
+		}
+	};
+
+	return scalebar;
+};
+
+export { ElementFrameWork };
+export default ElementFrameWork;

package/lib/core/es6/grid/util/HttpRequest.d.ts

@@ -0,0 +1,53 @@
+import EventDispatcher from "../event/EventDispatcher.js";
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+
+declare class HttpRequest extends EventDispatcher {
+
+    constructor(url: string, payload?: any|string, opt_serviceName?: string);
+
+    public static readonly defaultTimeout: number;
+
+    public getUrl(): string;
+
+    public getType(): string;
+
+    public getPayload(): any;
+
+    public getPayloadText(): string;
+
+    public getState(): string;
+
+    public getResponse(): any|string;
+
+    public getResponseText(): string;
+
+    public getResponseStatus(): number;
+
+    public setResponseType(dataType: string): void;
+
+    public setRequestTimeout(timeout: number): void;
+
+    public valueOf(): any|string;
+
+    public toString(): string;
+
+    public log(): void;
+
+    public send(opt_requestedHeaders?: { [key: string]:  string }): HttpRequest;
+
+    public abort(): void;
+
+    public then(onFulfilled: ((...params: any[]) => any), onRejected?: ((...params: any[]) => any)): HttpRequest;
+
+    public catch(onRejected: ((...params: any[]) => any)|null): HttpRequest;
+
+    public reject(reason?: any): HttpRequest;
+
+    public loadFile(): HttpRequest;
+
+    public loadText(): HttpRequest;
+
+}
+
+export default HttpRequest;
+export { HttpRequest };