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

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

@@ -0,0 +1,85 @@
+/** 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
+*/
+var 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.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;
+};
+
+export default Delay;
+export {Delay};

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

@@ -0,0 +1,32 @@
+
+
+declare namespace Dom {
+
+    function create(tagName: string, className?: string): Element;
+
+    function div(className?: string): Element;
+
+    function text(textContent?: string, className?: string): Element;
+
+    function appendChild(parentElem: Element, children: Node|any[]): Element;
+
+    function buildTree(parentElem: Element, children: Node|any[]): Element;
+
+    function setContent(elem: Element, val: any): void;
+
+    function preventDefault(e: Event): void;
+
+    function stopPropagation(e: Event): 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, classStr: string): Element;
+
+    function closestTagName(elem: Element|Node|undefined, tn: string): Element;
+
+}
+
+export default Dom;
+export {Dom};

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

@@ -0,0 +1,346 @@
+/** @namespace */
+var Dom = {};
+
+/** Shorthand for creating an element with class
+* @public
+* @function
+* @param {string} tagName
+* @param {string=} className
+* @return {!Element}
+*/
+Dom.create = function(tagName, className) {
+	var 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=} textContent
+* @param {string=} className
+* @return {!Element}
+*/
+Dom.text = function(textContent, className) {
+	var 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;
+	}
+	var i, ary;
+	if(Array.isArray(arguments[1])) {
+		ary = arguments[1];
+		i = 0;
+	} else {
+		ary = arguments;
+		i = 1;
+	}
+	var 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;
+	}
+	var args = arguments;
+	var len = args.length;
+	for(var i = 1; i < len; ++i) {
+		var child = args[i];
+		if(child) {
+			var 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; }
+	var 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) {
+		var 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) {
+			var 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) {
+		var ary = Array.isArray(classes) ? classes : arguments;
+		var len = ary.length;
+		for(var i = 0; i < len; ++i) {
+			var 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) {
+		var ary = Array.isArray(classes) ? classes : arguments;
+		var len = ary.length;
+		for(var i = 0; i < len; ++i) {
+			var 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) {
+	var pos = retObj || {"x": 0, "y": 0};
+	if(target["getBoundingClientRect"]){
+		var 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);
+	var bp = Dom.getClientPosition(B);
+
+	retObj["x"] -= bp["x"];
+	retObj["y"] -= bp["y"];
+	return /**@type {!Object} */(retObj);
+};
+/** Return closest ancestor element or the element itself with specified class string. Otherwise return 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) {
+	var n = elem;
+	while(n && n.classList) {
+		if(n.classList.contains(classStr)) {
+			return /** @type{Element} */(n);
+		}
+		n = n.parentNode;
+	}
+	return null;
+};
+/** Return closest ancestor element or the element itself with the specified tagName. Otherwise return 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) {
+	var n = elem;
+	while(n && n.tagName) {
+		if(n.tagName == tn) {
+			return /** @type{Element} */(n);
+		}
+		n = n.parentNode;
+	}
+	return null;
+};
+
+export default Dom;
+export {Dom};

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

@@ -0,0 +1,10 @@
+
+
+declare namespace ElementObserver {
+
+    function addLanguageListener(element: Element): void;
+
+}
+
+export default ElementObserver;
+export { ElementObserver };

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

@@ -0,0 +1,101 @@
+
+/** @namespace
+*/
+var ElementObserver = {};
+
+/** @private
+* @param {Element} elem
+* @param {MutationRecord} mutation
+*/
+var _onLanguageMutated = function (elem, mutation) {
+	if (mutation.type == "attributes" && mutation.attributeName == "lang") {
+		elem.lang = mutation.target.lang || "en";
+	}
+};
+
+/** @private
+* @return {string}
+*/
+ElementObserver._getNewId = function () {
+	var id = "observer_" + (++ElementObserver._id);
+	return id;
+};
+
+/** @private Observe any element
+* @param {Element} elem
+* @param {Function} listener
+* @param {Object=} opt_option
+*/
+ElementObserver._addObserver = function(elem, listener, opt_option) {
+	var option = opt_option;
+	if (!option) {
+		option = {};
+	}
+	option.attributes = true; //configure it to listen to attribute changes
+
+	ElementObserver._observer.observe(elem, option);
+	ElementObserver._addListener(elem, listener);
+};
+
+/** @private
+* @param {Array.<MutationRecord>} mutations
+*/
+ElementObserver._onMutationCallback = function(mutations) {
+	for (var i = 0; i < mutations.length; i++) {
+		var mutation = mutations[i];
+		var listeners = ElementObserver._listeners[mutation.target._observeId];
+		for (var j = 0; j < listeners.length; j++) {
+			listeners[j](mutation);
+		}
+	}
+};
+
+/** @private
+* @param {Element} elem
+* @param {Function} fn
+*/
+ElementObserver._addListener = function(elem, fn) {
+	var listeners = ElementObserver._listeners;
+	if (!listeners) {
+		listeners = ElementObserver._listeners = {};
+	}
+	if (!elem._observeId) {
+		var id = ElementObserver._getNewId();
+		listeners[id] = [];
+		elem._observeId = id;
+	}
+	var listener = listeners[elem._observeId];
+	if (listener.indexOf(fn) < 0) {
+		listener.push(fn);
+	}
+};
+
+/** @public Add a listener to a html lang attribute
+* @param {Element} element A target element to listen to
+*/
+ElementObserver.addLanguageListener = function(element) {
+	if (!element) { return; }
+
+	element.lang = document.documentElement.lang || "en";
+
+	ElementObserver._addObserver(document.documentElement, _onLanguageMutated.bind(null, element));
+};
+
+/**
+* @type {MutationObserver}
+* @private
+*/
+ElementObserver._observer = new MutationObserver(ElementObserver._onMutationCallback);
+/**
+* @type {Obect}
+* @private
+*/
+ElementObserver._listeners = {};
+/**
+* @type {number}
+* @private
+*/
+ElementObserver._id = 0;
+
+export default ElementObserver;
+export { ElementObserver };

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

@@ -0,0 +1,23 @@
+import {Ext} from './Ext.js';
+import {EventDispatcher} from './EventDispatcher.js';
+
+declare class ElementWrapper extends EventDispatcher {
+
+    constructor();
+
+    public getElement(): Element;
+
+    public setParent(parent: Node|ElementWrapper): void;
+
+    public getBoundingClientRect(): any;
+
+    public getMousePosition(e: Event, retObj?: any): any;
+
+    public addEventListener(type: string, listener: ((...params: any[]) => any)): void;
+
+    public removeEventListener(type: string, listener: ((...params: any[]) => any)): void;
+
+}
+
+export default ElementWrapper;
+export {ElementWrapper};

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

@@ -0,0 +1,83 @@
+import {Ext} from './Ext.js';
+import {EventDispatcher} from './EventDispatcher.js';
+
+/** @constructor
+* @extends {EventDispatcher}
+*/
+var ElementWrapper = function() {};
+Ext.inherits(ElementWrapper, EventDispatcher);
+/** @type {Element}
+* @protected
+* @ignore
+*/
+ElementWrapper.prototype._elem = null;
+
+
+/** @public
+* @return {Element}
+*/
+ElementWrapper.prototype.getElement = function() {
+	return this._elem;
+};
+/** @public
+* @param {Node|ElementWrapper} parent
+*/
+ElementWrapper.prototype.setParent = function(parent) {
+	if(parent) {
+		if(parent["getElement"]) {
+			parent = /** @type{Node} */(parent["getElement"]());
+		}
+		parent.appendChild(this._elem);
+	} else {
+		parent = this._elem.parentNode;
+		if(parent) {
+			parent.removeChild(this._elem);
+		}
+	}
+};
+/** @public
+* @return {!Object}
+*/
+ElementWrapper.prototype.getBoundingClientRect = function() {
+	return this._elem.getBoundingClientRect();
+};
+/** Get mouse position relative to this element
+* @public
+* @param {Event} e MouseEvent should be given
+* @param {Object=} retObj
+* @return {!Object}
+*/
+ElementWrapper.prototype.getMousePosition = function(e, retObj) {
+	if(!retObj) { retObj = {}; }
+	var bounds = this.getBoundingClientRect();
+	retObj["x"] = e.clientX - bounds["left"];
+	retObj["y"] = e.clientY - bounds["top"];
+
+	return /**@type {!Object}*/(retObj);
+};
+
+/** @public
+* @override
+* @param {string} type
+* @param {Function} listener
+*/
+ElementWrapper.prototype.addEventListener = function(type, listener) {
+	ElementWrapper.base(this, "addEventListener", type, listener);
+	if(this._elem["on" + type] != null) { // TODO: This won't work with Custom Element
+		this._elem.addEventListener(type, listener, false);
+	}
+};
+/** @public
+* @override
+* @param {string} type
+* @param {Function} listener
+*/
+ElementWrapper.prototype.removeEventListener = function(type, listener) {
+	ElementWrapper.base(this, "removeEventListener", type, listener);
+	if(this._elem["on" + type] != null) {
+		this._elem.removeEventListener(type, listener, false);
+	}
+};
+
+export default ElementWrapper;
+export {ElementWrapper};

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

@@ -0,0 +1,26 @@
+
+
+declare namespace ElfDate {
+
+    function from(val: any): Date;
+
+    function isValid(d: Date): boolean;
+
+    function prefixSingleDigit(n: number): string;
+
+    function toYMD(d: string|Date): string;
+
+    function setDate(edtp: Element, val: any): void;
+
+    function getDate(edtp: Element): Date;
+
+    function compare(valA: any, valB: any): number;
+
+    function equal(valA: any, valB: any): boolean;
+
+    function extractDate(d: Date): (number)[];
+
+}
+
+export default ElfDate;
+export { ElfDate };