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

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

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

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

@@ -0,0 +1,268 @@
+import {Dom} from './Dom.js';
+
+/** @namespace */
+let TextHighlighter = {};
+/** /[^\w-_ .]+/g
+* @type {RegExp}
+* @public
+*/
+TextHighlighter.invalidChars = /[^\w-_ .]+/g;
+/** /\s+/
+* @type {RegExp}
+* @public
+*/
+TextHighlighter.spaces = /\s+/;
+/** 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
+* let parent = Dom.div();
+* let child1 = Dom.text("Lorem ipsum dolor sit amet");
+* let 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) {
+	let rule = TextHighlighter.buildRule(keyword);
+	if(!tagName) {
+		tagName = TextHighlighter.defaultTag;
+	}
+
+	let nodes = [elem];
+	for(let i = 0; i < nodes.length; ++i) {
+		let curNode = nodes[i];
+		let chdr = curNode.children;
+		let nonLeafNode = !curNode._highlightData && chdr && chdr.length;
+		if(nonLeafNode) {
+			let len = chdr.length;
+			for(let 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
+* let el = Dom.text("Lorem ipsum dolor sit amet");
+* let highlightedEl = TextHighlighter.highlightContent(el, "e", "mark");
+* highlightedEl === el; // true
+*/
+TextHighlighter.highlightContent = function(elem, keyword, tagName) {
+	let reset = true;
+	if(keyword) {
+		let text = elem.textContent;
+		if(text) {
+			let highlightData = elem._highlightData;
+			let splitInfo = TextHighlighter._split(text, keyword, null, highlightData);
+			if(splitInfo) {
+				let i, len;
+				if(!highlightData) {
+					elem._highlightData = splitInfo;
+
+					// Save original child nodes
+					let cns = elem.childNodes;
+					len = cns.length;
+					let 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;
+				}
+
+				let chunks = splitInfo["chunks"];
+				len = chunks.length;
+				for(i = 0; i < len; ++i) {
+					let chunk = chunks[i];
+					if(chunk) {
+						let 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) {
+		let obj = /** @type{Object} */(elem._highlightData);
+		if(obj) {
+			let score = obj["score"];
+			if(score == null) {
+				let positions = /** @type{Array.<number>} */(obj["positions"]);
+				let matches = /** @type{Array.<string>} */(obj["matches"]);
+				let matchCount = matches.length;
+
+				score = matchCount * 1000; // Number of the matched keywords
+				for(let i = 0; i < matchCount; ++i) {
+					let curTxt = matches[i];
+					let pos = positions[i];
+					score += curTxt.length * 100; // Length of the matched keywords
+					score += pos ? (400 / pos) | 0 : 500;
+				}
+				if(matchCount) {
+					let 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) {
+	let 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;
+	}
+	let regExp = TextHighlighter.buildRule(needle, caseSensitive);
+
+	let matches = haystack.match(regExp);
+	if(!matches) {
+		return null;
+	}
+
+	if(!out_obj) {
+		out_obj = {};
+	}
+
+	let matchCount = matches.length;
+	let positions = new Array(matchCount);
+	let start = 0;
+	let curIdx = 0;
+	let chunks = [];
+	do {
+		let curMatch = matches[curIdx];
+		let matchLen = curMatch.length;
+		let at = positions[curIdx] = haystack.indexOf(curMatch, start);
+		chunks.push(
+			haystack.slice(start, at),
+			haystack.slice(at, at + matchLen)
+		);
+		start = at + matchLen;
+	} while(++curIdx < matchCount);
+
+	let end = haystack.length;
+	if(start < end) {
+		chunks.push(haystack.slice(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
+* let 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.trim();
+	}
+	if(!txt) {
+		return null;
+	}
+
+	let option = caseSensitive ? "g" : "gi";
+	let keywords = txt.split(TextHighlighter.spaces);
+	let 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 }|null;
+
+declare const TickFields: { [key: string]:  number }|null;
+
+export default TickCodes;
+export {TickCodes, TickFields};

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

@@ -0,0 +1,33 @@
+/** @type {Object.<string, number>}
+* @public
+*/
+let 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
+*/
+let 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)|null, 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
+* let 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
+*/
+let 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|null,
+        preventDefault?: boolean|null
+    };
+
+}
+
+declare class TouchProxy extends EventDispatcher {
+
+    constructor(elem?: Element|null, options?: (boolean|any)|null);
+
+    public static readonly passive: EventListenerOptions;
+
+    public getElement(): Element|null;
+
+    public setElement(elem?: Element|null): void;
+
+    public applyTrait(elem: Element|null): void;
+
+    public dispose(): void;
+
+    public addTouchListeners(touchStartFunc?: ((...params: any[]) => any)|null, touchEndFunc?: ((...params: any[]) => any)|null, touchMoveFunc?: ((...params: any[]) => any)|null): void;
+
+    public removeTouchListeners(): void;
+
+    public attachTouchMoveEvent(): void;
+
+    public detachTouchMoveEvent(): void;
+
+    public attachTouchEvents(touchMove?: boolean|null): void;
+
+    public detachTouchEvents(): void;
+
+    public static getButtonType(e: Event|null): number;
+
+    public static getPosition(e: Event|any|null, 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
+*/
+let 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() {
+	let 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() {
+	let 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) {
+	let 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() {
+	let 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) {
+	let touches = e.changedTouches;
+	let 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;