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

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

@@ -0,0 +1,10 @@
+
+
+declare namespace Ext {
+
+    function inherits(childCtor: ((...params: any[]) => any)|null, parentCtor: ((...params: any[]) => any)|null): void;
+
+}
+
+export default Ext;
+export {Ext};

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

@@ -0,0 +1,52 @@
+/** Provide ability for prototype based Class to inherits another class
+* @namespace
+* @example
+* let BaseClass = function() {};
+* BaseClass.prototype.method = function() {};
+* BaseClass.prototype._member = 1;
+* let DerivedClass = function() {};
+* Ext.inherits(DerivedClass, BaseClass); // Derived class will have methods and members of the base class
+* // To call base class method
+* DeriveClass["base"](this, "methodName", ...params);
+*/
+let Ext = {};
+
+/** @public
+* @function
+* @param {Function} childCtor
+* @param {Function} parentCtor
+*/
+Ext.inherits = function (childCtor, parentCtor) {
+	/** @constructor
+* @ignore
+*/
+	function tempCtor() { }
+	tempCtor.prototype = parentCtor.prototype;
+	childCtor.prototype = new tempCtor();
+	childCtor.prototype.constructor = childCtor;
+
+	/** Calls superclass constructor/method. <br>
+* This function is only available if you use goog.inherits to <br>
+* express inheritance relationships between classes. <br>
+* NOTE: This is a replacement for goog.base and for superClass_ <br>
+* property defined in childCtor.
+* @param {!Object} me Should always be "this".
+* @param {(string|null)=} methodName The method name to call. Calling superclass constructor can be done with the special string 'constructor'.
+* @param {...*} var_args The arguments to pass to superclass <br>
+* method/constructor.
+* @return {*} The return value of the superclass method/constructor.
+*/
+	childCtor["base"] = function(me, methodName, var_args) {
+		if(!methodName) { methodName = 'constructor'; }
+		// Copying using loop to avoid deop due to passing arguments object to function. This is faster in many JS engines as of late 2014.
+		let len = arguments.length;
+		let args = new Array(len); // http://jsperf.com/creating-an-array
+		for (let i = 2; i < len; i++) {
+			args[i - 2] = arguments[i];
+		}
+		return parentCtor.prototype[methodName].apply(me, args);
+	};
+};
+
+export default Ext;
+export {Ext};

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

@@ -0,0 +1,55 @@
+import { NumberFormatter } from "./NumberFormatter.js"; // eslint-disable-line
+import { DateTime } from "./DateTime.js";
+
+declare namespace FieldFormatter {
+
+    type Options = {
+        formatType?: string|null,
+        type: string,
+        field?: string|null,
+        fieldDataType?: string|null,
+        dateTimeFormat?: string|null,
+        useUTCTime?: boolean|null,
+        idnSource?: string|null
+    };
+
+}
+
+declare class FieldFormatter {
+
+    constructor(options?: FieldFormatter.Options|null);
+
+    public init(options?: FieldFormatter.Options|null): void;
+
+    public getOptions(options?: any): any;
+
+    public getField(): string;
+
+    public clone(): FieldFormatter|null;
+
+    public setFormatType(type: string): void;
+
+    public setField(field: string, combinedField?: string|null, formattedField?: string|null): void;
+
+    public setDateTimeMeta(format: string, gmtTimeZone?: boolean|null, inputSource?: string|null, lang?: string|null): void;
+
+    public setDateFormatter(func: ((...params: any[]) => any)|null): void;
+
+    public setNumberFormatter(formatter: ((...params: any[]) => any)|NumberFormatter|null): void;
+
+    public format(data: any): string;
+
+    public formatRowData(rowData: any): string;
+
+    public formatValue(val: any): string;
+
+}
+
+declare const DATE_TIME: string;
+
+declare function toDateTimeType(formatType: string): string;
+
+declare function fieldDataType(options?: any): any;
+
+export default FieldFormatter;
+export {FieldFormatter, DATE_TIME, toDateTimeType};

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

@@ -0,0 +1,440 @@
+import { NumberFormatter } from "./NumberFormatter.js"; // eslint-disable-line
+import { DateTime } from "./DateTime.js";
+
+/** @typedef {Object} FieldFormatter~Options
+* @description Options that can be provided at the initialization phase
+* @property {string=} formatType="number" Available Values are: number, percent, datetime, freetext (mixed), or formula
+* @property {string} type Alias to formatType
+* @property {string=} field
+* @property {string=} fieldDataType Deprecated. Alias to formatType
+* @property {string=} dateTimeFormat
+* @property {boolean=} useUTCTime=true If disable, time will be shown in local time format
+* @property {string=} idnSource
+*/
+
+/* eslint-disable */
+
+/** @public
+* @type {string}
+*/
+const DATE_TIME = "datetime";
+
+const DATE_TIME_TYPE = {
+	"DATE": true,
+	"TIME": true,
+	"DATETIME": true,
+	"DATE-TIME": true,
+	"TIME-DATE": true
+};
+
+const DEFAULT_DATE_TIME_FORMAT = "MM/DD/YYYY";
+
+/* eslint-enaable */
+
+/** @public
+* @param {string} formatType
+* @return {string}
+*/
+let toDateTimeType = function(formatType) {
+	if (formatType != null && DATE_TIME_TYPE[formatType.toUpperCase()]) {
+		return DATE_TIME;
+	}
+	return "";
+};
+
+/** @constructor
+* @param {FieldFormatter~Options=} options
+* @example
+* let ff = new FieldFormatter();
+* ff.format(anyValue);
+* ff.getOptions(); // For serialization
+*/
+let FieldFormatter = function(options) {
+	this["format"] = this.format = this.format.bind(this); // Always export bound format method
+
+	FieldFormatter._startMidnightInterval();
+	this.init(options);
+};
+
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._field = "";
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._formattedField = "";
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._combinedField = "";
+
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._formatType = "number"; // number, percent, datetime, freetext (mixed), or formula
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._userFormatType = "";
+/** @type {boolean}
+* @private
+*/
+FieldFormatter.prototype._mixedTypeInput = false; // Input can be either string or number in the same column
+
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._dateTimeFormat = "";
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._idnSource = "";
+/** @type {string}
+* @private
+*/
+FieldFormatter.prototype._timeZone = "GMT"; // "GMT" or "LOCAL"
+
+/** Date formatter
+* @type {Function}
+* @private
+*/
+FieldFormatter.prototype._df = null;
+/** Number formatter
+* @type {Function}
+* @private
+*/
+FieldFormatter.prototype._nf = null;
+
+/** Date past midnight 00:00:00 (UTC)
+* @type {Date}
+* @private
+*/
+FieldFormatter._lastMidnight = null;
+/** Update date past midnight
+* @private
+* @function
+*/
+FieldFormatter._updateMidnight = function() {
+	FieldFormatter._lastMidnight = new Date();
+	FieldFormatter._lastMidnight.setUTCHours(0, 0, 0, 0);
+};
+/** Start updating interval, if the interval has not been started
+* @private
+* @function
+*/
+FieldFormatter._startMidnightInterval = function() {
+	if(!FieldFormatter._lastMidnight) {
+		FieldFormatter._updateMidnight();
+		let currentMidnight = FieldFormatter._lastMidnight.valueOf();
+		let timeUntilNextUpdate = currentMidnight + 86405000 - (new Date().valueOf()); // delay to the next midnight + 5sec
+		setTimeout(FieldFormatter._setMidnightInterval, timeUntilNextUpdate);
+	}
+};
+/** WARNING: For internal use only
+* @private
+* @function
+*/
+FieldFormatter._setMidnightInterval = function() {
+	setInterval(FieldFormatter._updateMidnight, 86400000); // 24 hours
+};
+
+
+/** @public
+* @param {FieldFormatter~Options=} options
+*/
+FieldFormatter.prototype.init = function(options) { // deserialize
+	if(!options) {
+		return;
+	}
+
+	let val = options["field"];
+	if(val) {
+		// DateTime pairs come from the JET's user settings
+		// Datetime paired will have special column that suffix with "_COMBINED"
+		this.setField(val); // , (this._dateTimePairs[field]) ? field + "_COMBINED" : "");
+	}
+
+	let formatType = /** @type{string} */(options["formatType"] || options["type"]);
+	let fieldDataType = options["fieldDataType"]; // Keep backward compatibility
+	this._userFormatType = formatType || fieldDataType;
+
+	formatType = toDateTimeType(this._userFormatType);
+
+	val = formatType ? formatType : this._userFormatType;
+	if(val) {
+		this.setFormatType(val);
+	}
+	let dtf = options["dateTimeFormat"];
+	let utc = options["useUTCTime"];
+	if(utc != null || dtf != null) {
+		this.setDateTimeMeta(
+			dtf,
+			utc,
+			(options["idnSource"]) ? "idn" : "" // IDN Source will send time in second instead of millisecond.
+		);
+	}
+
+	if(this._formatType === DATE_TIME) { // WARNING: Beware of case sensitivity
+		if(!this._df) {
+			this._df = DateTime.format;
+		}
+	}
+};
+/** @public
+* @param {Object=} options
+* @return {!Object}
+*/
+FieldFormatter.prototype.getOptions = function(options) { // serialize
+	if(!options) { options = {}; }
+
+	options["field"] = this._field;
+	options["formatType"] = this._userFormatType ? this._userFormatType : this._formatType; // WARNING: Beware of case sensitivity
+	if(toDateTimeType(options["formatType"]) == DATE_TIME){
+		if(this._dateTimeFormat && this._dateTimeFormat !== DEFAULT_DATE_TIME_FORMAT) {
+			options["dateTimeFormat"] = this._dateTimeFormat;
+		}
+		if(this._timeZone !== "GMT") {
+			options["useUTCTime"] = false;
+		} // useUTCTime by default, otherwise is use local
+	}
+	return options;
+};
+/** @public
+* @return {string}
+*/
+FieldFormatter.prototype.getField = function() {
+	return this._field;
+};
+
+/** @public
+* @return {FieldFormatter}
+*/
+FieldFormatter.prototype.clone = function() {
+	let newFF = new FieldFormatter();
+	newFF._field = this._field;
+	newFF._formattedField = this._formattedField;
+	newFF._combinedField = this._combinedField;
+
+	newFF._formatType = this._formatType;
+	newFF._mixedTypeInput = this._mixedTypeInput;
+
+	newFF._dateTimeFormat = this._dateTimeFormat;
+	newFF._idnSource = this._idnSource;
+	newFF._timeZone = this._timeZone;
+
+	newFF._df = this._df;
+	newFF._nf = this._nf;
+	return newFF;
+};
+
+/** @public
+* @param {string} type Possible values are number, percent, datetime, freetext, and formula
+*/
+FieldFormatter.prototype.setFormatType = function(type) {
+	this._formatType = type.toLowerCase(); // WARNING: Beware of case sensitivity
+	this._mixedTypeInput = (this._formatType == "freetext" || this._formatType == "formula");
+};
+/** @public
+* @param {string} field
+* @param {string=} combinedField
+* @param {string=} formattedField
+*/
+FieldFormatter.prototype.setField = function(field, combinedField, formattedField) {
+	this._field = field;
+	this._formattedField = (formattedField) ? formattedField : field + "_FORMATTED";
+	this._combinedField = combinedField || "";
+};
+/** @public
+* @param {string} format
+* @param {boolean=} gmtTimeZone
+* @param {string=} inputSource
+* @param {string=} lang
+*/
+FieldFormatter.prototype.setDateTimeMeta = function(format, gmtTimeZone, inputSource, lang) {
+	this._dateTimeFormat = format || "";
+	this._timeZone = (gmtTimeZone !== false) ? "GMT" : "LOCAL";
+	this._idnSource = (inputSource && inputSource.toLowerCase() == "idn") ? "idn" : "";
+	DateTime.setLocale(lang);
+};
+/** @public
+* @param {Function} func The given function should take a value and return string
+*/
+FieldFormatter.prototype.setDateFormatter = function(func) {
+	this._df = func;
+};
+/** @public
+* @param {Function|NumberFormatter} formatter The given function should take a value and return string
+*/
+FieldFormatter.prototype.setNumberFormatter = function(formatter) {
+	if(formatter) {
+		if(typeof formatter === "function") {
+			this._nf = formatter;
+		} else if(typeof formatter["format"] === "function") {
+			this._nf = formatter["format"];
+		}
+	} else {
+		this._nf = null;
+	}
+};
+
+FieldFormatter.prototype.getProperties = function() {
+	let obj = {
+		"field": this._field,
+		"formattedField": this._formattedField,
+		"combinedField": this._combinedField,
+		"type": this._formatType
+	};
+
+	if(this._formatType === DATE_TIME) { // WARNING: Beware of case sensitivity
+		obj["dateTimeFormat"] = this._dateTimeFormat;
+		obj["timeZone"] = this._timeZone;
+		obj["idnSource"] = this._idnSource;
+	}
+
+	return obj;
+};
+
+
+/** @public
+* @param {*} data This can be row data (Object} or any other value
+* @return {string}
+*/
+FieldFormatter.prototype.format = function(data) {
+	if(data) {
+		if(typeof data == "object") {
+			if(!(data instanceof Date)) {  // Array or literal object
+				return this.formatRowData(data);
+			}
+		}
+	}
+	return this._format(data, null);
+};
+/** @public
+* @param {Object} rowData
+* @return {string}
+*/
+FieldFormatter.prototype.formatRowData = function(rowData) {
+	return rowData ? this._format(rowData[this._field], rowData) : "";
+};
+/** @public
+* @param {*} val
+* @return {string}
+*/
+FieldFormatter.prototype.formatValue = function(val) {
+	return this._format(val, null);
+};
+
+
+/** @private
+* @param {*} val
+* @param {Object} rowData
+* @return {string}
+*/
+FieldFormatter.prototype._format = function(val, rowData) {
+	if(!val) {
+		if(val !== 0) {
+			return "";
+		}
+	}
+
+	if(this._formatType == DATE_TIME) {
+		return this._formatDateTime(val, rowData);
+	}
+
+	if(this._mixedTypeInput) { // Free text and Formula
+		if(typeof val != "number") {
+			return (typeof val != "string") ? val + "" : val;
+		}
+	}
+
+	if(this._nf) { // Number formatter will override any default field format
+		if(typeof val != "number") { // string
+			let num = (+val); // Only convertible value will be formatted by the number formatter
+			return (num === num) ? this._nf(num) : val + "";
+		}
+
+		return this._nf(val);
+	}
+
+	if(this._mixedTypeInput) { // Free text and formula
+		if(this._formatType == "formula") { // Remove small fraction (e.g. 3.0000000001)
+			return (Math.round(val * 1000000) / 1000000) + ""; // Round to seven digit precision
+		}
+		return val + "";
+	}
+
+	// Only number and percent formatType can reach here at this point
+	return this._formatNumber(val, rowData);
+};
+/** @private
+* @param {number|string|Date} val
+* @param {Object} rowData
+* @return {string}
+*/
+FieldFormatter.prototype._formatDateTime = function(val, rowData) {
+	if(!this._df) { return ""; }
+	if(this._idnSource) { // IDN Source will send time in second instead of millisecond.
+		let sec = +val; // Date object can be converted to number
+		if(sec !== sec) { // NaN checking
+			return val; // WARNING: val could be number
+		}
+
+		let cmbValue = (rowData && this._combinedField) ? +rowData[this._combinedField] : NaN;
+		if(cmbValue === cmbValue) { // Combined value is not NaN
+			sec = cmbValue;
+		} else if(sec < 86400) { // No paired date and sec < 24 hours -> this is a time within this day
+			sec += FieldFormatter._lastMidnight.valueOf() / 1000;
+		} else { // No paired sec. Date need to add for timezone
+			if((this._field !== "NEWS_TIME") && (this._timeZone === "LOCAL")) {
+				let d = new Date(sec * 1000); // Need to know the timezone of given date
+				sec += d.getTimezoneOffset() * 60;
+			}
+		}
+		val = new Date(sec * 1000); // Convert real-time raw data (second) to millisecond
+	}
+	return this._df(val, this._dateTimeFormat || DEFAULT_DATE_TIME_FORMAT, this._timeZone);
+};
+/** @private
+* @param {number|string|Date} val
+* @param {Object} rowData
+* @return {string}
+*/
+FieldFormatter.prototype._formatNumber = function(val, rowData) {
+	let ff;
+	if(rowData) {
+		ff = rowData[this._formattedField];
+		if(!ff) { // null, undefined, empty string, zero, or NaN
+			if(ff === null && val === 0) { // +0 case
+				return ""; // Unformatted value of +0 should be blank
+			}
+			ff = val; // As opposed to formatted value, raw value may exist (i.e. combined fields)
+		}
+	} else {
+		ff = val; // string|number|Date
+	}
+	if(this._formatType == "number") {
+		if(typeof ff == "string" && ff.indexOf(",") >= 0) {
+			// Remove the 1000 separator for the formatted numbers from JET.Quote
+			return ff.replace(/,/g, '');
+		}
+	} else if(this._formatType == "percent") {
+		if(typeof ff == "string") {
+			if (ff.lastIndexOf("%") < 0 && (+ff) !== 0) { // ff could be "   " (empty spaces)
+				return ff + " %";
+			}
+		} else if(typeof ff == "number") {
+			if(ff === ff) { // ff is not NaN
+				return ff + " %";
+			}
+			return "#INVALID";
+		}
+	}
+	if(!ff) { // null, undefined, empty string, zero, or NaN
+		return (ff === 0) ? "0" : "";
+	}
+	return ff; // WARNING: This could be some Date object
+};
+
+export default FieldFormatter;
+export {FieldFormatter, DATE_TIME, toDateTimeType};

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

@@ -0,0 +1,54 @@
+import { FilterOperators, OperatorFunctions } from "./FilterOperators.js";
+import { ExpressionParser } from "./ExpressionParser.js";
+
+declare namespace FilterBuilder {
+
+    type Options = {
+        field?: (string|null)|null,
+        formatter?: ((...params: any[]) => any)|null,
+        formattedField?: string|null,
+        useUTCTime?: boolean|null,
+        rawDataAccessor?: ((...params: any[]) => any)|null,
+        formattedDataAccessor?: ((...params: any[]) => any)|null
+    };
+
+    type Condition = any[]|null;
+
+    type Conditions = (FilterBuilder.Condition)[]|null;
+
+}
+
+declare class FilterBuilder {
+
+    constructor(options?: FilterBuilder.Options|null);
+
+    public reset(): void;
+
+    public init(options?: FilterBuilder.Options|null): void;
+
+    public setFieldDefinition(fieldName: string, formatter?: ((...params: any[]) => any)|null, formattedField?: string|null): void;
+
+    public setDefaultUTCUsage(useUTCTime: boolean): void;
+
+    public setDataAccessors(rawDataAccessor?: ((...params: any[]) => any)|null, formattedDataAccessor?: ((...params: any[]) => any)|null): void;
+
+    public addCondition(oper: string, value: string|number|boolean|Date|null, connector?: string|null, useUTCTime?: boolean|null): boolean;
+
+    public addConditions(conditions: FilterBuilder.Conditions|null): number;
+
+    public getConditions(): FilterBuilder.Conditions|null;
+
+    public buildFilter(): ((...params: any[]) => any)|null;
+
+    public buildMonitorFilter(filterStr: string, field: string, formatter?: ((...params: any[]) => any)|null, formattedField?: string|null): ((...params: any[]) => any)|null;
+
+    public parse(condition: any, field?: string|null, formatter?: ((...params: any[]) => any)|null, formattedField?: string|null, rawDataAccessor?: ((...params: any[]) => any)|null, formattedDataAccessor?: ((...params: any[]) => any)|null): ((...params: any[]) => any)|null;
+
+}
+
+declare function stringToDateObject(str: any): any;
+
+declare function buildFilterFromObjectMap(obj: any, field: string, rawDataAccessor?: ((...params: any[]) => any)|null): ((...params: any[]) => any)|null;
+
+export default FilterBuilder;
+export { FilterBuilder, buildFilterFromObjectMap, stringToDateObject };