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

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

@@ -0,0 +1,528 @@
+
+/** @typedef {Object} NumberFormatter~Options
+* @description Options that can be provided at the initialization phase
+* @property {string=} formatType Supported value "number", "scaled", "scaledvalue" or "percent"
+* @property {string} type Alias to formatType
+* @property {boolean=} precisionEnabled=true
+* @property {number=} decimalPlaces=2
+* @property {boolean=} plusSign=false
+* @property {boolean=} separator=false
+* @property {boolean=} percentSign=false
+* @property {string=} scalingUnit "b" | "m"
+* @property {boolean=} multiplyBy100=false
+* @property {boolean=} mutiplyBy100=false Alias of multiplyBy100
+*/
+
+/** @private
+* @function
+* @param {number} num Absolute number
+* @return {number}
+*/
+let _multiplyByHundred = function(num) {
+	let intPart = num | 0;
+	if(num > intPart) {
+		let str = num + "";
+		let at = str.indexOf(".");
+		let fracStr = str.slice(at + 1) + "00";
+		return +(str.slice(0, at) + fracStr.slice(0, 2) + "." + fracStr.slice(2));
+	}
+	return num * 100;
+};
+
+/** NumberFormatter provides a way to format the given number quickly.
+* @constructor
+* @param {NumberFormatter~Options=} options
+* @example
+* let options = {
+*  "precisionEnabled": false, // Default is leaving precision as is
+*  "decimalPlaces": 2, // Take effect only precisionEnabled === true
+*  "plusSign": false, // Plus sign prefixing
+*  "separator": false, // Comma separated
+*  "percentSign": false,
+*  "scalingUnit": "", // "b"|"m"
+*  "multiplyBy100": false
+*};
+* let nf = new NumberFormatter(options);
+* nf.format(123); // "123"
+* nf.format(-456.789); // "-456.789"
+* nf.getOptions(); // For serialization
+*/
+let NumberFormatter = function (options) {
+	this["format"] = this.format = this.format.bind(this);
+
+	this.init(options);
+};
+
+/** @type {Array.<number>}
+* @private
+*/
+NumberFormatter._denominator = [1, 10, 100, 1000, 10000, 100000, 1e6, 1e7, 1e8, 1e9];
+/** @type {Array.<string>}
+* @private
+*/
+NumberFormatter._zeroes = ["", "0", "00", "000", "0000", "00000", "000000", "0000000", "00000000", "000000000", "0000000000"];
+
+/** @type {number}
+* @private
+*/
+NumberFormatter.prototype._precision = 2;
+/** @type {string}
+* @private
+*/
+NumberFormatter.prototype._sepChar = ",";
+/** @type {string}
+* @private
+*/
+NumberFormatter.prototype._percentChar = " %";
+
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._precisionEnabled = false;
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._separatorEnabled = false;
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._percentSignEnabled = false;
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._percentFormatEnabled = false;
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._plusSignEnabled = false;
+/** @type {boolean}
+* @private
+*/
+NumberFormatter.prototype._multiplyBy100Enabled = false;
+/** @type {string}
+* @private
+*/
+NumberFormatter.prototype._scaler = "";
+
+
+/** @public
+* @param {NumberFormatter~Options=} options
+*/
+NumberFormatter.prototype.init = function(options) { // deserialize
+	if(!options) {
+		return;
+	}
+
+	let formatType = /** @type{string} */(options["formatType"] || options["type"]);
+
+	// Note that precision will not be used in scaledValue mode
+	let val = options["precisionEnabled"];
+	if(val != null && val !== "") {
+		this._precisionEnabled = val ? true : false;
+	} else {
+		this._precisionEnabled = true; // If it is initialized this way, precision is enabled by default to increase the ease of use
+	}
+
+	val = options["decimalPlaces"];
+	if(val != null && val !== "") {
+		this._precision = (typeof val == "number") ? val : 2;
+	}
+
+	val = options["plusSign"];
+	if(val != null && val !== "") {
+		this._plusSignEnabled = val ? true : false;
+	}
+
+	val = options["separator"];
+	if(val != null && val !== "") {
+		this._separatorEnabled = val ? true : false;
+	}
+
+	this.enableMillionScaling(false);
+	// Only enable scaling mode when format type is scaled
+	if(formatType === "scaled" || formatType === "scaledvalue") { // WARNING: Beware of case sensitivity
+		val = options["scalingUnit"];
+		if(val != null && val !== "") {
+			if(val && typeof val == "string") {
+				val = val.charAt(0).toLowerCase();
+				if(val == "b") {
+					this.enableBillionScaling();
+				} else if (val == "m") {
+					this.enableMillionScaling();
+				}
+			}
+		} else {
+			this.enableMillionScaling();
+		}
+	}
+
+	if(formatType === "percent") {
+		val = options["percentSign"];
+		if(val != null && val !== "") {
+			this._percentSignEnabled = val ? true : false;
+		} else {
+			this._percentSignEnabled = false;
+		}
+
+		val = options["multiplyBy100"];
+		if(val != null && val !== "") {
+			this._multiplyBy100Enabled = val ? true : false;
+		} else {
+			// Keep this typo alias to preserve backward compatibility
+			val = options["mutiplyBy100"];
+			if(val != null && val !== "") {
+				this._multiplyBy100Enabled = val ? true : false;
+			}
+		}
+	} else {
+		this._percentSignEnabled = this._multiplyBy100Enabled = false;
+	}
+};
+
+/** @public
+*/
+NumberFormatter.prototype.resetToDefaults = function () {
+	this._precisionEnabled = false;
+	this._precision = 2;
+	this._plusSignEnabled = false;
+	this._separatorEnabled = false;
+	this._percentSignEnabled = false;
+	this._scaler = '';
+	this._multiplyBy100Enabled = false;
+};
+
+/** @public
+* @function
+* @param {string} str
+* @param {number} precision
+* @return {string}
+* @example
+* NumberFormatter.padDecimalPartWithZeroes("1", 2); // "1.00"
+* NumberFormatter.padDecimalPartWithZeroes("1.", 2); // "1.00"
+* NumberFormatter.padDecimalPartWithZeroes("1.0", 2); // "1.00"
+* NumberFormatter.padDecimalPartWithZeroes("1.000", 2); // "1.000"
+*/
+NumberFormatter.padDecimalPartWithZeroes = function (str, precision) {
+	let dp = str.lastIndexOf(".");
+	if (dp >= 0) {
+		let decimalPlace = str.length - dp - 1;
+		if (decimalPlace < precision) {
+			str += NumberFormatter._zeroes[precision - decimalPlace];
+		}
+	} else {
+		str += "." + NumberFormatter._zeroes[precision];
+	}
+	return str;
+};
+/** @public
+* @function
+* @param {number} num
+* @return {number}
+* @example
+* NumberFormatter.multiplyByHundred(1); // 1
+* NumberFormatter.multiplyByHundred(1.1); // 110
+* NumberFormatter.multiplyByHundred(1.21); // 121
+* NumberFormatter.multiplyByHundred(1.321); // 132.1
+* NumberFormatter.multiplyByHundred(-1.4321); // -143.21
+*/
+NumberFormatter.multiplyByHundred = function (num) {
+	if(num < 0) {
+		return -(_multiplyByHundred(-num));
+	}
+	return _multiplyByHundred(num);
+};
+
+
+/** @public
+* @param {Object=} options
+* @return {!Object}
+*/
+NumberFormatter.prototype.getOptions = function(options) { // serialize
+	if(!options) { options = {}; }
+
+	let formatType = options["formatType"];
+
+	if(this._precisionEnabled !== true) {
+		options["precisionEnabled"] = this._precisionEnabled; // Default in init
+	}
+
+	if(this._precision !== 2) {
+		options["decimalPlaces"] = this._precision;
+	}
+
+	if(this._plusSignEnabled !== false) {
+		options["plusSign"] = this._plusSignEnabled;
+	}
+
+	if(this._separatorEnabled !== false) {
+		options["separator"] = this._separatorEnabled;
+	}
+
+	if(formatType === "scaled" || formatType === "scaledvalue") {
+		let su = "";
+		if(this._scaler == "b") {
+			su = "billion";
+			options["scalingUnit"] = su;
+		} // We didn't return default value (million) for clean up getConfigObject
+	}
+
+	if(formatType === "percent") {
+		if(this._percentSignEnabled !== false) {
+			options["percentSign"] = this._percentSignEnabled;
+		}
+		if(this._multiplyBy100Enabled !== false) {
+			options["multiplyBy100"] = this._multiplyBy100Enabled;
+		}
+	}
+	return options;
+};
+
+/** @public
+* @param {number} origVal
+* @return {string}
+*/
+NumberFormatter.prototype.format = function(origVal) {
+	if(!origVal) {
+		if(origVal !== 0) {
+			return ""; // Invalid value will be formatted as empty
+		}
+	}
+	if(typeof origVal !== "number") {
+		origVal = Number(origVal);
+		if(origVal !== origVal) {
+			return "";
+		}
+	}
+
+	// Simplify logic by making positive value
+	let val, sign;
+	if(origVal >= 0) {
+		val = origVal;
+		sign = this._plusSignEnabled ? "+" : "";
+	} else {
+		val = -origVal;
+		sign = "-";
+	}
+	let scalingMode = this._percentFormatEnabled ? "" : this._scaler; // Percent formatting overwrite scaling mode
+
+	if(this._multiplyBy100Enabled) {
+		if(this._precisionEnabled || scalingMode) {
+			val = val * 100; // Since value will be rounded later, there is no need to avoid rounding issue
+		} else {
+			val = _multiplyByHundred(val);
+		}
+	}
+
+	let absVal = val;
+	// Perform scaling
+	if (scalingMode) {
+		if (scalingMode === "b" && val < 1e9) {
+			scalingMode = "m";
+		}
+		if (scalingMode === "m") {
+			if (val >= 1e6) {
+				val = val / 1e6;
+			} else if (val >= 1e3) {
+				val = val / 1e3;
+			}
+		} else if (scalingMode === "b") {
+			val = val / 1e9;
+		}
+	}
+	// Perform rounding
+	if (this._precisionEnabled) {
+		if (this._precision > 0) {
+			let deno = NumberFormatter._denominator[this._precision];
+			val = Math.round(val * deno) / deno;
+		} else {
+			val = Math.round(val);
+		}
+	} else if(scalingMode) {
+		val = Math.round(val * 100) / 100;
+	}
+
+	// Convert value to string
+	let str;
+	if(val > 0) {
+		if(val >= 1e-6) { // Handle high (7 or more digits) precision value
+			str = sign + val;
+		} else {
+			let fraction = val * 1e7; // Be careful that there are some cases like 1e-7 * 1e6 === 0.099
+			str = (fraction / 10) + "";
+			str = sign + "0.000000" + str.slice(2);
+		}
+	} else {
+		str = "0";
+	}
+
+	// Add separators
+	if(this._separatorEnabled && val >= 1e3) {
+		let strs = str.split(".");
+		str = strs[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+		if(strs.length > 1) {
+			str += "." + strs[1];
+		}
+	}
+
+	if ((this._precisionEnabled || scalingMode ) && this._precision > 0) { // Filling trialling zeros
+		str = NumberFormatter.padDecimalPartWithZeroes(str, this._precision);
+	}
+
+	// Add unit or suffix
+	if (scalingMode) {
+		if (scalingMode === "m") {
+			if (absVal >= 1e6) {
+				str += "M";
+			} else if (absVal >= 1e3) {
+				str += "K";
+			}
+		} else if (scalingMode === "b") {
+			str += "B";
+		}
+	}
+
+	if(this._percentSignEnabled || this._percentFormatEnabled) {
+		str += this._percentChar;
+	}
+	return str;
+};
+
+/** @public */
+NumberFormatter.prototype.enableDefaultFormat = function() {
+	let t = this;
+	t._precisionEnabled = t._separatorEnabled = t._percentSignEnabled = false;
+	t._percentFormatEnabled = t._plusSignEnabled = t._multiplyBy100Enabled = false;
+	t._scaler = "";
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enablePrecision = function(bool) {
+	this._precisionEnabled = (bool !== false);
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enableSeparator = function(bool) {
+	this._separatorEnabled = (bool !== false);
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enablePercentSign = function(bool) {
+	this._percentSignEnabled = (bool !== false);
+};
+/** Enforce percent format even if scaling mode is active
+* @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enablePercentFormat = function(bool) {
+	this._percentFormatEnabled = (bool !== false);
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enablePlusSign = function(bool) {
+	this._plusSignEnabled = (bool !== false);
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enableMultiplyBy100 = function(bool) {
+	this._multiplyBy100Enabled = (bool !== false);
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enableMillionScaling = function(bool) {
+	this._scaler = (bool !== false) ? "m" : "";
+};
+/** @public
+* @param {boolean=} bool
+*/
+NumberFormatter.prototype.enableBillionScaling = function(bool) {
+	this._scaler = (bool !== false) ? "b" : "";
+};
+
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isDefaultFormatEnabled = function() {
+	return !(this._precisionEnabled || this._separatorEnabled || this._percentSignEnabled || this._scaler || this._percentFormatEnabled);
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isPrecisionEnabled = function() {
+	return this._precisionEnabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isSeparatorEnabled = function() {
+	return this._separatorEnabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isPercentSignEnabled = function() {
+	return this._percentSignEnabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isPercentFormatEnabled = function() {
+	return this._percentFormatEnabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isPlusSignEnabled = function() {
+	return this._plusSignEnabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isMultiplyBy100Enabled = function() {
+	return this._multiplyBy100Enabled;
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isMillionScalingEnabled = function() {
+	return this._scaler === "m";
+};
+/** @public
+* @return {boolean}
+*/
+NumberFormatter.prototype.isBillionScalingEnabled = function() {
+	return this._scaler === "b";
+};
+
+/** @public
+* @return {number}
+*/
+NumberFormatter.prototype.getPrecision = function() {
+	return this._precision;
+};
+/** @public
+* @param {number} num Maximum is 9 digits
+*/
+NumberFormatter.prototype.setPrecision = function(num) {
+	this._precision = (num < NumberFormatter._denominator.length) ? num : NumberFormatter._denominator.length - 1;
+};
+/** @public
+* @param {string} cha
+*/
+NumberFormatter.prototype.setSeparatorCharacter = function(cha) {
+	this._sepChar = cha;
+};
+/** @public
+* @param {string} cha
+*/
+NumberFormatter.prototype.setPercentSignCharacter = function(cha) {
+	this._percentChar = cha;
+};
+
+export default NumberFormatter;
+export {NumberFormatter};

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

@@ -0,0 +1,71 @@
+import {Dom} from "./Dom.js";
+import { ElfUtil } from "./ElfUtil.js";
+import { injectCss, prettifyCss } from "./Util.js";
+
+declare namespace PercentBar {
+
+    type Options = {
+        alignment?: string|null,
+        movementColor?: boolean|null,
+        barColor?: string|null,
+        textHidden?: boolean|null,
+        textWidth?: (number|string)|null,
+        zeroValueHidden?: boolean|null
+    };
+
+}
+
+declare class PercentBar {
+
+    constructor(elem?: (Element|null)|null, options?: PercentBar.Options|null);
+
+    public static injectCss(hostElem: Element|null): void;
+
+    public static toAlignment(str: string|null|null): string;
+
+    public getElement(): Element|null;
+
+    public getValue(): number;
+
+    public getPercent(): number;
+
+    public isInvalid(): boolean;
+
+    public setValue(value: number, opt_max?: number|null, displayText?: (string|boolean)|null): void;
+
+    public setMax(absVal: number): void;
+
+    public hideZeroValue(hidden?: boolean|null): boolean;
+
+    public setText(txt: string|number|null): void;
+
+    public hideText(hidden?: boolean|null): boolean;
+
+    public isTextHidden(): boolean;
+
+    public setTextWidth(width: number|string|null): void;
+
+    public setMaxTextLength(width: number|string|null): void;
+
+    public getTextScrollWidth(): number;
+
+    public getAlignment(): string;
+
+    public setAlignment(alignment: string): void;
+
+    public useMovementColor(opt_enabled?: boolean|null): void;
+
+    public setTrackColor(color?: string|null): void;
+
+    public setBarColor(color?: string|null): void;
+
+    public enableTooltip(enabled?: boolean|null): void;
+
+    public updateBarColor(): void;
+
+}
+
+declare function toAlignment(str: string|null|null): string;
+
+export default PercentBar;
+export { PercentBar, toAlignment };