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

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

@@ -0,0 +1,508 @@
+import translation from './locale/translation.js';
+import ElfUtil from './ElfUtil.js';
+
+/** @type {!Date}
+* @public
+* @constant
+*/
+const INVALID_DATE = new Date(NaN); // eslint-disable-line
+/** JavaScript date starts at Jan 01 1970, while Excel date starts at Jan 01 1900 (before JavaScript date). This value is the difference in days between the two values.
+* @type {number}
+* @private
+* @constant
+*/
+const _DIFF_DAYS = 25567 + 2; // Start 1 on 1 Jan 1900 + 1 for error on 29 Feb 1900 (Not existing date but existing in window)
+/** Starting date (1 Jan 1900) of Excel date in milliseconds counting from JavaScript date
+* @type {number}
+* @private
+* @constant
+*/
+const _1_JAN_1900 = Date.UTC(1900, 0, 1); // -2208988800000
+/** @type {number}
+* @private
+* @constant
+*/
+const _1_MAR_1900 = Date.UTC(1900, 2, 1); // -2203891200000
+/** @type {number}
+* @public
+* @constant
+*/
+const MILLISECONDS_IN_DAY = 24 * 60 * 60 * 1000; // 86400000
+/** 86400 seconds in a day
+* @type {number}
+* @public
+* @constant
+*/
+const SECONDS_IN_DAY = 24 * 60 * 60; // eslint-disable-line
+/** 3600 seconds in a day
+* @type {number}
+* @public
+* @constant
+*/
+const SECONDS_IN_HOUR = 60 * 60; // eslint-disable-line
+/** @type {number}
+* @public
+* @constant
+*/
+const SECONDS_IN_MINUTE = 60; // eslint-disable-line
+
+/** @type {Array.<string>}
+* @public
+* @constant
+*/
+const SHORT_DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+/** @type {Array.<string>}
+* @public
+* @constant
+*/
+const FULL_DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** @type {Array.<string>}
+* @public
+* @constant
+*/
+const SHORT_MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+/** @type {Array.<string>}
+* @public
+* @constant
+*/
+const FULL_MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+
+/** Add zero prefix to the number. WARNING: Does not support negative number
+* @ignore
+* @function
+* @param {number} num
+* @return {string}
+*/
+let prefixZero = function(num) {
+	return (num > 9) ? "" + num : "0" + num;
+};
+
+/** Add double zero prefix to the number. WARNING: Does not support negative number
+* @ignore
+* @function
+* @param {number} num
+* @return {string}
+*/
+let prefixDoubleZero = function(num) {
+	if (num > 99) {
+		return "" + num;
+	} else if (num > 9) {
+		return "0" + num;
+	} else {
+		return "00" + num;
+	}
+};
+
+/** @type {!Object.<string, Function>}
+* @ignore
+* @description Map of date pattern convertion
+*/
+let Parsers = {
+	// Interday time
+	"D": function(date, locale) { return "" + date.getDate(); },
+	"DD": function(date, locale) { return prefixZero(date.getDate()); },
+	"DDD": function(date, locale) { return locale[ SHORT_DAYS[date.getDay()] ]; },
+	"D_": function(date, locale) { return locale[ FULL_DAYS[date.getDay()] ]; },
+	"M": function(date, locale) { return "" + (date.getMonth() + 1); },
+	"MM": function(date, locale) { return prefixZero(date.getMonth() + 1); },
+	"MMM": function(date, locale) { return locale[ SHORT_MONTHS[date.getMonth()] ]; },
+	"M_": function(date, locale) { return locale[ FULL_MONTHS[date.getMonth()] ]; },
+	"YY": function(date, locale) { return ("" + date.getFullYear()).slice(-2); },
+	"Y_": function(date, locale) { return "" + date.getFullYear(); },
+	// Intraday time
+	"H": function(date, locale) { return "" + date.getHours(); },
+	"H_": function(date, locale) { return prefixZero(date.getHours()); },
+	"h": function(date, locale) {
+		let temp = date.getHours() % 12;
+		return (temp === 0) ? "12" : "" + temp;
+	},
+	"h_": function(date, locale) {
+		let temp = date.getHours() % 12;
+		temp = (temp === 0) ? 12 : temp;
+		return prefixZero(temp);
+	},
+	"m": function(date, locale) { return "" + date.getMinutes(); },
+	"m_": function(date, locale) { return prefixZero(date.getMinutes()); },
+	"s": function(date, locale) { return "" + date.getSeconds(); },
+	"s_": function(date, locale) { return prefixZero(date.getSeconds()); },
+	"S": function(date, locale) { return ~~(date.getMilliseconds() / 100); },
+	"SS": function(date, locale) { return prefixZero(~~(date.getMilliseconds() / 10)); },
+	"S_": function(date, locale) { return prefixDoubleZero(date.getMilliseconds()); },
+	// AM/PM suffix
+	"A": function(date, locale) { return (date.getHours() < 12) ? locale["AM"] : locale["PM"]; },
+	"a": function(date, locale) { return (date.getHours() < 12) ? locale["am"] : locale["pm"]; }
+};
+
+/** @namespace
+*/
+let DateTime = {};
+
+/**
+* @type {string}
+* @private
+*/
+DateTime._dateTimePattern = "M/D/YY h:mm A";
+/**
+* @type {string}
+* @private
+*/
+DateTime._localeSetting = "en";
+/**
+* @type {Object.<string, string>}
+* @private
+*/
+DateTime._activeLocaleMap = null;
+/**
+* @type {Date}
+* @private
+*/
+DateTime._activeInput = null;
+
+
+/** @public
+* @function
+* @description Set the default date time format in formula.
+* @param {string=} format
+*/
+DateTime.setDateTimePattern = function(format) {
+	DateTime._dateTimePattern = format || "M/D/YY h:mm A";
+};
+/** @public
+* @function
+* @description Set the locale language for localization.
+* @param {string=} lang
+*/
+DateTime.setLocale = function(lang) {
+	let mainLang = ElfUtil.toLangString(lang);
+	DateTime._localeSetting = translation[mainLang] ? mainLang : "en";
+};
+
+/**
+* @public
+* @function
+* @description The TEXT function converts an date & time number since 1 Jan, 1900 into a text in customizable format. Default is YYYY-MM-DD HH:mm:ss.
+* @param  {number|string|Date} dateTimeNumber A date & time number since 1 Jan, 1900 or date & time text in format YYYY-MM-DDTHH:mm:ss
+* @param  {string=} dateTimeFormat A customized format of the result. Default format is M/D/YY h:mm A.
+* @param  {string=} timezone GMT (Greenwich Mean Time) or LOCAL (Local timezone). Default is GMT.
+* @return {string}
+* @example
+* ---------------------------------------------------------------------
+* | Group  | Character   | English Output                             |
+* ---------------------------------------------------------------------
+* | Year        | YY / yy     | 00 01 ... 16 17                       |
+* |             | YYYY / yyyy | 2000 2001 ... 2016 2017               |
+* | Month       | M           | 1 2 ... 11 12                         |
+* |             | MM          | 01 02 ... 11 12                       |
+* |             | MMM         | Jan Feb ... Nov Dec                   |
+* |             | MMMM        | January February ... November December|
+* | Day         | D / d       | 1 2 ... 30 31                         |
+* |             | DD / dd     | 01 02 ... 30 31                       |
+* |             | DDD / ddd   | Sun Mon ... Fri Sat                   |
+* |             | DDDD / dddd | Sunday Monday ... Friday Saturday     |
+* | Hour        | H           | 0 1 ... 22 23                         |
+* |             | HH          | 00 01 ... 22 23                       |
+* |             | h           | 1 2 ... 11 12                         |
+* |             | hh          | 01 02 ... 11 12                       |
+* | Minute      | m           | 0 1 ... 58 59                         |
+* |             | mm          | 00 01 ... 58 59                       |
+* | Second      | s           | 0 1 ... 58 59                         |
+* |             | ss          | 00 01 ... 58 59                       |
+* | Millisecond | S           | 0 1 ... 8 9                           |
+* |             | SS          | 00 01 ... 98 99                       |
+* |             | SSS         | 001 002 ... 998 999                   |
+* | AM/PM       | A           | AM PM                                 |
+* |             | a           | am pm                                 |
+* ---------------------------------------------------------------------
+*/
+DateTime.format = function(dateTimeNumber, dateTimeFormat, timezone) {
+	let date = null;
+	let dtTxt = ""; // new Date() is on par with Date.parse in term of performance.
+	let localTime = !!(timezone && timezone.toUpperCase() === "LOCAL");
+	if(typeof dateTimeNumber === "number") {
+		if(dateTimeNumber > 1e8) { // Maximum date is 100 millions and any number greater than that is assumed to be millisecond
+			date = new Date(dateTimeNumber); // convert milisecond
+		} else { // The given number is assumed to be in Excel format (i.e. integer represents date and fraction represents time)
+			// This number is a product of other formulas (e.g. TODAY(), NOW()), which are all local time.
+			date = DateTime.fromDateNumber(dateTimeNumber);
+			localTime = true; // Assume that the given date is already in local time
+		}
+	} else if(dateTimeNumber instanceof Date) {
+		// Monitor timestamp should pass the value as Date object
+		// IDN data should pass the value as Date object. E.g. CF_DATE, CF_TIME
+		date = new Date(dateTimeNumber); // Always clone the passing object as Date object is mutable
+	} else {
+		// Pass the value with string format, expected to be ISO8601 format (YYYY-MM-DDTHH:mm:ss)
+		dtTxt = dateTimeNumber + "";
+		let isISO8601 = dtTxt.match(/^\d{4}(-\d{2}(-\d{2}(T\d{2}\:\d{2}\:\d{2})?)?)?$/);
+		dtTxt = dtTxt.replace(/\-/g, "\/"); // Convert to YYYY/MM/DD HH:mm:ss (common for all browsers)
+		if(isISO8601) {
+			dtTxt = dtTxt.replace(/T/g, " "); // Convert to YYYY/MM/DD HH:mm:ss (common for all browsers)
+		}
+
+		date = new Date(dtTxt);
+	}
+
+	if(DateTime.isInvalidDate(date)) { // Invalid date
+		return dateTimeNumber || ""; // TODO: Check if we need to convert the original object to string
+	}
+
+	// Convert non-local time (GMT) to local time
+	if(!localTime) {
+		date.setTime(date.getTime() + date.getTimezoneOffset() * 60000);
+	}
+
+	return DateTime.formatDateObject(date, dateTimeFormat);
+};
+/** Format the Date object to specified format.
+* @public
+* @function
+* @param  {Date} date Date object
+* @param  {string=} dateTimeFormat Datetime format. Referred to TEXT function.
+* @return {string} Return empty string, if the given date object is invalid
+*/
+DateTime.formatDateObject = function(date, dateTimeFormat) {
+	if(DateTime.isInvalidDate(date)) { // Invalid date
+		return "";
+	}
+
+	if(!dateTimeFormat) {
+		dateTimeFormat = DateTime._dateTimePattern;
+	}
+
+	DateTime._activeInput = date;
+	DateTime._activeLocaleMap = translation[DateTime._localeSetting] || DateTimeLocale["en"];
+
+	let result = dateTimeFormat.replace(/D+|M+|Y+|H+|S+|A+|d+|m+|y+|h+|s+|a+|\[[^\]]*\]+/g, DateTime._parseDatePattern);
+	DateTime._activeInput = null;
+
+	return result;
+};
+
+/** @type {!Object.<string, boolean>}
+* @private
+*/
+DateTime._lowerCaseDatePatterns = {
+	"d": true,
+	"y": true
+};
+/**
+* @private
+* @function
+* @param  {string} match
+* @return {string}
+*/
+DateTime._parseDatePattern = function(match) {
+	let fchar = (match) ? match.charAt(0) : "";
+	if(fchar === "[") { // Static text
+		return match.substring(1, match.length - 1);
+	}
+
+	let parser = Parsers[match];
+	if(!parser) {
+		let mod = match;
+		if(DateTime._lowerCaseDatePatterns[fchar]) {
+			mod = match.toUpperCase();
+			fchar = fchar.toUpperCase();
+			parser = Parsers[mod];
+		}
+		if(!parser) {
+			mod = fchar + "_";
+			parser = Parsers[mod];
+		}
+	}
+	if(parser) {
+		return parser(DateTime._activeInput, DateTime._activeLocaleMap);
+	}
+	return match;
+};
+
+/** Check if the given date obj is valid without any automatic data type conversion.
+* @public
+* @function
+* @param  {Date} dateObj Date number since 1 Jan, 1900 (value is 1)
+* @return {boolean}
+*/
+DateTime.isValidDate = function(dateObj) {
+	if(dateObj) {
+		if(dateObj.getTime) {
+			let t = dateObj.getTime();
+			return t === t;
+		}
+	}
+	return false;
+};
+/** Check if the given date obj is invalid without any automatic data type conversion.
+* @public
+* @function
+* @param  {Date} dateObj Date number since 1 Jan, 1900 (value is 1)
+* @return {boolean}
+*/
+DateTime.isInvalidDate = function(dateObj) {
+	if(dateObj) {
+		if(dateObj.getTime) {
+			let t = dateObj.getTime();
+			return t !== t;
+		}
+	}
+	return true;
+};
+
+/** Convert the date number (Excel date format) since 1 Jan, 1900 (value is 1) to Date object.
+* @public
+* @function
+* @param  {number} dateNumber Date number since 1 Jan, 1900 (value is 1)
+* @return {!Date}
+* @see {@link DateTime#dateNumberToMs}
+* @see {@link DateTime#timeNumberToMs}
+*/
+DateTime.fromDateNumber = function(dateNumber) {
+	let datePart = DateTime.dateNumberToMs(dateNumber);
+	if(datePart === datePart) {
+		let timePart = DateTime.timeNumberToMs(dateNumber);
+		return new Date(datePart + timePart);
+	}
+	return new Date(NaN);
+};
+/** Convert the date number (Excel date format) to milliseconds. WARNING: This discards any intraday time information (keep only date part).
+* @public
+* @function
+* @param  {number} dateNumber Date number since 1 Jan, 1900 (value is 1)
+* @return {number} Returns NaN, if the given number is invalid. Otherwise, returns positive number in milliseconds
+* @see {@link DateTime#timeNumberToMs}
+* @see {@link DateTime#fromDateNumber}
+*/
+DateTime.dateNumberToMs = function(dateNumber) {
+	dateNumber = Math.floor(+dateNumber); // Remove the floating point to prevent calculation error
+	if(!dateNumber || dateNumber <= 0 || dateNumber === 60) { // Invalid input // 60 is 29 Feb 1900 that is not existing
+		return NaN;
+	}
+
+	let num = dateNumber - _DIFF_DAYS;
+	if(dateNumber < 60) {
+		num++; // +1 Before 1 Mar 1900 because there is not existing 29 Feb 1900 but existing in Window.
+	}
+	return num * MILLISECONDS_IN_DAY;
+};
+/** Convert the time number (Excel time format) with range between 0 and 1 to milliseconds. WARNING: This discards date and millisecond from the given number.
+* @public
+* @function
+* @param  {number} dateNumber Date number since 1 Jan, 1900 (value is 1)
+* @return {number}
+* @see {@link DateTime#dateNumberToMs}
+* @see {@link DateTime#fromDateNumber}
+*/
+DateTime.timeNumberToMs = function(dateNumber) {
+	if(typeof dateNumber !== "number") {
+		dateNumber = (+dateNumber);
+	}
+	let timeNumber = dateNumber - Math.floor(dateNumber);
+	if(!timeNumber) { // NaN or 0
+		return 0;
+	}
+	if(timeNumber < 0) {
+		timeNumber = -timeNumber;
+	}
+
+	let secondFromMidnight = Math.round(timeNumber * SECONDS_IN_DAY);
+	return secondFromMidnight * 1000;
+};
+
+/** Convert string or number to date object
+* @public
+* @param {string|number} dateInput
+* @return {Object}
+*/
+DateTime.toDateObject = function(dateInput) {
+	let date = null;
+	if(dateInput instanceof Date) {
+		date = dateInput;
+	} else if(typeof dateInput === "number") {
+		if(dateInput > 3e9 || dateInput <= 0) { // 3e9 milliseconds is Thu Feb 05 1970 00:20:00
+			date = new Date(dateInput); // convert milisecond
+		} else if(dateInput > 1e5) { // 1e5 days is Tue Oct 17 2243
+			// The given number is assumed to be second
+			date = new Date(dateInput * 1000);
+		} else {
+			// The given number is assumed to be in Excel format (i.e. integer represents date and fraction represents time)
+			// Excel stores dates as the number of days since January 0, 1900.
+			// This number is a product of other formulas (e.g. TODAY(), NOW()), which are all local time.
+			date = DateTime.fromDateNumber(dateInput);
+		}
+	} else if(!dateInput) {
+		date = new Date(NaN);
+	} else {
+		// Pass the value with string format, expected to be ISO8601 format (YYYY-MM-DDTHH:mm:ss)
+		let dtTxt = dateInput + "";
+		let isISO8601 = dtTxt.match(/^\d{4}(-\d{2}(-\d{2}(T\d{2}\:\d{2}\:\d{2})?)?)?$/);
+		dtTxt = dtTxt.replace(/\-/g, "\/"); // Convert to YYYY/MM/DD HH:mm:ss (common for all browsers)
+		if(isISO8601) {
+			dtTxt = dtTxt.replace(/T/g, " "); // Convert to YYYY/MM/DD HH:mm:ss (common for all browsers)
+		}
+
+		date = new Date(dtTxt);
+	}
+
+	return date;
+};
+
+/** Convert the JavaScript date object to the date number since 1 Jan, 1900 (value is 1). WARNING: This discards any intraday time information (keep only date part).
+* @public
+* @param  {Date} dateObj JavaScript date object
+* @return {number}
+*/
+DateTime.toDateNumber = function(dateObj) {
+	return DateTime._millisecondToDateNumber(Date.UTC(
+		dateObj.getUTCFullYear(),
+		dateObj.getUTCMonth(),
+		dateObj.getUTCDate()
+	));
+};
+/** Convert the JavaScript date object to the time number in a range between 0 and 1. WARNING: This discards date and millisecond from the given date object.
+* @public
+* @param  {Date} dateObj JavaScript date object
+* @return {number}
+*/
+DateTime.toTimeNumber = function(dateObj) {
+	return Date.UTC(
+		1970, 0, 1,
+		dateObj.getUTCHours(),
+		dateObj.getUTCMinutes(),
+		dateObj.getUTCSeconds()
+	) / MILLISECONDS_IN_DAY;
+};
+/** Convert the time in millisecond of JavaScript date object to date number since 1 Jan, 1900 (value is 1).
+* @private
+* @function
+* @param  {number} millisecond Milliseconds of JavaScript date object (UTC)
+* @return {number} Date number
+*/
+DateTime._millisecondToDateNumber = function(millisecond) {
+	millisecond = +millisecond;
+	if(millisecond !== millisecond || millisecond < _1_JAN_1900) { // Invalid input
+		return NaN;
+	} else {
+		let calDate = (millisecond / MILLISECONDS_IN_DAY) + _DIFF_DAYS;
+		if(millisecond < _1_MAR_1900) {
+			calDate--; // -1 before 1 Mar 1900 because there is not existing 29 Feb 1900 but existing in Window.
+		}
+		return calDate;
+	}
+};
+
+/** Returns YYYY-MM-DD (UTC)
+* @public
+* @function
+* @param  {Date} dateObj
+* @return {string}
+*/
+DateTime.toYYYYMMDD = function(dateObj) {
+	let str = dateObj ? dateObj.toJSON() : "";
+	if(str) {
+		return str.slice(0, 10);
+	}
+	return "";
+};
+
+
+export default DateTime;
+export { DateTime, MILLISECONDS_IN_DAY, SECONDS_IN_DAY };

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

@@ -0,0 +1,16 @@
+
+
+declare class Deferred {
+
+    constructor(resolveHandler?: ((...params: any[]) => any)|null, rejectHandler?: ((...params: any[]) => any)|null, ctx?: any);
+
+    public resolve(result?: any): void;
+
+    public reject(result?: any): void;
+
+    public isFulfilled(): boolean;
+
+}
+
+export default Deferred;
+export {Deferred};

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

@@ -0,0 +1,108 @@
+/** Deferred promise should be used when asynchronous method does not return promise object (e.g. typical AJAX calls, or native setTimeout()). In other words, deferred promise is used to allow any non-promise logics to be worked in promise pattern.
+* @constructor
+* @param {Function=} resolveHandler
+* @param {Function=} rejectHandler
+* @param {*=} ctx Context object that will be provided as the second parameter of the given handlers
+* @example
+* let def = new Deferred(handler);
+* setTimeout(def.resolve, 2000);
+* let def2 = new Deferred();
+* setTimeout(function() {
+*   def2.resolve();
+* }, 4000);
+*/
+let Deferred = function(resolveHandler, rejectHandler, ctx) {
+	this.resolve = this.resolve.bind(this);
+	this.reject = this.reject.bind(this);
+
+	if(typeof resolveHandler === "function") {
+		this._resolveHandler = resolveHandler;
+	}
+	if(typeof rejectHandler === "function") {
+		this._rejectHandler = rejectHandler;
+	}
+	if(ctx != null) {
+		this._ctx = ctx;
+	}
+	this.promise = new Promise((function(resolve, reject) {
+		this._resolve = resolve;
+		this._reject = reject;
+	}).bind(this));
+};
+/** @type {Promise<*>}
+* @public
+*/
+Deferred.prototype.promise = null;
+/** @type {Function}
+* @private
+*/
+Deferred.prototype._resolve = null; // Always supplied from Promise object
+/** @type {Function}
+* @private
+*/
+Deferred.prototype._reject = null; // Always supplied from Promise object
+/** @type {Function}
+* @private
+*/
+Deferred.prototype._resolveHandler = null;
+/** @type {Function}
+* @private
+*/
+Deferred.prototype._rejectHandler = null;
+/** Context object that will be provided as the second parameter of the given handlers
+* @type {*}
+* @private
+*/
+Deferred.prototype._ctx = null;
+/** @type {boolean}
+* @private
+*/
+Deferred.prototype._fulfilled = false;
+
+/** @public
+* @param {*=} result
+*/
+Deferred.prototype.resolve = function(result) {
+	if(this._resolve) { // Promise can be resolved only once
+		if(this._resolveHandler) {
+			let handlerRes = this._resolveHandler(result, this._ctx || this);
+			if(handlerRes != null) {
+				result = handlerRes;
+			}
+		}
+		this._resolve(result); // WARNING: Synchronous call. The standard promise behavior requires asynchronous response.
+		this._finally();
+	}
+};
+/** @public
+* @param {*=} result
+*/
+Deferred.prototype.reject = function(result) {
+	if(this._reject) { // Promise can be resolved only once
+		if(this._rejectHandler) {
+			let handlerRes = this._rejectHandler(result, this._ctx || this);
+			if(handlerRes != null) {
+				result = handlerRes;
+			}
+		}
+		this._reject(result); // WARNING: Synchronous call
+		this._finally();
+	}
+};
+/** @public
+* @return {boolean}
+*/
+Deferred.prototype.isFulfilled = function() {
+	return this._fulfilled;
+};
+
+/** @private */
+Deferred.prototype._finally = function() {
+	// Release all references to avoid memory leak
+	this._fulfilled = true;
+	this._ctx = this._resolveHandler = this._rejectHandler = null;
+	this._resolve = this._reject = null;
+};
+
+export default Deferred;
+export {Deferred};

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

@@ -0,0 +1,20 @@
+
+
+declare class Delay {
+
+    constructor(ms?: number|null, ctx?: any);
+
+    public static for(ms?: number|null, ctx?: any): Delay|null;
+
+    public resolve(): void;
+
+    public reject(): void;
+
+    public isTimeout(): boolean;
+
+}
+
+declare function promiseDelay(ms?: number|null, ctx?: any): Promise<any>|null;
+
+export default Delay;
+export {Delay, promiseDelay};