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

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

@@ -0,0 +1,18 @@
+import {Dom} from './Dom.js';
+
+declare namespace TextHighlighter {
+
+    const invalidChars: RegExp;
+
+    const spaces: RegExp;
+
+    const spaceTrimer: RegExp;
+
+    const defaultTag: string;
+
+}
+
+declare function score(haystack: string, needle: string|RegExp, caseSensitive?: (boolean|number)): (string)[];
+
+export default TextHighlighter;
+export {TextHighlighter};

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

@@ -0,0 +1,273 @@
+import {Dom} from './Dom.js';
+
+/** @namespace */
+var TextHighlighter = {};
+/** /[^\w-_ .]+/g
+* @type {RegExp}
+* @public
+*/
+TextHighlighter.invalidChars = /[^\w-_ .]+/g;
+/** /\s+/
+* @type {RegExp}
+* @public
+*/
+TextHighlighter.spaces = /\s+/;
+/** /^\s+|\s+$/g
+* @type {RegExp}
+* @public
+*/
+TextHighlighter.spaceTrimer = /^\s+|\s+$/g;
+/** Default is <mark> tag
+* @type {string}
+* @public
+*/
+TextHighlighter.defaultTag = "mark";
+
+/** Highlight all descendants from the given element. Only leaf node, that has no children, will be highlighted.
+* @function
+* @param {Element} elem
+* @param {string|RegExp} keyword If omit, the content, that has been highlighted, will be restored to its original form
+* @param {string=} tagName Default is <mark> tag
+* @return {Element} the same given elem
+* @example
+* var parent = Dom.div();
+* var child1 = Dom.text("Lorem ipsum dolor sit amet");
+* var child2 = Dom.text("Quisque volutpat, neque et pretium accumsan");
+* Dom.appendChild(parent, child1, child2);
+* TextHighlighter.highlightAll(parent, "e", "mark"); // only child1 and child2 are modified
+*/
+TextHighlighter.highlightAll = function(elem, keyword, tagName) {
+	var rule = TextHighlighter.buildRule(keyword);
+	if(!tagName) {
+		tagName = TextHighlighter.defaultTag;
+	}
+
+	var nodes = [elem];
+	for(var i = 0; i < nodes.length; ++i) {
+		var curNode = nodes[i];
+		var chdr = curNode.children;
+		var nonLeafNode = !curNode._highlightData && chdr && chdr.length;
+		if(nonLeafNode) {
+			var len = chdr.length;
+			for(var j = 0; j < len; ++j) {
+				nodes.push(chdr[j]);
+			}
+		} else { // leaf node
+			TextHighlighter.highlightContent(curNode, rule, tagName);
+		}
+	}
+	return elem;
+};
+
+/** Highlight text content of the given element. This method does not preserve internal structure of the element. Thus, this should be used on a leaf node where content is just text without layout.
+* @function
+* @param {Element} elem
+* @param {string|RegExp} keyword If omit, the content, that has been highlighted, will be restored to its original form
+* @param {string=} tagName Default is &lt;mark> tag
+* @return {Element} Element with children of &lt;span>&lt;/span> and &lt;mark>&lt;/mark> tags
+* @example
+* var el = Dom.text("Lorem ipsum dolor sit amet");
+* var highlightedEl = TextHighlighter.highlightContent(el, "e", "mark");
+* highlightedEl === el; // true
+*/
+TextHighlighter.highlightContent = function(elem, keyword, tagName) {
+	var reset = true;
+	if(keyword) {
+		var text = elem.textContent;
+		if(text) {
+			var highlightData = elem._highlightData;
+			var splitInfo = TextHighlighter._split(text, keyword, null, highlightData);
+			if(splitInfo) {
+				var i, len;
+				if(!highlightData) {
+					elem._highlightData = splitInfo;
+
+					// Save original child nodes
+					var cns = elem.childNodes;
+					len = cns.length;
+					var originalNodes = new Array(len);
+					for(i = 0; i < len; ++i) {
+						originalNodes[i] = cns[i];
+					}
+					splitInfo["originalNodes"] = originalNodes;
+				}
+				Dom.removeChildren(elem);
+
+				if(!tagName) {
+					tagName = TextHighlighter.defaultTag;
+				}
+
+				var chunks = splitInfo["chunks"];
+				len = chunks.length;
+				for(i = 0; i < len; ++i) {
+					var chunk = chunks[i];
+					if(chunk) {
+						var tag = Dom.create((i & 1) ? tagName : "span");
+						tag.textContent = chunk;
+						elem.appendChild(tag);
+					}
+				}
+				reset = false;
+			}
+		}
+	}
+	if(reset) {
+		TextHighlighter.restore(elem);
+	}
+	return elem;
+};
+
+/** Clear all highlights and reset back to its original state.
+* @function
+* @param {Element} elem
+* @return {boolean} Returns true if there is any change
+*/
+TextHighlighter.restore = function(elem) {
+	if(elem && elem._highlightData) {
+		Dom.removeChildren(elem);
+		Dom.appendChild(elem, elem._highlightData["originalNodes"]);
+		elem._highlightData = null;
+		return true;
+	}
+	return false;
+};
+
+/** Get matching score. The score is calculated by the following criteria: <br>
+* - Number of the matched keywords <br>
+* - Length of the matched keywords <br>
+* - Position of the matched keywords <br>
+* - Length of the original text <br>
+*
+* @function
+* @param {Element} elem
+* @return {number}
+*/
+TextHighlighter.getScore = function(elem) {
+	if(elem) {
+		var obj = /** @type{Object} */(elem._highlightData);
+		if(obj) {
+			var score = obj["score"];
+			if(score == null) {
+				var positions = /** @type{Array.<number>} */(obj["positions"]);
+				var matches = /** @type{Array.<string>} */(obj["matches"]);
+				var matchCount = matches.length;
+
+				score = matchCount * 1000; // Number of the matched keywords
+				for(var i = 0; i < matchCount; ++i) {
+					var curTxt = matches[i];
+					var pos = positions[i];
+					score += curTxt.length * 100; // Length of the matched keywords
+					score += pos ? (400 / pos) | 0 : 500;
+				}
+				if(matchCount) {
+					var origLen = obj["original"] ? obj["original"].length : 0;
+					score += origLen ? (1000 / origLen) | 0 : 0;
+				}
+				obj["score"] = score; // Cache for later usage
+			}
+			return /** @type{number} */(score);
+		}
+	}
+	return 0;
+};
+
+/** Split the given haystack while preserving the matched texts (i.e. the results will contain the given needle). The matched texts will always be in the odd index (e.g. 1, 3, 5, ...) of the result array.
+* @function
+* @param {string} haystack
+* @param {string|RegExp} needle
+* @param {(boolean|number)=} caseSensitive
+* @return {!Array.<string>}
+* @example
+* TextHighlighter.split("aabbccbb ddbbee", "bb"); // ["aa", "bb", "cc", "bb", " dd", "bb", "ee"]
+* TextHighlighter.split("entire_word", "entire_word"); // ["", "entire_word"]
+* TextHighlighter.split("not_found", "aaa"); // ["not_found"]
+*/
+TextHighlighter.split = function (haystack, needle, caseSensitive) {
+	var obj = TextHighlighter._split(haystack, needle, caseSensitive);
+	if(obj) {
+		return /** @type{!Array.<string>} */(obj["chunks"]);
+	}
+	return [haystack];
+};
+/** @private
+* @function
+* @param {string} haystack
+* @param {string|RegExp} needle
+* @param {(boolean|number)=} caseSensitive
+* @param {Object=} out_obj
+* @return {Object}
+*/
+TextHighlighter._split = function (haystack, needle, caseSensitive, out_obj) {
+	if(!haystack || !needle) {
+		return null;
+	}
+	var regExp = TextHighlighter.buildRule(needle, caseSensitive);
+
+	var matches = haystack.match(regExp);
+	if(!matches) {
+		return null;
+	}
+
+	if(!out_obj) {
+		out_obj = {};
+	}
+
+	var matchCount = matches.length;
+	var positions = new Array(matchCount);
+	var start = 0;
+	var curIdx = 0;
+	var chunks = [];
+	do {
+		var curMatch = matches[curIdx];
+		var matchLen = curMatch.length;
+		var at = positions[curIdx] = haystack.indexOf(curMatch, start);
+		chunks.push(
+			haystack.substring(start, at),
+			haystack.substr(at, matchLen)
+		);
+		start = at + matchLen;
+	} while(++curIdx < matchCount);
+
+	var end = haystack.length;
+	if(start < end) {
+		chunks.push(haystack.substring(start, end));
+	}
+
+	out_obj["chunks"] = chunks;
+	out_obj["matches"] = matches;
+	out_obj["positions"] = positions;
+	out_obj["original"] = haystack;
+	out_obj["score"] = null;
+	return out_obj;
+};
+
+/** Build RegExp for highlighting. This is useful to speed up the process, as the same rule will be used on multiple elements.
+* @function
+* @param {string|RegExp} txt
+* @param {(boolean|number)=} caseSensitive If true, the rule is produced with case sensitive characters
+* @return {RegExp}
+* @example
+* var regExp = TextHighlighter.buildRule("A + B"); // Equivalent to new RegExp(/A|B/g);
+*/
+TextHighlighter.buildRule = function(txt, caseSensitive) {
+	if(typeof txt != "string") {
+		return /** @type{RegExp} */(txt) || null;
+	}
+
+	if(txt) {
+		txt = txt.replace(TextHighlighter.invalidChars, " ");
+		txt = txt.replace(TextHighlighter.spaceTrimer, "");
+	}
+	if(!txt) {
+		return null;
+	}
+
+	var option = caseSensitive ? "g" : "gi";
+	var keywords = txt.split(TextHighlighter.spaces);
+	var rule = (keywords.length > 1) ? keywords.join("|") : txt;
+
+	return new RegExp(rule, option);
+};
+
+export default TextHighlighter;
+export {TextHighlighter};

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

@@ -0,0 +1,8 @@
+
+
+declare const TickCodes: { [key: string]:  number };
+
+declare const TickFields: { [key: string]:  number };
+
+export default TickCodes;
+export {TickCodes, TickFields};

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

@@ -0,0 +1,33 @@
+/** @type {Object.<string, number>}
+* @public
+*/
+var TickCodes = {
+	"\u21e7": 1,
+	"B\u21e7": 1,
+	"\u2191": 1,
+	"B\u2191": 1,
+	"26": 1,
+	"1": 1,
+	"\"1\"": 1,
+	"-1": -1,
+	"\u21e9": -1,
+	"B\u21e9": -1,
+	"\u2193": -1,
+	"B\u2193": -1,
+	"27": -1,
+	"2": -1,
+	"\"2\"": -1
+};
+
+/** @type {Object.<string, number>}
+* @public
+*/
+var TickFields = {
+	"CF_TICK": 1,
+	"PRCTCK_1": 1,
+	"BID_TICK": 1,
+	"ASK_TICK": 1
+};
+
+export default TickCodes;
+export {TickCodes, TickFields};

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

@@ -0,0 +1,16 @@
+
+
+declare class Timer {
+
+    constructor(duration: number, func?: ((...params: any[]) => any), ctx?: any);
+
+    public start(): void;
+
+    public stop(): void;
+
+    public isActive(): boolean;
+
+}
+
+export default Timer;
+export {Timer};

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

@@ -0,0 +1,49 @@
+/** Provide a way to execute a function with context object. The timer can be started, extended, stopped at any time. Use {@link Delay} for promisified version of Timer class
+* @constructor
+* @param {number} duration Delay before executing the given function
+* @param {Function=} func Function to be executed
+* @param {*=} ctx Context object that will be supplied to the function as the first parameter
+* @example
+* var timer = new Timer(2000, (ctx)=>{ console.log(ctx)}, "AAA");
+* timer.start(); // AAA will be logged after 2 seconds
+* timer.start(); // Timer is reset. AAA will be logged only once
+*/
+var Timer = function(duration, func, ctx) {
+	this._duration = (typeof duration == "number") ? duration : 0;
+	this._onTimeout = this._onTimeout.bind(this);
+	this._method = func || null;
+	this._ctx = ctx != null ? ctx : null;
+};
+/** If calling start before the timer end, the timer will be reset, and effectively extended the duration.
+* @public
+*/
+Timer.prototype.start = function() {
+	if(this._timerId) {
+		clearTimeout(this._timerId); // Extend duration
+	}
+	this._timerId = setTimeout(this._onTimeout, this._duration);
+};
+/** @public */
+Timer.prototype.stop = function() {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+};
+/** @public
+* @return {boolean}
+*/
+Timer.prototype.isActive = function() {
+	return this._timerId ? true : false;
+};
+
+/** @private */
+Timer.prototype._onTimeout = function() {
+	this._timerId = 0;
+	if(this._method) {
+		this._method(this._ctx || this);
+	}
+};
+
+export default Timer;
+export {Timer};

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

@@ -0,0 +1,46 @@
+import {Ext} from "./Ext.js";
+import {EventDispatcher} from "./EventDispatcher.js";
+
+declare namespace TouchProxy {
+
+    type Options = {
+        useTouchMove?: boolean,
+        preventDefault?: boolean
+    };
+
+}
+
+declare class TouchProxy extends EventDispatcher {
+
+    constructor(elem?: Element, options?: (boolean|any));
+
+    public static readonly passive: EventListenerOptions;
+
+    public getElement(): Element;
+
+    public setElement(elem?: Element): void;
+
+    public applyTrait(elem: Element): void;
+
+    public dispose(): void;
+
+    public addTouchListeners(touchStartFunc?: ((...params: any[]) => any), touchEndFunc?: ((...params: any[]) => any), touchMoveFunc?: ((...params: any[]) => any)): void;
+
+    public removeTouchListeners(): void;
+
+    public attachTouchMoveEvent(): void;
+
+    public detachTouchMoveEvent(): void;
+
+    public attachTouchEvents(touchMove?: boolean): void;
+
+    public detachTouchEvents(): void;
+
+    public static getButtonType(e: Event): number;
+
+    public static getPosition(e: Event|any, obj?: any): any;
+
+}
+
+export {TouchProxy};
+export default TouchProxy;

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

@@ -0,0 +1,212 @@
+import {Ext} from "./Ext.js";
+import {EventDispatcher} from "./EventDispatcher.js";
+
+/** @typedef {Object} TouchProxy~Options
+* @description TouchProxy options
+* @property {boolean=} useTouchMove=false If enabled, touch events are added to the element
+* @property {boolean=} preventDefault=false If enabled, event default behaviors are prevented
+*/
+
+/** @event TouchProxy#touchStart
+* @description Alias to native touchstart
+* @type {Event}
+*/
+/** @event TouchProxy#touchEnd
+* @description Alias to native touchend and touchcancel
+* @type {Event}
+*/
+/** @event TouchProxy#touchMove
+* @description Alias to native touchmove
+* @type {Event}
+*/
+
+/** @constructor
+* @extends {EventDispatcher}
+* @param {Element=} elem
+* @param {(boolean|Object)=} options Boolean is treated as useTouchMove
+*/
+var TouchProxy = function (elem, options) {
+	this._onTouchStart = this._dispatch.bind(this, "touchStart");
+	this._onTouchEnd = this._dispatch.bind(this, "touchEnd");
+	this._onTouchMove = this._dispatch.bind(this, "touchMove");
+
+	if(options) {
+		if(typeof options == "boolean") {
+			this._touchMove = true;
+		} else {
+			if(options["useTouchMove"]) {
+				this._touchMove = true;
+			}
+			if(options["preventDefault"]) {
+				this._defaultPrevented = true;
+			}
+		}
+	}
+	if(!this._defaultPrevented) {
+		this._evtOptions = TouchProxy.passive;
+	}
+	this.setElement(elem);
+};
+Ext.inherits(TouchProxy, EventDispatcher);
+
+/** @type {Element}
+* @private
+*/
+TouchProxy.prototype._elem;
+/** @type {!Function}
+* @private
+*/
+TouchProxy.prototype._onTouchStart;
+/** @type {!Function}
+* @private
+*/
+TouchProxy.prototype._onTouchEnd;
+/** @type {!Function}
+* @private
+*/
+TouchProxy.prototype._onTouchMove;
+/** @type {boolean}
+* @private
+*/
+TouchProxy.prototype._touchMove = false;
+/** @type {boolean}
+* @private
+*/
+TouchProxy.prototype._defaultPrevented = false;
+/** @type {!EventListenerOptions}
+* @private
+*/
+TouchProxy.prototype._evtOptions;
+/** @type {!EventListenerOptions}
+* @public
+*/
+TouchProxy.passive = {"passive": true};
+
+/** @public
+* @return {Element}
+*/
+TouchProxy.prototype.getElement = function() {
+	return this._elem;
+};
+/** @public
+* @param {Element=} elem
+*/
+TouchProxy.prototype.setElement = function(elem) {
+	this.detachTouchEvents();
+	this._elem = elem || null;
+	this.attachTouchEvents(this._touchMove);
+};
+/** @public
+* @function
+* @param {Element} elem
+*/
+TouchProxy.prototype.applyTrait = TouchProxy.prototype.setElement;
+/** @public */
+TouchProxy.prototype.dispose = function() {
+	this.setElement(null);
+};
+
+/** @public
+* @param {Function=} touchStartFunc
+* @param {Function=} touchEndFunc
+* @param {Function=} touchMoveFunc
+*/
+TouchProxy.prototype.addTouchListeners = function(touchStartFunc, touchEndFunc, touchMoveFunc) {
+	if(touchStartFunc) {
+		this.addEventListener("touchStart", touchStartFunc);
+	}
+	if(touchEndFunc) {
+		this.addEventListener("touchEnd", touchEndFunc);
+	}
+	if(touchMoveFunc) {
+		this.addEventListener("touchMove", touchMoveFunc);
+	}
+};
+/** @public
+* @function
+*/
+TouchProxy.prototype.removeTouchListeners = TouchProxy.prototype.unlistenAll;
+
+/** @public */
+TouchProxy.prototype.attachTouchMoveEvent = function() {
+	var elem = this._elem;
+	if(elem) {
+		if(this._defaultPrevented) {
+			elem.addEventListener("touchmove", EventDispatcher.preventDefault);
+		}
+		elem.addEventListener("touchmove",  this._onTouchMove, this._evtOptions);
+	}
+};
+/** @public */
+TouchProxy.prototype.detachTouchMoveEvent = function() {
+	var elem = this._elem;
+	if(elem) {
+		if(this._defaultPrevented) {
+			elem.removeEventListener("touchmove", EventDispatcher.preventDefault);
+		}
+		elem.removeEventListener("touchmove",  this._onTouchMove, this._evtOptions);
+	}
+};
+/** @public
+* @param {boolean=} touchMove
+*/
+TouchProxy.prototype.attachTouchEvents = function(touchMove) {
+	var elem = this._elem;
+	if(elem) {
+		elem.addEventListener("touchstart", this._onTouchStart, this._evtOptions);
+		elem.addEventListener("touchend", this._onTouchEnd, this._evtOptions);
+		elem.addEventListener("touchcancel",  this._onTouchEnd, this._evtOptions);
+		if(touchMove) {
+			this.attachTouchMoveEvent();
+		}
+	}
+};
+/** @public */
+TouchProxy.prototype.detachTouchEvents = function() {
+	var elem = this._elem;
+	if(elem) {
+		elem.removeEventListener("touchstart", this._onTouchStart, this._evtOptions);
+		elem.removeEventListener("touchend", this._onTouchEnd, this._evtOptions);
+		elem.removeEventListener("touchcancel",  this._onTouchEnd, this._evtOptions);
+		this.detachTouchMoveEvent();
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+* @return {number} 0 is Left mouse button
+*/
+TouchProxy.getButtonType = function(e) {
+	if(e.changedTouches) {
+		return 0;
+	} else {
+		return e.button || 0; // Support from IE9+
+	}
+};
+/** @public
+* @function
+* @param {Event|Object} e
+* @param {Object=} obj
+* @return {!Object}
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent}
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent}
+*/
+TouchProxy.getPosition = function(e, obj) {
+	var touches = e.changedTouches;
+	var mPos = (touches) ? touches[touches.length - 1] : e;
+
+	if(!obj) {
+		obj = {};
+	}
+	obj["x"] = obj["pageX"] = mPos.pageX; // window.pageXOffset
+	obj["y"] = obj["pageY"] = mPos.pageY; // window.pageYOffset
+	obj["clientX"] = mPos.clientX; // Allow relative position calculation and distance comparison
+	obj["clientY"] = mPos.clientY;
+	obj["timeStamp"] = e.timeStamp;
+	return obj;
+};
+
+
+export {TouchProxy};
+export default TouchProxy;