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

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

@@ -0,0 +1,65 @@
+
+
+declare namespace Util {
+
+    function post(url: string, obj: any|string): Promise<Response>;
+
+    function requestText(url: string, obj: any|string): Promise<Response>;
+
+    function requestByUrlEncoded(url: string, obj: string): Promise<Response>;
+
+    function toJSON(resp: Response): Promise<any>;
+
+    function toText(resp: Response): Promise<string>;
+
+}
+
+declare function extendObject(obj: any, extender?: any, limiters?: (string)[]): any;
+
+declare function cloneObject(obj: any, limiters?: (string)[]): any;
+
+declare function arrayToObject(data?: any[], fields?: (string)[]): any|null;
+
+declare function extendProperty(obj: any, extender: any, propName: string): void;
+
+declare function extendArrayProperty(obj: any, propName: string, ary: any): any[];
+
+declare function parseCondition(expression: string|((...params: any[]) => any)): ((...params: any[]) => any);
+
+declare function prettifyCss(css: string|any[]): string;
+
+declare function getShadowRoot(elem: Element): DocumentFragment;
+
+declare function injectCss(cssStr: string, targetContext?: Element): Element;
+
+declare function isIE(): boolean;
+
+declare function isMac(): boolean;
+
+declare function isTouchDevice(): boolean;
+
+declare function nestedObjectToArray(obj: any, ary?: any[]): any[];
+
+declare function rgb2Hex(rgbCode: string): string;
+
+declare function prepareTSVContent(data: any): string;
+
+export default Util;
+export {
+	Util,
+	extendObject,
+	cloneObject,
+	arrayToObject,
+	extendProperty,
+	extendArrayProperty,
+	parseCondition,
+	prettifyCss,
+	getShadowRoot,
+	injectCss,
+	isIE,
+	isMac,
+	isTouchDevice,
+	nestedObjectToArray,
+	rgb2Hex,
+	prepareTSVContent
+};

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

@@ -0,0 +1,528 @@
+/** @namespace */
+var 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) {
+	var 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}
+*/
+var extendObject = function (obj, extender, limiters) {
+	if(!obj) { // null undefined NaN empty string and 0
+		return null;
+	}
+	if(!extender || obj === extender) {
+		return obj;
+	}
+
+	var key;
+	if(limiters) {
+		var len = limiters.length;
+		for(var 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}
+*/
+var cloneObject = function (obj, limiters) {
+	return extendObject({}, obj, limiters);
+};
+/** @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}
+*/
+var arrayToObject = function(data, fields) {
+	if(!Array.isArray(data)) {
+		return data;
+	} else if(!fields) {
+		return null;
+	}
+	var ary = data;
+	data = {};
+	var len = ary.length;
+	for(var i = 0; i < len; ++i) {
+		var 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]}
+*/
+var extendProperty = function (obj, extender, propName) {
+	var val = extender[propName];
+	if(val != null) {
+		var 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
+		}
+	}
+};
+/** 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
+* var 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
+*/
+var extendArrayProperty = function (obj, propName, ary) {
+	var objAry = null;
+	if(ary) {
+		var 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;
+};
+
+
+/** Regex for matching the field token E.g. '[CF_BID]'
+* @type {!RegExp}
+* @private
+* @const
+*/
+var _bracketExp = new RegExp(/\[[^\[]*\]/g); // eslint-disable-line no-useless-escape
+/** @public
+* @function
+* @param {string|Function} expression
+* @return {Function}
+* @example
+* var fn = parseCondition("[CF_BID] >= 10 && [CF_BID] <= 100");
+* window.console.log(fn(25));
+*/
+var parseCondition = function(expression) {
+	if(!expression) {
+		return null;
+	}
+	if(typeof expression !== "string") {
+		return (typeof expression == "function") ? /** @type {Function} */(expression) : null;
+	}
+
+	var brackets = expression.match(_bracketExp); // Retrieving field tokens (anything in between brackets)
+	var map = {}; // For checking duplication
+	var fields = [];
+	var len = brackets ? brackets.length : 0;
+	for(var i = len; --i >= 0;) {
+		var field = brackets[i];
+		if(!map[field]) {
+			map[field] = "f[" + fields.length + "]"; // Create mapping of field token to array with index E.g. { "[CF_BID]": "f[0]" }
+			fields.push(field.substring(1, field.length - 1)); // Strip '[' and ']' of field token to get field name
+		}
+	}
+
+	// Replace the field tokens with rowData of array with index E.g. [CF_BID] ==> rowData[f[0]]
+	expression = expression.replace(_bracketExp, function(match) {
+		return "rowData[" + map[match] + "]";
+	});
+	var finalExp = "(function(f, rowData) { return (" + expression + "); })";
+
+	var fn = null;
+	try {
+		fn = eval(finalExp);
+		fn = fn.bind(null, fields); // Bind fields for matching field name
+	} catch(err) {
+		console.log(err.message);
+	}
+	return (fn) ? fn : null;
+};
+
+
+/** @private
+* @param {string|Array.<string>} item
+* @return {string}
+*/
+var _encloseBracket = function(item) {
+	return Array.isArray(item) ? "{\n" + item.join("\n") + "\n}" : item;
+};
+/** @private
+* @param {string} str
+* @return {string}
+*/
+var _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;"
+* ]
+* ]);
+*/
+var prettifyCss = function(css) {
+	if(css) {
+		var cssStr = "";
+		if (Array.isArray(css)) {
+			var 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}
+*/
+var getShadowRoot = function(elem) {
+	if(elem) {
+		var 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
+*/
+var injectCss = function(cssStr, targetContext) {
+	if(!cssStr) {
+		return null;
+	}
+
+	var styleTag = document.createElement("style");
+	styleTag.textContent = "\n" + cssStr + "\n";
+
+	var styleHost = getShadowRoot(targetContext);
+	var isInShadow = true;
+	if(!styleHost) {
+		isInShadow = false;
+		styleHost = document.head;
+	}
+
+	// Find a place to insert the style tag
+	var 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}
+*/
+var isIE = function () {
+	var 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}
+*/
+var isMac = function () {
+	return /Mac/.test(navigator.platform);
+};
+
+/** Return true if device is mac
+* @public
+* @return {boolean}
+*/
+var 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}
+*/
+var nestedObjectToArray = function (obj, ary) {
+	if (!ary) {
+		ary = [];
+	}
+	for (var key in obj) {
+		var element = obj[key];
+		if ('object' === typeof element) {
+			nestedObjectToArray(element, ary);
+		} else {
+			ary.push(element);
+		}
+	}
+	return ary;
+};
+
+/** Convert CSS rgb or rgba formats to CSS hex color string (# prefix)
+* @public
+* @param {string} rgbCode
+* @return {string}
+* @example
+* rgb2Hex("rgb(255, 255, 0)"); // "#FFFF00"
+* rgb2Hex("rgba(255, 255, 0, 1)"); // "#FFFF00"
+* rgb2Hex("255 255.0"); // "#FFFF00"
+* rgb2Hex("#FFFF00"); // "#FFFF00"
+* rgb2Hex("#1a1a1a"); // "#1a1a1a"
+* rgb2Hex("2552550"); // "2552550"
+* rgb2Hex("invalid"); // "invalid"
+* rgb2Hex(null); // ""
+*/
+var rgb2Hex = function (rgbCode) {
+	if(!rgbCode || typeof rgbCode !== "string") {
+		return "";
+	}
+	if(rgbCode.charAt(0) === "#") {
+		return rgbCode;
+	}
+	var rgb = rgbCode.match(/\d+/g);
+	if(!rgb || rgb.length < 3) {
+		return rgbCode;
+	}
+
+	var hex = "#";
+	for(var i = 0; i < 3; i++) {
+		var num = +rgb[i];
+		if(!(num >= 16)) { // Handle NaN case
+			hex += "0";
+		}
+		hex += (num) ? num.toString(16).toUpperCase() : "0";
+	}
+	return hex;
+};
+
+/** transform data to tab seperated value
+* @public
+* @param {*} data
+* @return {string}
+*/
+var prepareTSVContent = function (data) {
+	if (data == null) {
+		return "";
+	}
+
+	var 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,
+	arrayToObject,
+	extendProperty,
+	extendArrayProperty,
+	parseCondition,
+	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, productId?: string, adcUrl?: string, lang?: string): void;
+
+}
+
+export {ADCService};

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

@@ -0,0 +1,72 @@
+import {ADCSubscription} from "./ADCSubscription.js";
+
+/** @namespace */
+var 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() {
+	var 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): void;
+
+    public setIntervalTime(time: number): void;
+
+    public addSymbolToField(symbol: string, field: string): any;
+
+}
+
+export {ADCSubscription};