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

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

@@ -0,0 +1,96 @@
+/** Delay class combines {@link Deferred} and Timeout method together.
+* @constructor
+* @param {number=} ms
+* @param {*=} ctx Context object that will passed to resolve func as the first parameter
+*/
+let Delay = function(ms, ctx){
+	this.promise = new Promise(this._executor.bind(this));
+	if(ctx != null) {
+		this._ctx = ctx;
+	}
+
+	setTimeout(this._onTimeout.bind(this), ms > 0 ? ms : 0);
+};
+/** A shorthand for Creating a Delay class object
+* @public
+* @function
+* @param {number=} ms
+* @param {*=} ctx
+* @return {Delay}
+*/
+Delay.for = function(ms, ctx) {
+	return new Delay(ms, ctx);
+};
+
+/** @type {Promise<*>}
+* @public
+*/
+Delay.prototype.promise = null;
+/** @type {Function}
+* @private
+*/
+Delay.prototype._resolve = null;
+/** @type {Function}
+* @private
+*/
+Delay.prototype._reject = null;
+
+/** @type {number}
+* @private
+*/
+Delay.prototype._timerId = 0;
+/** @type {*}
+* @public
+*/
+Delay.prototype._ctx = null; // Context object
+
+/** @public */
+Delay.prototype.resolve = function() {
+	if(this._timerId) {
+		this._onTimeout();
+	}
+};
+/** @public */
+Delay.prototype.reject = function() {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+		this._reject((this._ctx != null) ? this._ctx : this);
+		this._ctx = null;
+	}
+};
+/** @public
+* @return {boolean}
+*/
+Delay.prototype.isTimeout = function() {
+	return !this._timerId;
+};
+
+/** @private
+* @param {Function} resolve
+* @param {Function} reject
+*/
+Delay.prototype._executor = function(resolve, reject) {
+	this._resolve = resolve;
+	this._reject = reject;
+};
+/** @private */
+Delay.prototype._onTimeout = function() {
+	this._timerId = 0;
+	this._resolve((this._ctx != null) ? this._ctx : this);
+	this._ctx = null;
+};
+
+/** Create a promise of a Delay
+* @public
+* @function
+* @param {number=} ms
+* @param {*=} ctx
+* @return {Promise}
+*/
+let promiseDelay = function(ms, ctx) {
+	return Delay.for(ms, ctx).promise;
+};
+
+export default Delay;
+export {Delay, promiseDelay};

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

@@ -0,0 +1,32 @@
+
+
+declare namespace Dom {
+
+    function create(tagName: string, className?: string|null): Element;
+
+    function div(className?: string|null): Element;
+
+    function text(textContent?: (string|number)|null, className?: string|null): Element;
+
+    function appendChild(parentElem: Element|null, children: Node|any[]|null): Element|null;
+
+    function buildTree(parentElem: Element|null, children: Node|any[]|null): Element|null;
+
+    function setContent(elem: Element|null, val: any): void;
+
+    function preventDefault(e: Event|null): void;
+
+    function stopPropagation(e: Event|null): void;
+
+    function getClientPosition(target: Element|Event|MouseEvent, retObj?: any): any;
+
+    function getRelativePosition(A: Element|Event|MouseEvent, B: Element|Event|MouseEvent, retObj?: any): any;
+
+    function closestElement(elem: Element|Node|undefined|null, classStr: string): Element|null;
+
+    function closestTagName(elem: Element|Node|undefined|null, tn: string): Element|null;
+
+}
+
+export default Dom;
+export {Dom};

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

@@ -0,0 +1,350 @@
+/** @namespace */
+let Dom = {};
+
+/** Shorthand for creating an element with class
+* @public
+* @function
+* @param {string} tagName
+* @param {string=} className
+* @return {!Element}
+*/
+Dom.create = function(tagName, className) {
+	let elem = document.createElement(tagName);
+	if(className) {
+		elem.className = className;
+	}
+	return elem;
+};
+/** Shorthand for creating a div element with class
+* @public
+* @function
+* @param {string=} className
+* @return {!Element}
+*/
+Dom.div = function(className) {
+	return Dom.create("div", className);
+};
+/** Shorthand for creating a span element with textContent
+* @public
+* @function
+* @param {(string|number)=} textContent
+* @param {string=} className
+* @return {!Element}
+*/
+Dom.text = function(textContent, className) {
+	let elem = Dom.create("span", className);
+	if(textContent || textContent === 0) {
+		elem.textContent = textContent;
+	}
+	return elem;
+};
+
+/** Shorthand for appending multiple children
+* @public
+* @function
+* @param {Element} parentElem
+* @param {...Node|Array} children
+* @return {Element} Parent element
+*/
+Dom.appendChild = function(parentElem, children) {
+	if(!parentElem) {
+		return null;
+	}
+	let i, ary;
+	if(Array.isArray(arguments[1])) {
+		ary = arguments[1];
+		i = 0;
+	} else {
+		ary = arguments;
+		i = 1;
+	}
+	let len = ary.length;
+	while(i < len) {
+		parentElem.appendChild(ary[i]);
+		++i;
+	}
+	return parentElem;
+};
+/** Shorthand for appending multiple children in a tree like manner
+* @public
+* @function
+* @param {Element} parentElem
+* @param {...Node|Array} children The first child from the given array will be treated as a parent of all subsequence items.
+* @return {Element} Parent element
+* @example
+* Dom.buildTree(p1,
+*   ch1,
+*   ch2,
+*   [ch3_p1,
+*	 ch3_ch1,
+*	 ch3_ch2
+*   ]
+* );
+*/
+Dom.buildTree = function(parentElem, children) {
+	if(!parentElem) {
+		return null;
+	}
+	let args = arguments;
+	let len = args.length;
+	for(let i = 1; i < len; ++i) {
+		let child = args[i];
+		if(child) {
+			let childElem;
+			if(Array.isArray(child)) {
+				childElem = Dom.buildTree.apply(null, child);
+			} else if(child.nodeType === 1) {
+				childElem = /** @type{Element} */(child);
+			}
+			if(childElem) {
+				parentElem.appendChild(childElem);
+			}
+		}
+	}
+	return parentElem;
+};
+/** Put the given element out of the document
+* @function
+* @param {Node|Element} child
+* @return {Element} Parent Element
+*/
+Dom.removeParent = function (child) {
+	if(!child) { return null; }
+	let parent = child.parentNode;
+	if(parent) {
+		parent.removeChild(child);
+	}
+	return parent;
+};
+/** Safely set parent for the specified child element
+* @function
+* @param {Node|Element} child
+* @param {Node|Element} parent
+* @return {Element} Parent Element
+*/
+Dom.setParent = function (child, parent) {
+	if(!child) { return null; }
+	if(parent) {
+		parent.appendChild(child);
+		return parent;
+	} else {
+		return Dom.removeParent(child);
+	}
+};
+/** Remove all child nodes
+* @function
+* @param {Node|Element} elem
+* @param {number=} count
+*/
+Dom.removeChildren = function (elem, count) {
+	if(elem) {
+		let childCount = elem.childNodes.length;
+		if(count == null || count > childCount) {
+			count = childCount;
+		}
+		while(--count >= 0) {
+			elem.removeChild(elem.lastChild);
+		}
+	}
+};
+/** Ensure that element will contain only the given nodes (all other existing nodes are removed).
+* @public
+* @function
+* @param {Element} elem
+* @param {*} val Element, Node, string, number, or everything else.
+*/
+Dom.setContent = function(elem, val) {
+	if(elem) {
+		if(val || val === 0) {
+			let nt = val.nodeType;
+			if(nt === 1 || nt === 3) {
+				if(val !== elem.lastChild) {
+					Dom.removeChildren(elem);
+					elem.appendChild(/** @type{Node} */(val));
+				}
+			} else if(Array.isArray(val)) {
+				Dom.removeChildren(elem); // Could be slow, if duplicates are given
+				Dom.appendChild(elem, val);
+			} else {
+				elem.textContent = val; // Implicit text conversion
+			}
+		} else {
+			Dom.removeChildren(elem);
+		}
+	}
+};
+
+/** A quick way to toggle attribute on and off.
+* @function
+* @param {Element} elem
+* @param {string} attr Attribute name (e.g. disabled, readonly, style, class)
+* @param {*=} bool Truthy or falsy value. If specified, this method is equivalent to setter method.
+*/
+Dom.toggleAttribute = function (elem, attr, bool) {
+	if(bool) {
+		elem.setAttribute(attr, (typeof bool === "string") ? bool : "");
+	} else if(bool == null) {
+		if(elem.hasAttribute(attr)) {
+			elem.removeAttribute(attr);
+		} else {
+			elem.setAttribute(attr, "");
+		}
+	} else {
+		elem.removeAttribute(attr);
+	}
+};
+/** A quick way to toggle class on and off. Note that this is a replacement for classList.toggle() as IE10 doesn't support it.
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/classList}
+* @function
+* @param {Element} elem
+* @param {string} classStr Non space class name
+* @param {*=} bool Truthy or falsy value. If specified, this method is equivalent to setter method.
+*/
+Dom.toggleClass = function (elem, classStr, bool) {
+	if(bool) {
+		elem.classList.add(classStr);
+	} else if(bool == null) {
+		if(elem.classList.contains(classStr)) {
+			elem.classList.remove(classStr);
+		} else {
+			elem.classList.add(classStr);
+		}
+	} else {
+		elem.classList.remove(classStr);
+	}
+};
+/** A quick way to add multiple classes without altering existing classes in the element. This does not necessarily mean that this method has high performance.
+* @function
+* @param {Element} elem
+* @param {...string} classes CSS Class names without any space in the name. Array can be given as well
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/classList}
+*/
+Dom.addClasses = function (elem, classes) {
+	if(elem) {
+		let ary = Array.isArray(classes) ? classes : arguments;
+		let len = ary.length;
+		for(let i = 0; i < len; ++i) {
+			let str = ary[i];
+			if(str && typeof str == "string") {
+				elem.classList.add(str);
+			}
+		}
+	}
+};
+/** A quick way to remove multiple classes without altering unrelated classes in the element. This does not necessarily mean that this method has high performance.
+* @function
+* @param {Element} elem
+* @param {...string} classes CSS Class names without any space in the name. Array can be given as well
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/classList}
+*/
+Dom.removeClasses = function (elem, classes) {
+	if(elem) {
+		let ary = Array.isArray(classes) ? classes : arguments;
+		let len = ary.length;
+		for(let i = 0; i < len; ++i) {
+			let str = ary[i];
+			if(str && typeof str == "string") {
+				elem.classList.remove(str);
+			}
+		}
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+Dom.preventDefault = function(e) {
+	e.preventDefault();
+	e.stopPropagation();
+};
+/** @public
+* @function
+* @param {Event} e
+*/
+Dom.stopPropagation = function(e) {
+	e.stopPropagation();
+};
+
+
+/** Get client prosition from the given target. Supports only for modern browser (Gecko 1.9+, modern Webkit)
+* @public
+* @function
+* @param {!Element|Event|MouseEvent} target
+* @param {*=} retObj An object that stores returned values
+* @return {!Object} Return object with property x and y
+*/
+Dom.getClientPosition = function(target, retObj) {
+	let pos = retObj || {"x": 0, "y": 0};
+	if(target["getBoundingClientRect"]){
+		let box = target["getBoundingClientRect"]();
+		pos["x"] = box.left;
+		pos["y"] = box.top;
+	} else { //Event
+		pos["x"] = target.clientX;
+		pos["y"] = target.clientY;
+	}
+
+	return /**@type {!Object} */(pos);
+};
+/** Get position of A element that is relative to the B element. <br>
+* Top-left of B is used as registration a point (0, 0) for x and y. <br>
+* For example, if A is located to right of B, "x" will be positive, If A is located below B, "y" will be positive.
+* @public
+* @function
+* @param {!Element|Event|MouseEvent} A HTMLElement, Browser's event, or mouse event object
+* @param {!Element|Event|MouseEvent} B HTMLElement, Browser's event, or mouse event object
+* @param {*=} retObj An object that stores returned values
+* @return {!Object} an object with "x" and "y" values
+* @example
+* Dom.getRelativePosition(popupA, document.body); // Get position of popupA that is relative to the document body
+*/
+Dom.getRelativePosition = function(A, B, retObj) {
+	retObj = Dom.getClientPosition(A, retObj);
+	let bp = Dom.getClientPosition(B);
+
+	retObj["x"] -= bp["x"];
+	retObj["y"] -= bp["y"];
+	return /**@type {!Object} */(retObj);
+};
+/** The method returns closest ancestor element or the element itself with specified class string. Otherwise, it returns null
+* @public
+* @function
+* @param {Element|Node|undefined} elem
+* @param {string} classStr The class string can only be one single class without spaces
+* @return {Element}
+*/
+Dom.closestElement = function(elem, classStr) {
+	let n = elem;
+	while (n) {
+		if(n.classList) { // DocumentFragment does not have classList property
+			if (n.classList.contains(classStr)) {
+				return /** @type{Element} */(n);
+			}
+		}
+		n = n.parentNode || n.host; // ShadowRoot has host, but not parentNode
+	}
+	return null;
+};
+/** The method returns closest ancestor element or the element itself with the specified tagName. Otherwise, it returns null
+* @public
+* @function
+* @param {Element|Node|undefined} elem
+* @param {string} tn Tag name in uppercase format (e.g. "DIV")
+* @return {Element}
+*/
+Dom.closestTagName = function(elem, tn) {
+	let n = elem;
+	while(n) {
+		if(n.tagName) {
+			if(n.tagName == tn) {
+				return /** @type{Element} */(n);
+			}
+		}
+		n = n.parentNode || n.host; // ShadowRoot has host, but not parentNode
+	}
+	return null;
+};
+
+export default Dom;
+export {Dom};

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

@@ -0,0 +1,20 @@
+import { injectCss, prettifyCss } from "./Util.js";
+import Dom from "./Dom.js";
+import ElfUtil from "./ElfUtil.js";
+
+declare class DragUI {
+
+    constructor(options: any);
+
+    public static applyThemeColor(grid: any): void;
+
+    public onThemeLoaded(colors: any): void;
+
+    public static initStyles(colors?: any): void;
+
+    public setContent(content: any): void;
+
+}
+
+export default DragUI;
+export {DragUI};