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

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

@@ -0,0 +1,432 @@
+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=false
+* @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
+};
+
+/* eslint-enaable */
+
+/** @public
+* @param {string} formatType
+* @return {string}
+*/
+var toDateTimeType = function(formatType) {
+	if (formatType != null && DATE_TIME_TYPE[formatType.toUpperCase()]) {
+		return DATE_TIME;
+	}
+	return "";
+};
+
+/** @constructor
+* @param {FieldFormatter~Options=} options
+* @example
+* var ff = new FieldFormatter();
+* ff.format(anyValue);
+* ff.getOptions(); // For serialization
+*/
+var 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();
+		var currentMidnight = FieldFormatter._lastMidnight.valueOf();
+		var 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;
+	}
+
+	var 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" : "");
+	}
+
+	var formatType = /** @type{string} */(options["formatType"] || options["type"]);
+	var fieldDataType = options["fieldDataType"]; // Keep backward compatibility
+	this._userFormatType = formatType || fieldDataType;
+
+	formatType = toDateTimeType(this._userFormatType);
+
+	val = formatType ? formatType : this._userFormatType;
+	if(val) {
+		this.setFormatType(val);
+	}
+	var dtf = options["dateTimeFormat"];
+	var utc = options["useUTCTime"];
+	if(utc != null || dtf != null) {
+		this.setDateTimeMeta(
+			dtf || "MM/DD/YYYY",
+			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
+	options["dateTimeFormat"] = this._dateTimeFormat;
+	options["useUTCTime"] = (this._timeZone == "GMT");
+	return options;
+};
+/** @public
+* @return {string}
+*/
+FieldFormatter.prototype.getField = function() {
+	return this._field;
+};
+
+/** @public
+* @return {FieldFormatter}
+*/
+FieldFormatter.prototype.clone = function() {
+	var 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() {
+	var 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
+			var 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.
+		var sec = +val; // Date object can be converted to number
+		if(sec !== sec) { // NaN checking
+			return val; // WARNING: val could be number
+		}
+
+		var 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")) {
+				var 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, this._timeZone);
+};
+/** @private
+* @param {number|string|Date} val
+* @param {Object} rowData
+* @return {string}
+*/
+FieldFormatter.prototype._formatNumber = function(val, rowData) {
+	var 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,48 @@
+import { parseCondition } from "./Util.js";
+import { DateTime } from "./DateTime.js";
+import { FilterOperators } from "./FilterOperators.js";
+
+declare namespace FilterBuilder {
+
+    type Options = {
+        field: string,
+        formatter?: ((...params: any[]) => any),
+        formattedField?: string
+    };
+
+    type Condition = any[];
+
+    type Conditions = (FilterBuilder.Condition)[];
+
+}
+
+declare class FilterBuilder {
+
+    constructor(options?: FilterBuilder.Options);
+
+    public reset(): void;
+
+    public init(options?: FilterBuilder.Options): void;
+
+    public setFieldDefinition(fieldName: string, formatter?: ((...params: any[]) => any), formattedField?: string): void;
+
+    public setDataAccessors(rawDataAccessor?: ((...params: any[]) => any), formattedDataAccessor?: ((...params: any[]) => any)): void;
+
+    public addCondition(oper: string, value: string|number, connector?: string): boolean;
+
+    public addConditions(conditions: FilterBuilder.Conditions): number;
+
+    public getConditions(): FilterBuilder.Conditions;
+
+    public buildFilter(): ((...params: any[]) => any);
+
+    public buildMonitorFilter(filterStr: string, field: string, formatter?: ((...params: any[]) => any), formattedField?: string): ((...params: any[]) => any);
+
+    public parse(condition: any, field?: string, formatter?: ((...params: any[]) => any), formattedField?: string, rawDataAccessor?: ((...params: any[]) => any), formattedDataAccessor?: ((...params: any[]) => any)): ((...params: any[]) => any);
+
+}
+
+declare function buildFilterFromObjectMap(obj: any, field: string, rawDataAccessor?: ((...params: any[]) => any)): ((...params: any[]) => any);
+
+export default FilterBuilder;
+export { FilterBuilder, buildFilterFromObjectMap };