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

package/lib/tr-grid-util/es6/Util.d.ts

@@ -0,0 +1,66 @@
+import { rgb2Hex } from "./Color.js";
+
+declare namespace Util {
+
+    function post(url: string, obj: any|string|null): Promise<Response>;
+
+    function requestText(url: string, obj: any|string|null): Promise<Response>;
+
+    function requestByUrlEncoded(url: string, obj: string): Promise<Response>;
+
+    function toJSON(resp: Response|null): Promise<any>;
+
+    function toText(resp: Response|null): Promise<string>;
+
+}
+
+declare function extendObject(obj: any, extender?: any, limiters?: (string)[]|null): any;
+
+declare function cloneObject(obj: any, limiters?: (string)[]|null): any;
+
+declare function isEmptyObject(obj: any): boolean;
+
+declare function arrayToObject(data?: any[]|null, fields?: (string)[]|null): any|null|null;
+
+declare function extendProperty(obj: any, extender: any, propName: string): void;
+
+declare function deepEqual(obj1: any, obj2: any): boolean;
+
+declare function extendArrayProperty(obj: any, propName: string, ary: any): any[]|null;
+
+declare function prettifyCss(css: string|any[]|null): string;
+
+declare function getShadowRoot(elem: Element|null): DocumentFragment|null;
+
+declare function injectCss(cssStr: string, targetContext?: Element|null): Element|null;
+
+declare function isIE(): boolean;
+
+declare function isMac(): boolean;
+
+declare function isTouchDevice(): boolean;
+
+declare function nestedObjectToArray(obj: any, ary?: any[]|null): any[]|null;
+
+declare function prepareTSVContent(data: any): string;
+
+export default Util;
+export {
+	Util,
+	extendObject,
+	cloneObject,
+	isEmptyObject,
+	deepEqual,
+	arrayToObject,
+	extendProperty,
+	extendArrayProperty,
+	prettifyCss,
+	getShadowRoot,
+	injectCss,
+	isIE,
+	isMac,
+	isTouchDevice,
+	nestedObjectToArray,
+	rgb2Hex,
+	prepareTSVContent
+};

package/lib/tr-grid-util/es6/Util.js

@@ -0,0 +1,508 @@
+import { rgb2Hex } from "./Color.js";
+
+/** @namespace */
+let Util = {};
+
+/** This is a shorthand for fetch() API by POST method and with json body <br>
+* WARNING: fetch is not supported in IE (including IE11)
+* @public
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch}
+* @function
+* @param {string} url
+* @param {Object|string} obj
+* @return {!Promise<Response>}
+*/
+Util.post = function(url, obj) { // Not supported in IE
+	return Util._post(url, obj).then(Util.toJSON);
+};
+/** Request a server response from server as text by POST method <br>
+* WARNING: fetch is not supported in IE (including IE11)
+* @public
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch}
+* @function
+* @param {string} url
+* @param {Object|string} obj
+* @return {!Promise<Response>}
+*/
+Util.requestText = function(url, obj) { // Not supported in IE
+	return Util._post(url, obj, "text/plain").then(Util.toText);
+};
+/** Request a server response from server by POST method and with url-encoded body <br>
+* WARNING: fetch is not supported in IE (including IE11)
+* @public
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch}
+* @function
+* @param {string} url
+* @param {string} obj
+* @return {!Promise<Response>}
+*/
+Util.requestByUrlEncoded = function(url, obj) { // Not supported in IE
+	return Util._post(url, obj, "application/x-www-form-urlencoded").then(Util.toJSON);
+};
+
+/** @public
+* @function
+* @param {Response} resp
+* @return {!Promise<Object>}
+*/
+Util.toJSON = function (resp) {
+	if(Util._logError(resp)) {
+		return Promise.reject(resp);
+	}
+	return resp.json();
+};
+/** @public
+* @function
+* @param {Response} resp
+* @return {!Promise<string>}
+*/
+Util.toText = function (resp) {
+	if(Util._logError(resp)) {
+		return Promise.reject(resp);
+	}
+	return resp.text();
+};
+
+/** @private
+* @see {@link https://en.wikipedia.org/wiki/List_of_HTTP_status_codes}
+* @function
+* @param {Response} resp
+* @return {boolean}
+*/
+Util._logError = function(resp) {
+	if(resp && resp.status >= 300) {
+		console.log("Response " + resp.status + ": " + resp.statusText);
+		return true;
+	}
+	return false;
+};
+/** @private
+* @function
+* @param {string} url
+* @param {Object|string} obj
+* @param {string=} contentType
+* @return {!Promise<Response>}
+*/
+Util._post = function(url, obj, contentType) {
+	let options = {
+		method: obj ? "POST" : "GET",
+		headers: { "Content-Type": contentType || "application/json" }
+	};
+	if(obj) {
+		options.body = typeof obj === "string" ? obj : JSON.stringify(obj);
+	}
+
+	return fetch(url, options);
+};
+
+/** WARNING: Only one level of property tree is affected (i.e. no recursive or nested operation). <br>
+* Property with undefined or null value will not have an impact on the object. <br>
+* Existing properties will be overridden.
+* @public
+* @function
+* @param {Object} obj Object that is extended (new properties will be added to this object)
+* @param {Object=} extender Master object (no modification will be made on the extender)
+* @param {Array.<string>=} limiters Specify property to be extended
+* @return {Object}
+*/
+let extendObject = function (obj, extender, limiters) {
+	if(!obj) { // null undefined NaN empty string and 0
+		return null;
+	}
+	if(!extender || obj === extender) {
+		return obj;
+	}
+
+	let key;
+	if(limiters) {
+		let len = limiters.length;
+		for(let i = 0; i < len; ++i) {
+			key = limiters[i];
+			if(key) {
+				extendProperty(obj, extender, key);
+			}
+		}
+	} else {
+		for(key in extender) {
+			extendProperty(obj, extender, key);
+		}
+	}
+	return obj;
+};
+/** WARNING: Only one level of property tree is affected (i.e. no recursive or nested operation). <br>
+* Property with undefined or null value will not be cloned.
+* @public
+* @function
+* @param {Object} obj
+* @param {Array.<string>=} limiters
+* @return {Object}
+*/
+let cloneObject = function (obj, limiters) {
+	return extendObject({}, obj, limiters);
+};
+
+/** Check empty object
+* @public
+* @function
+* @param {Object} obj
+* @return {boolean}=true, if the obj is empty
+*/
+let isEmptyObject = function (obj) {
+	for (let key in obj) {
+		return false;
+	}
+	return true;
+};
+
+/** @public
+* @param {Array=} data
+* @param {Array.<string>=} fields In case of the given data is an array, this param will be used for mapping index to field
+* @return {Object|null}
+*/
+let arrayToObject = function(data, fields) {
+	if(!Array.isArray(data)) {
+		return data;
+	} else if(!fields) {
+		return null;
+	}
+	let ary = data;
+	data = {};
+	let len = ary.length;
+	for(let i = 0; i < len; ++i) {
+		let field = fields[i];
+		// eslint-disable-next-line no-undefined
+		if(field && ary[i] !== undefined) {
+			data[field] = ary[i];
+		}
+	}
+	return data;
+};
+/** Replace the specified property with the value from the extender. If the value is an array, the value will be added to the array instead of replacement
+* @public
+* @function
+* @param {Object} obj
+* @param {Object} extender
+* @param {string} propName
+* @example
+* extendProperty({a: 0}, {a: 1}, "a"); // {a: 1}
+* extendProperty({a: 0}, {b: 1}, "b"); // {a: 0, b: 1}
+* extendProperty({a: [0]}, {a: 1}, "a"); // {a: [0, 1]}
+* extendProperty({a: [0]}, {a: [1, 2]}, "a"); // {a: [0, 1, 2]}
+*/
+let extendProperty = function (obj, extender, propName) {
+	let val = extender[propName];
+	if(val != null) {
+		let objVal = obj[propName];
+		if(Array.isArray(objVal)) {
+			obj[propName] = objVal.concat(val);
+		} else if(Array.isArray(val) && objVal) {
+			obj[propName] = val.concat(objVal); // TODO: Preserve the order
+		} else {
+			obj[propName] = val; // WARNING: Overriding existing data
+		}
+	}
+};
+
+
+/** Compare the values of obj1 and obj2. if they are the same object or have the same value, the result will be true. Otherwise, it will return false.
+* @public
+* @param {*} obj1
+* @param {*} obj2
+* @return {boolean}
+*/
+let deepEqual = function (obj1, obj2) {
+
+	if(obj1 === obj2) {
+		return true;
+	}
+
+	if (typeof obj1 !== typeof obj2) {
+		return false;
+	}
+
+	if (typeof obj1 === "object") {
+
+		// We need to split array and object for performance reason
+		if(Array.isArray(obj1)) {
+			if(obj1.length !== obj2.length) {
+				return false;
+			}
+
+			for (let i = 0; i < obj1.length; i++) {
+				if (!deepEqual(obj1[i], obj2[i])) { // The array may not be a match if the elements are not sorted, so it will not be considered equal if there is a mismatch.
+					return false;
+				}
+			}
+
+		} else {
+
+			if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+				return false;
+			}
+
+			for (let key in obj1) {
+				if (!deepEqual(obj1[key], obj2[key])) {
+					return false;
+				}
+			}
+		}
+
+
+		return true;
+	}
+
+	return false;
+
+};
+/** Array.push() is much faster than Array.concat(). The downside is the parameters must be an array, whereas concat() has no such requirement. <br>
+* This method excels in extending known array property in an object.
+* @public
+* @function
+* @param {Object} obj
+* @param {string} propName
+* @param {*} ary
+* @return {Array} Returns the result of the extended array
+* @see {@link https://dev.to/uilicious/javascript-array-push-is-945x-faster-than-array-concat-1oki}
+* @example
+* let obj = {};
+* extendArrayProperty(obj, "prop1", 1); // [1]
+* extendArrayProperty(obj, "prop1", 2); // [1, 2]
+* extendArrayProperty(obj, "prop1", [3, 4]); // [1, 2, 3, 4]
+* obj.prop2 = 5;
+* extendArrayProperty(obj, "prop2", 6); // [5, 6]
+* extendArrayProperty(obj, "prop2", [7]); // [5, 6, 7]
+* extendArrayProperty(obj, "prop2", null); // null
+*/
+let extendArrayProperty = function (obj, propName, ary) {
+	let objAry = null;
+	if(ary) {
+		let objVal = obj[propName];
+		if(objVal) {
+			if(Array.isArray(objVal)) {
+				objAry = objVal;
+			} else {
+				objAry = obj[propName] = [objVal];
+			}
+		} else {
+			objAry = obj[propName] = [];
+		}
+		// objAry is guaranteed to be an array at this point
+
+		if(Array.isArray(ary)) {
+			if(ary.length) {
+				if(ary.length > 1) {
+					Array.prototype.push.apply(objAry, ary);
+				} else {
+					objAry.push(ary[0]);
+				}
+			}
+		} else {
+			objAry.push(ary);
+		}
+	}
+	return objAry;
+};
+
+/** @private
+* @param {string|Array.<string>} item
+* @return {string}
+*/
+let _encloseBracket = function(item) {
+	return Array.isArray(item) ? "{\n" + item.join("\n") + "\n}" : item;
+};
+/** @private
+* @param {string} str
+* @return {string}
+*/
+let _indentBracketContent = function(str){
+	return str.replace(/\n+/g, "\n\t").replace(/\n\t}$/, "\n}");
+};
+/** @public
+* @param {string|Array} css
+* @return {string} prettified CSS string
+* @example
+* prettifyCss(["div", [
+*   "color: red;",
+*   "padding: 20px;"
+* ],
+* ".class", [
+*   "margin: 0;"
+* ]
+* ]);
+*/
+let prettifyCss = function(css) {
+	if(css) {
+		let cssStr = "";
+		if (Array.isArray(css)) {
+			let ary = css.map(_encloseBracket);
+			cssStr = ary.join("\n").replace(/{\s*{/g, "{").replace(/\s+{/g, " {");
+		} else {
+			cssStr = (typeof css === "string") ? css : css + "";
+		}
+
+		if(cssStr) {
+			return cssStr.replace(/{[\w\W]*?}/g, _indentBracketContent);
+		}
+	}
+	return "";
+};
+/** Get shadow root of the given element regardless of whether the element is in the DOM or not. The immediate shadow root parent is returned in case of nested shadow roots. Any other case return null.
+* @public
+* @param {Element} elem
+* @return {DocumentFragment}
+*/
+let getShadowRoot = function(elem) {
+	if(elem) {
+		let rootNode;
+		if(elem.shadowRoot) {
+			rootNode = elem.shadowRoot;
+		} else if(elem.getRootNode) {
+			rootNode = elem.getRootNode();
+		}
+		if(rootNode) { // getRootNode does not supported in IE. It should be implemented by the polyfills
+			if(rootNode !== document) { // element that is in the DOM and not in the shadow has document as its root node
+				if(rootNode !== elem) { // element that is NOT in the DOM and not in the shadow has itself as its root node
+					return rootNode;
+				}
+			}
+		}
+	}
+	return null;
+};
+/** Attach style tag to the proper document (in case of element inside a shadow root)
+* @public
+* @param {string} cssStr Valid CSS string (e.g. "div {color: red;}")
+* @param {Element=} targetContext Element that needs the CSS
+* @return {Element} New style tag
+*/
+let injectCss = function(cssStr, targetContext) {
+	if(!cssStr) {
+		return null;
+	}
+
+	let styleTag = document.createElement("style");
+	styleTag.textContent = "\n" + cssStr + "\n";
+
+	let styleHost = getShadowRoot(targetContext);
+	let isInShadow = true;
+	if(!styleHost) {
+		isInShadow = false;
+		styleHost = document.head;
+	}
+
+	// Find a place to insert the style tag
+	let beforeElem;
+	if(isInShadow) {
+		if(styleHost.children && styleHost.children.length) {
+			beforeElem = styleHost.children[0];
+		}
+	}
+	if(beforeElem) {
+		styleHost.insertBefore(styleTag, beforeElem);
+	} else {
+		styleHost.appendChild(styleTag);
+	}
+	return styleTag;
+};
+
+/** return true if browser is IE or Edge
+* @public
+* @return {boolean}
+*/
+let isIE = function () {
+	let ua = window.navigator.userAgent;
+	return (ua.indexOf('MSIE ') > 0) || (ua.indexOf('Trident/') > 0) || (ua.indexOf('Edge/') > 0);
+};
+
+/** return true if device is mac
+* @public
+* @return {boolean}
+*/
+let isMac = function () {
+	return /Mac/.test(navigator.platform);
+};
+
+/** Return true if device is mac
+* @public
+* @return {boolean}
+*/
+let isTouchDevice = function () {
+	if ((navigator["maxTouchPoints"] && navigator["maxTouchPoints"] < 256) ||
+		(navigator["msMaxTouchPoints"] && navigator["msMaxTouchPoints"] < 256)) {
+		return true;
+	}
+	return false;
+};
+
+/** parse nested object in to array
+* @public
+* @param {Object} obj
+* @param {Array=} ary
+* @return {Array}
+*/
+let nestedObjectToArray = function (obj, ary) {
+	if (!ary) {
+		ary = [];
+	}
+	for (let key in obj) {
+		let element = obj[key];
+		if ('object' === typeof element) {
+			nestedObjectToArray(element, ary);
+		} else {
+			ary.push(element);
+		}
+	}
+	return ary;
+};
+
+/** transform data to tab seperated value
+* @public
+* @param {*} data
+* @return {string}
+*/
+let prepareTSVContent = function (data) {
+	if (data == null) {
+		return "";
+	}
+
+	let content = (typeof data === 'string') ? data : data.toString();
+
+	if (!content.length) { return ""; }
+
+	// Replace any new line and tab
+	if (content.indexOf("\n") >= 0) {
+		content = content.replace(/[\r\n]/g, " ");
+	}
+
+	if (content.indexOf("\t") >= 0) {
+		content = content.replace(/\t/g, " ");
+	}
+
+	// Trim front and back spaces
+	if (content.charAt(0) === " " || content.charAt(content.length - 1) === " ") {
+		content = content.trim();
+	}
+
+	return content;
+};
+
+export default Util;
+export {
+	Util,
+	extendObject,
+	cloneObject,
+	isEmptyObject,
+	deepEqual,
+	arrayToObject,
+	extendProperty,
+	extendArrayProperty,
+	prettifyCss,
+	getShadowRoot,
+	injectCss,
+	isIE,
+	isMac,
+	isTouchDevice,
+	nestedObjectToArray,
+	rgb2Hex,
+	prepareTSVContent
+};

package/lib/tr-grid-util/es6/formula/ADCService.d.ts

@@ -0,0 +1,11 @@
+import {ADCSubscription} from "./ADCSubscription.js";
+
+declare namespace ADCService {
+
+    function create(): any;
+
+    function setDataCloudSettings(uuid?: string|null, productId?: string|null, adcUrl?: string|null, lang?: string|null): void;
+
+}
+
+export {ADCService};

package/lib/tr-grid-util/es6/formula/ADCService.js

@@ -0,0 +1,72 @@
+import {ADCSubscription} from "./ADCSubscription.js";
+
+/** @namespace */
+let ADCService = {};
+
+/** @type {Object}
+* @private
+*/
+ADCService._adcSubscription = null;
+/** @type {string}
+* @private
+*/
+ADCService._uuid = "GUEST";
+/** @type {string}
+* @private
+*/
+ADCService._adcProductId = "ANONYMOUS";
+/** @type {string}
+* @private
+*/
+ADCService._adcUrl = "/datacloud/rest/select";
+
+/** @public
+* @return {Object}
+*/
+ADCService.create = function() {
+	let adcSub = ADCService._adcSubscription;
+	if (!adcSub) {
+		if (window["JET"]) { // ADC only need JET
+			adcSub = ADCService._adcSubscription = new ADCSubscription();
+			ADCService._updateDataCloudSettings();
+		}
+	}
+	return adcSub || null;
+};
+
+/** @public
+* @param {string=} uuid
+* @param {string=} productId
+* @param {string=} adcUrl
+* @param {string=} lang
+*/
+ADCService.setDataCloudSettings = function(uuid, productId, adcUrl, lang) {
+	if(uuid) {
+		ADCService._uuid = uuid;
+	}
+	if(productId) {
+		ADCService._adcProductId = productId;
+	}
+	if(adcUrl) {
+		ADCService._adcUrl = adcUrl;
+	}
+	if(lang) {
+		ADCService._lang = lang;
+	}
+	// In case set the settings after the service was created.
+	ADCService._updateDataCloudSettings();
+};
+/** @private */
+ADCService._updateDataCloudSettings = function() {
+	if(ADCService._adcSubscription) {
+		ADCService._adcSubscription.setDataCloudSettings(
+			ADCService._uuid,
+			ADCService._adcProductId,
+			ADCService._adcUrl,
+			ADCService._lang
+		);
+	}
+};
+
+
+export {ADCService};

package/lib/tr-grid-util/es6/formula/ADCSubscription.d.ts

@@ -0,0 +1,17 @@
+import {Ext} from "../Ext.js";
+import {Util} from "../Util.js";
+import {EventDispatcher} from "../EventDispatcher.js";
+
+declare class ADCSubscription extends EventDispatcher {
+
+    constructor();
+
+    public setDataCloudSettings(userId: string, productId: string, url: string, opt_lang?: string|null): void;
+
+    public setIntervalTime(time: number): void;
+
+    public addSymbolToField(symbol: string, field: string): any;
+
+}
+
+export {ADCSubscription};