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

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

@@ -0,0 +1,471 @@
+
+/** @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
+*/
+
+/** NumberFormatter provides a way to format the given number quickly.
+* @constructor
+* @param {NumberFormatter~Options=} options
+* @example
+* var 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
+*};
+* var nf = new NumberFormatter(options);
+* nf.format(123); // "123"
+* nf.format(-456.789); // "-456.789"
+* nf.getOptions(); // For serialization
+*/
+var 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;
+	}
+
+	var formatType = /** @type{string} */(options["formatType"] || options["type"]);
+
+	// Note that precision will not be used in scaledValue mode
+	var 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 = true;
+		}
+
+		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) {
+	var dp = str.lastIndexOf(".");
+	if (dp >= 0) {
+		var decimalPlace = str.length - dp - 1;
+		if (decimalPlace < precision) {
+			str += NumberFormatter._zeroes[precision - decimalPlace];
+		}
+	} else {
+		str += "." + NumberFormatter._zeroes[precision];
+	}
+	return str;
+};
+
+/** @public
+* @param {Object=} options
+* @return {!Object}
+*/
+NumberFormatter.prototype.getOptions = function(options) { // serialize
+	if(!options) { options = {}; }
+
+	options["precisionEnabled"] = this._precisionEnabled;
+	options["decimalPlaces"] = this._precision;
+	options["plusSign"] = this._plusSignEnabled;
+	options["separator"] = this._separatorEnabled;
+	options["percentSign"] = this._percentSignEnabled;
+	var su = "";
+	if(this._scaler == "b") {
+		su = "billion";
+	} else if(this._scaler == "m") {
+		su = "million";
+	}
+	options["scalingUnit"] = su;
+	options["mutiplyBy100"] = this._multiplyBy100Enabled;
+	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 "";
+		}
+	}
+
+	// Make value to be positive value for simpler logic
+	var val, sign;
+	if(origVal >= 0) {
+		val = origVal;
+		sign = this._plusSignEnabled ? "+" : "";
+	} else {
+		val = -origVal;
+		sign = "-";
+	}
+	if(this._multiplyBy100Enabled) {
+		val = val * 100;
+	}
+	var absVal = val;
+	var scalingMode = this._percentFormatEnabled ? "" : this._scaler; // Percent formatting overwrite scaling mode
+
+	// Perform rounding
+
+	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;
+		}
+
+		if (!this._precisionEnabled) {
+			val = Math.round(val * 100) / 100;
+		}
+	}
+	if (this._precisionEnabled) {
+		if (this._precision > 0) {
+			var deno = NumberFormatter._denominator[this._precision];
+			val = Math.round(val * deno) / deno;
+		} else {
+			val = Math.round(val);
+		}
+	}
+
+	// Convert value to string
+	var str;
+	if(val > 0) {
+		if(val >= 1e-6) { // Handle high (7 or more digits) precision value
+			str = sign + val;
+		} else {
+			var fraction = val * 1e7; // Be careful that there are some cases like 1e-7 * 1e6 === 0.099
+			str = (fraction / 10) + "";
+			str = sign + "0.000000" + str.substr(2);
+		}
+	} else {
+		str = "0";
+	}
+
+	// Add separators
+	if(this._separatorEnabled && val >= 1e3) {
+		var 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() {
+	var 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,
+        movementColor?: boolean,
+        barColor?: string,
+        textHidden?: boolean,
+        textWidth?: (number|string),
+        zeroValueHidden?: boolean
+    };
+
+}
+
+declare class PercentBar {
+
+    constructor(elem?: (Element|null), options?: PercentBar.Options);
+
+    public static injectCss(hostElem: Element): void;
+
+    public static toAlignment(str: string|null): string;
+
+    public getElement(): Element;
+
+    public getValue(): number;
+
+    public getPercent(): number;
+
+    public isInvalid(): boolean;
+
+    public setValue(value: number, opt_max?: number, displayText?: (string|boolean)): void;
+
+    public setMax(absVal: number): void;
+
+    public hideZeroValue(hidden?: boolean): boolean;
+
+    public setText(txt: string): void;
+
+    public hideText(hidden?: boolean): boolean;
+
+    public isTextHidden(): boolean;
+
+    public setTextWidth(width: number|string): void;
+
+    public setMaxTextLength(width: number|string): void;
+
+    public getTextScrollWidth(): number;
+
+    public getAlignment(): string;
+
+    public setAlignment(alignment: string): void;
+
+    public useMovementColor(opt_enabled?: boolean): void;
+
+    public setTrackColor(color?: string): void;
+
+    public setBarColor(color?: string): void;
+
+    public enableTooltip(enabled?: boolean): void;
+
+    public updateBarColor(): void;
+
+}
+
+declare function toAlignment(str: string|null): string;
+
+export default PercentBar;
+export { PercentBar, toAlignment };