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

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

@@ -0,0 +1,40 @@
+
+
+declare namespace Color {
+
+}
+
+declare function rgb2Hex(rgbCode: string): string;
+
+declare function num2Hex(triplet: (number)[]|null): string;
+
+declare function num2Rgb(triplet: (number)[]|null): string;
+
+declare function hex2Num(hex: string): (number)[]|null;
+
+declare function hex2Rgb(hex: string): string;
+
+declare function getColorLuminance(color: number): number;
+
+declare function getRelativeLuminance(triplet: (number)[]|null): number;
+
+declare function getContrastRatio(lumin1: number, lumin2: number): number;
+
+declare function getContrastColor(triplet: (number)[]|null): string;
+
+declare function blendColor(baseColor: string, maxColor: string, ratio: number): (number)[]|null;
+
+export default Color;
+export {
+	Color,
+	rgb2Hex,
+	num2Hex,
+	num2Rgb,
+	hex2Num,
+	hex2Rgb,
+	getColorLuminance,
+	getRelativeLuminance,
+	getContrastRatio,
+	getContrastColor,
+	blendColor
+};

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

@@ -0,0 +1,210 @@
+/** @namespace */
+let Color = {};
+
+/** @private
+* @constant
+* @type {RegExp}
+*/
+const NumRegExp = /\d+/g;
+
+/** Convert CSS rgb or rgba formats to CSS hex color string (with # prefix)
+* @public
+* @param {string} rgbCode RGB values without # prefix
+* @return {string} RGB in hex code (with # prefix)
+* @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); // ""
+*/
+let rgb2Hex = function (rgbCode) {
+	if(!rgbCode || typeof rgbCode !== "string") {
+		return "";
+	}
+	if(rgbCode.charAt(0) === "#") {
+		return rgbCode;
+	}
+	let rgb = rgbCode.match(NumRegExp);
+	if(!rgb || rgb.length < 3) {
+		return rgbCode;
+	}
+
+	let hex = "#";
+	for(let i = 0; i < 3; i++) {
+		let num = +rgb[i];
+		if(!(num >= 16)) { // Handle NaN case
+			hex += "0";
+		}
+		hex += (num) ? num.toString(16).toUpperCase() : "0";
+	}
+	return hex;
+};
+
+/** @public
+* @function
+* @param {Array.<number>} triplet
+* @return {string} resultColor
+*/
+let num2Hex = function (triplet) {
+	let rgb = triplet[2] | (triplet[1] << 8) | (triplet[0] << 16);
+	return ("#" + (0x1000000 + rgb).toString(16).slice(1));
+};
+/** Note that Chrome, IE, and Firefox store color in rgb representation.
+* @public
+* @function
+* @param {Array.<number>} triplet
+* @return {string} Color string in RGB represetation (e.g. rgb(100, 44, 1))
+*/
+let num2Rgb = function (triplet) {
+	return "rgb(" + triplet[0] + ", " + triplet[1] + ", " + triplet[2] + ")";
+};
+/** @public
+* @function
+* @param {string} hex
+* @return {Array.<number>} Array of size 3 which contains [red, green, blue]
+*/
+let hex2Num = function (hex) {
+	let hexInt = parseInt(hex.replace(/[^0-9A-F]/gi, ""), 16);
+	let r = (hexInt >> 16) & 255;
+	let g = (hexInt >> 8) & 255;
+	let b = hexInt & 255;
+	return [r, g, b];
+};
+/** @public
+* @function
+* @param {string} hex Color string with leading # character (e.g. #FFAA00)
+* @return {string} Color string in RGB represetation (e.g. rgb(100, 44, 1))
+*/
+let hex2Rgb = function (hex) {
+	if(hex) {
+		let hexInt = parseInt(hex.replace(/[^0-9A-F]/gi, ""), 16);
+		let r = (hexInt >> 16) & 255;
+		let g = (hexInt >> 8) & 255;
+		let b = hexInt & 255;
+		return "rgb(" + r + ", " + g + ", " + b + ")";
+	}
+	return "";
+};
+
+/** @public
+* @function
+* @param {number} color A color component (e.g., R, G, or B) with value between 0 and 255 (inclusive)
+* @return {number} Normalized luminance value between 0 and 1
+*/
+let getColorLuminance = function (color) {
+	if(!color || color < 0) {
+		return 0;
+	}
+	if(color >= 255) {
+		return 1;
+	}
+	let normalizedColor = color / 255;
+	if(normalizedColor <= 0.03928) {
+		return normalizedColor / 12.92;
+	}
+	return Math.pow((normalizedColor + 0.055) / 1.055, 2.4);
+};
+/** The relative brightness of any point in a colorspace, normalized to 0 for darkest black and 1 for lightest white (https://www.w3.org/TR/WCAG20/#relativeluminancedef)
+* @public
+* @function
+* @param {Array.<number>} triplet
+* @return {number} Normalized value between 0 and 1
+*/
+let getRelativeLuminance = function (triplet) {
+	let R = getColorLuminance(triplet[0]);
+	let G = getColorLuminance(triplet[1]);
+	let B = getColorLuminance(triplet[2]);
+
+	return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+};
+/** @public
+* @function
+* @param {number} lumin1
+* @param {number} lumin2
+* @return {number} Contrast ratios can range from 1 to 21 (commonly written 1:1 to 21:1).
+*/
+let getContrastRatio = function (lumin1, lumin2) {
+	if(lumin1 === lumin2) {
+		return 1;
+	}
+	let darker = lumin1;
+	let lighter = lumin2;
+
+	if(lumin1 > lumin2) {
+		lighter = lumin1;
+		darker = lumin2;
+	}
+	return (lighter + 0.05) / (darker + 0.05);
+};
+/** @public
+* @function
+* @param {Array.<number>} triplet
+* @return {string} white or black color in hex code
+*/
+let getContrastColor = function (triplet) {
+	let luminance = getRelativeLuminance(triplet);
+	let contrastW = getContrastRatio(1, luminance);
+	let contrastB = getContrastRatio(0, luminance);
+
+	if (contrastB >= contrastW) { // Brighter color has more impact to human eye than the darker color
+		return "#000000";
+	}
+	return "#ffffff";
+};
+
+/** Blend two colors into single color with the specified ratio
+* @public
+* @function
+* @param {string} baseColor
+* @param {string} maxColor
+* @param {number} ratio [0, 1]
+* @return {Array.<number>} resultColor
+*/
+let blendColor = function (baseColor, maxColor, ratio) { // This can be optimized further
+	if (ratio > 1) {
+		ratio = 1;
+	} else if(ratio < 0) {
+		ratio = 0;
+	}
+
+	let baseColorTriplet = hex2Num(baseColor);
+	let maxColorTriplet = hex2Num(maxColor);
+	let blendResult = [];
+	for (let i = 0; i < 3; ++i) {
+		let gap = (maxColorTriplet[i] - baseColorTriplet[i]) * ratio;
+		blendResult.push(baseColorTriplet[i] + gap);
+	}
+
+	return blendResult;
+};
+
+
+Color.rgb2Hex = rgb2Hex;
+Color.num2Hex = num2Hex;
+Color.num2Rgb = num2Rgb;
+Color.hex2Num = hex2Num;
+Color.hex2Rgb = hex2Rgb;
+Color.getColorLuminance = getColorLuminance;
+Color.getRelativeLuminance = getRelativeLuminance;
+Color.getContrastRatio = getContrastRatio;
+Color.getContrastColor = getContrastColor;
+Color.blendColor = blendColor;
+
+export default Color;
+export {
+	Color,
+	rgb2Hex,
+	num2Hex,
+	num2Rgb,
+	hex2Num,
+	hex2Rgb,
+	getColorLuminance,
+	getRelativeLuminance,
+	getContrastRatio,
+	getContrastColor,
+	blendColor
+};

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

@@ -0,0 +1,34 @@
+
+
+declare class Conflator {
+
+    constructor(func?: (((...params: any[]) => any)|number)|null, ms?: (number|((...params: any[]) => any))|null, thisObj?: any);
+
+    public reset(): any[]|null;
+
+    public popAllData(): any[]|null;
+
+    public dispose(): void;
+
+    public conflate(obj?: any): boolean;
+
+    public isConflating(): boolean;
+
+    public getData(): any[];
+
+    public setFunction(func: ((...params: any[]) => any)|null, thisObj?: any): void;
+
+    public setConflatingTime(ms: number): void;
+
+    public getConflatingTime(): number;
+
+    public disable(opt_disabled?: boolean|null): void;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean|null): void;
+
+}
+
+export default Conflator;
+export {Conflator};

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

@@ -0,0 +1,193 @@
+/** Conflator is used to stop multiple executions of a function in the specified period of time by merging multiple calls into one single call. <br>
+* Conflator guarantees that only one single call will be executed.
+* @constructor
+* @param {(Function|number)=} func Bound function that will use this conflator
+* @param {(number|Function)=} ms The delay time in millisecond before executing the function
+* @param {*=} thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+* @example
+* let c = new Conflator(function() { console.log("Executed"); }, 1000);
+* for(let i = 10; --i >= 0;) {
+*   c.conflate(i); // Only one "Executed" text will be logged to console after one second
+* }
+*/
+let Conflator = function (func, ms, thisObj) {
+	this._onConflated = this._onConflated.bind(this);
+
+	this._data = [];
+
+	if(typeof func == "function") {
+		this.setFunction(func, thisObj);
+	} else if (typeof ms == "function") { // Parameter can be swapped places
+		this.setFunction(ms, thisObj);
+	}
+
+	if(typeof ms == "number") {
+		this.setConflatingTime(ms);
+	} else if (typeof func == "number") { // Parameter can be swapped places
+		this.setConflatingTime(func);
+	}
+};
+
+/** @type {!Array}
+* @private
+*/
+Conflator.prototype._data; // Array to store all conflated data
+/** @type {Function}
+* @private
+*/
+Conflator.prototype._func = null;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._delay = 0;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._timerId = 0;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._conflated = false;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._disabled = false;
+
+
+/** Any existing timer and stored data will be cleared.
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.reset = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+
+	return this.popAllData();
+};
+/** All stored data will be cleared
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.popAllData = function() {
+	if(this._data.length) {
+		let data = this._data;
+		this._data = [];
+		return data;
+	}
+	return null;
+};
+/** @public */
+Conflator.prototype.dispose = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+	if(this._data.length) {
+		this._data.length = 0;
+	}
+	this._func = null; // Release user bound function
+};
+
+/** @public
+* @param {*=} obj Any data that is needed to be stored for later usage
+* @return {boolean}
+*/
+Conflator.prototype.conflate = function (obj) {
+	if(this._disabled) {
+		return false;
+	}
+	if(obj != null) {
+		this._data.push(obj);
+	}
+	if(this._conflated) {
+		return false; // Conflating operation is already completed
+	}
+	if(!this._timerId) {
+		this._timerId = setTimeout(this._onConflated, this._delay);
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isConflating = function () {
+	return (this._timerId > 0 && !this._conflated && !this._disabled);
+};
+
+/** @private */
+Conflator.prototype._onConflated = function () {
+	this._conflated = true;
+
+	try {
+		this._func();
+	} catch (err) {
+		console.error(err.message || err);
+	}
+
+	this._timerId = 0;
+	this._data.length = 0;
+	this._conflated = false;
+};
+
+/** @public
+* @return {!Array}
+*/
+Conflator.prototype.getData = function () {
+	return this._data;
+};
+/** @public
+* @param {Function} func Bound function that will use this conflator
+* @param {*=} thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+*/
+Conflator.prototype.setFunction = function (func, thisObj) {
+	this._func = func;
+	if(func) {
+		if(thisObj) {
+			this._func = func.bind(thisObj);
+		} else {
+			this._func = func;
+		}
+	} else {
+		this._func = null;
+	}
+};
+/** @public
+* @param {number} ms The delay time in millisecond before executing the function
+*/
+Conflator.prototype.setConflatingTime = function (ms) {
+	this._delay = ms || 0;
+	if(this._delay < 0) {
+		this._delay = 0;
+	}
+};
+
+/** @public
+* @return {number} milli second
+*/
+Conflator.prototype.getConflatingTime = function () {
+	return this._delay;
+};
+
+/** @public
+* @param {boolean=} opt_disabled
+*/
+Conflator.prototype.disable = function (opt_disabled) {
+	this._disabled = opt_disabled !== false;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isEnabled = function () {
+	return !this._disabled;
+};
+/** @public
+* @param {boolean=} opt_enabled
+*/
+Conflator.prototype.enable = function (opt_enabled) {
+	this._disabled = opt_enabled === false;
+};
+
+export default Conflator;
+export {Conflator};

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

@@ -0,0 +1,10 @@
+
+
+declare namespace CoralItems {
+
+    function create(userItems: any[]|null): (any)[]|null;
+
+}
+
+export default CoralItems;
+export {CoralItems};

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

@@ -0,0 +1,42 @@
+/** @namespace */
+let CoralItems = {};
+
+/** Create new array with valid object items to be consumed by ef-select's data property from the given input
+* @public
+* @function
+* @param {Array} userItems This can be array of anything (e.g. texts, numbers, objects or etc.).
+* @return {Array.<Object>} Valid data objects for generating ef-item by ef-select
+* @example
+* CoralItems.create(["a", "b"]); // [{label: "a", value: "a"}, {label: "b", value: "b"}]
+* CoralItems.create([33]); // [{label: "33", value: 33}]
+* CoralItems.create([null]); // [{label: "", value: ""}]
+* CoralItems.create([{value: false}]); // [{label: "false", value: false}]
+* CoralItems.create([{label: "a", value: "b"}]); // [{label: "a", value: "b"}]
+* CoralItems.create("invalid parameter"); // null
+*/
+CoralItems.create = function(userItems) {
+	if(Array.isArray(userItems)) {
+		let len = userItems.length;
+		let ary = new Array(len);
+		for(let i = 0; i < len; ++i) {
+			let userItem = userItems[i];
+			if(userItem != null) {
+				if (typeof userItem !== "object") {
+					userItem = { value: userItem };
+				}
+			} else {
+				userItem = {value: ""};
+			}
+			let label = userItem.label;
+			if(!label && typeof label !== "string") { // 0, false, null, undefined, NaN
+				userItem.label = userItem.value + "";
+			}
+			ary[i] = userItem;
+		}
+		return ary;
+	}
+	return null;
+};
+
+export default CoralItems;
+export {CoralItems};

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

@@ -0,0 +1,57 @@
+import translation from './locale/translation.js';
+import ElfUtil from './ElfUtil.js';
+
+declare namespace DateTime {
+
+    function setDateTimePattern(format?: string|null): void;
+
+    function setLocale(lang?: string|null): void;
+
+    function format(dateTimeNumber: number|string|Date|null, dateTimeFormat?: string|null, timezone?: string|null): string;
+
+    function formatDateObject(date: Date|null, dateTimeFormat?: string|null): string;
+
+    function isValidDate(dateObj: Date|null): boolean;
+
+    function isInvalidDate(dateObj: Date|null): boolean;
+
+    function fromDateNumber(dateNumber: number): Date;
+
+    function dateNumberToMs(dateNumber: number): number;
+
+    function timeNumberToMs(dateNumber: number): number;
+
+    function toDateObject(dateInput: string|number|null): any;
+
+    function toDateNumber(dateObj: Date|null): number;
+
+    function toTimeNumber(dateObj: Date|null): number;
+
+    function toYYYYMMDD(dateObj: Date|null): string;
+
+}
+
+declare const INVALID_DATE: Date;
+
+declare const MILLISECONDS_IN_DAY: number;
+
+declare const SECONDS_IN_DAY: number;
+
+declare const SECONDS_IN_HOUR: number;
+
+declare const SECONDS_IN_MINUTE: number;
+
+declare const SHORT_DAYS: (string)[]|null;
+
+declare const FULL_DAYS: (string)[]|null;
+
+declare const SHORT_MONTHS: (string)[]|null;
+
+declare const FULL_MONTHS: (string)[]|null;
+
+declare function prefixZero(num: number): string;
+
+declare function prefixDoubleZero(num: number): string;
+
+export default DateTime;
+export { DateTime, MILLISECONDS_IN_DAY, SECONDS_IN_DAY };