@beinformed/ui 1.20.7 → 1.20.10

package/lib/utils/number/DecimalFormat.js

@@ -13,17 +13,13 @@ var _startsWith = _interopRequireDefault(require("@babel/runtime-corejs3/core-js
 
 var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
 
 // @see: https://docs.oracle.com/javase/tutorial/i18n/format/decimalFormat.html
 
 /**
  */
-var DecimalFormat = /*#__PURE__*/function () {
+class DecimalFormat {
   // Grouping size
   // Minimum integer digits to be displayed
   // Minimum fractional digits to be displayed
@@ -31,8 +27,7 @@ var DecimalFormat = /*#__PURE__*/function () {
 
   /**
    */
-  function DecimalFormat(format) {
-    (0, _classCallCheck2.default)(this, DecimalFormat);
+  constructor(format) {
     (0, _defineProperty2.default)(this, "_prefix", void 0);
     (0, _defineProperty2.default)(this, "_suffix", void 0);
     (0, _defineProperty2.default)(this, "_comma", void 0);
@@ -50,396 +45,371 @@ var DecimalFormat = /*#__PURE__*/function () {
    */
 
 
-  (0, _createClass2.default)(DecimalFormat, [{
-    key: "prefix",
-    get: function get() {
-      return this._prefix;
-    }
-    /**
-     */
+  get prefix() {
+    return this._prefix;
+  }
+  /**
+   */
 
-  }, {
-    key: "suffix",
-    get: function get() {
-      return this._suffix;
-    }
-    /**
-     */
 
-  }, {
-    key: "comma",
-    get: function get() {
-      return this._comma;
-    }
-    /**
-     */
+  get suffix() {
+    return this._suffix;
+  }
+  /**
+   */
 
-  }, {
-    key: "minInt",
-    get: function get() {
-      return this._minInt;
-    }
-    /**
-     */
 
-  }, {
-    key: "minFrac",
-    get: function get() {
-      return this._minFrac;
-    }
-    /**
-     */
+  get comma() {
+    return this._comma;
+  }
+  /**
+   */
 
-  }, {
-    key: "maxFrac",
-    get: function get() {
-      return this._maxFrac;
-    }
-    /**
-     */
 
-  }, {
-    key: "isPercentage",
-    get: function get() {
-      return this._isPercentage;
-    }
-    /**
-     */
-
-  }, {
-    key: "setAffix",
-    value: function setAffix(format) {
-      var beforeDigit = (0, _includes.default)(format).call(format, "#") ? format.substring(0, format.indexOf("#")) : format;
-      this._prefix = (0, _includes.default)(beforeDigit).call(beforeDigit, "0") ? beforeDigit.substring(0, beforeDigit.indexOf("0")) : beforeDigit;
-      this._suffix = format.substring(this._prefix.length).replace(/[#,\.0]/g, "");
-    }
-    /**
-     */
-
-  }, {
-    key: "setFractionLengths",
-    value: function setFractionLengths(format) {
-      this._minFrac = 0;
-      this._maxFrac = 0;
-      var numberStr = format.replace(/(?:(?![#,\.0])[\s\S])/g, "");
-
-      if ((0, _includes.default)(numberStr).call(numberStr, ".")) {
-        var fracStr = numberStr.substring(numberStr.indexOf(".") + 1);
-        var maxFrac = fracStr.replace(/,|\.+/g, "");
-        this._maxFrac = maxFrac.length; // replace all but zeros
-
-        var minFrac = maxFrac.replace(/(?:(?!0)[\s\S])/g, "");
-        this._minFrac = minFrac.length;
-      }
-    }
-    /**
-     */
-
-  }, {
-    key: "setGroupLength",
-    value: function setGroupLength(format) {
-      this._comma = 0;
-      var numberStr = format.replace(/(?:(?![#,\.0])[\s\S])/g, "");
-      var intStr = (0, _includes.default)(numberStr).call(numberStr, ".") ? numberStr.substring(0, numberStr.indexOf(".")) : numberStr;
-
-      if ((0, _includes.default)(intStr).call(intStr, ",")) {
-        this._comma = intStr.length - 1 - intStr.lastIndexOf(",");
-      }
-    }
-    /**
-     */
-
-  }, {
-    key: "setMinLength",
-    value: function setMinLength(format) {
-      var intFormatStr = (0, _includes.default)(format).call(format, ".") ? format.substring(0, format.indexOf(".")) : format;
-      var intStr = intFormatStr.replace(/(?:(?!0)[\s\S])/g, "");
-      this._minInt = intStr.length > 1 ? intStr.length : 1;
+  get minInt() {
+    return this._minInt;
+  }
+  /**
+   */
+
+
+  get minFrac() {
+    return this._minFrac;
+  }
+  /**
+   */
+
+
+  get maxFrac() {
+    return this._maxFrac;
+  }
+  /**
+   */
+
+
+  get isPercentage() {
+    return this._isPercentage;
+  }
+  /**
+   */
+
+
+  setAffix(format) {
+    const beforeDigit = (0, _includes.default)(format).call(format, "#") ? format.substring(0, format.indexOf("#")) : format;
+    this._prefix = (0, _includes.default)(beforeDigit).call(beforeDigit, "0") ? beforeDigit.substring(0, beforeDigit.indexOf("0")) : beforeDigit;
+    this._suffix = format.substring(this._prefix.length).replace(/[#,.0]/gu, "");
+  }
+  /**
+   */
+
+
+  setFractionLengths(format) {
+    this._minFrac = 0;
+    this._maxFrac = 0;
+    const numberStr = format.replace(/[^#,.0]/gu, "");
+
+    if ((0, _includes.default)(numberStr).call(numberStr, ".")) {
+      const fracStr = numberStr.substring(numberStr.indexOf(".") + 1);
+      const maxFrac = fracStr.replace(/,|\.+/g, "");
+      this._maxFrac = maxFrac.length; // replace all but zeros
+
+      const minFrac = maxFrac.replace(/[^0]/gu, "");
+      this._minFrac = minFrac.length;
     }
-    /**
-     */
+  }
+  /**
+   */
+
 
-  }, {
-    key: "setPercentage",
-    value: function setPercentage() {
-      this._isPercentage = this.suffix.charAt(0) === "%";
+  setGroupLength(format) {
+    this._comma = 0;
+    const numberStr = format.replace(/[^#,.0]/gu, "");
+    const intStr = (0, _includes.default)(numberStr).call(numberStr, ".") ? numberStr.substring(0, numberStr.indexOf(".")) : numberStr;
+
+    if ((0, _includes.default)(intStr).call(intStr, ",")) {
+      this._comma = intStr.length - 1 - intStr.lastIndexOf(",");
     }
-    /**
-     * Solves problem where big numbers loose the precision:
-     * e.g. Number(23423423423342234.34) => 23423423423342236
-     */
-
-  }, {
-    key: "formatBack",
-    value:
-    /**
-     * Converts formatted value back to non-formatted value
-     * e.g. $1,223.06 --> 1223.06
-     */
-    function formatBack(formattedNumber) {
-      var stringNumber = String(formattedNumber);
-
-      if (!stringNumber) {
-        return "";
-      }
+  }
+  /**
+   */
 
-      if (!isNaN(stringNumber)) {
-        return DecimalFormat.getNumericString(stringNumber);
-      }
 
-      var tempNumber = formattedNumber;
-      var negative = false;
+  setMinLength(format) {
+    const intFormatStr = (0, _includes.default)(format).call(format, ".") ? format.substring(0, format.indexOf(".")) : format;
+    const intStr = intFormatStr.replace(/[^0]/gu, "");
+    this._minInt = intStr.length > 1 ? intStr.length : 1;
+  }
+  /**
+   */
+
 
-      if (formattedNumber.charAt(0) === "-") {
-        tempNumber = formattedNumber.substr(1);
-        negative = true;
-      }
+  setPercentage() {
+    this._isPercentage = this.suffix.charAt(0) === "%";
+  }
+  /**
+   * Solves problem where big numbers loose the precision:
+   * e.g. Number(23423423423342234.34) => 23423423423342236
+   */
 
-      var hasPrefix = (0, _startsWith.default)(formattedNumber).call(formattedNumber, this.prefix);
-      var suffixIndex = this.suffix === "" ? formattedNumber.length : formattedNumber.indexOf(this.suffix, this.prefix.length + 1);
 
-      if (hasPrefix && suffixIndex > 0) {
-        tempNumber = tempNumber.substr(0, suffixIndex);
-        tempNumber = tempNumber.substr(this.prefix.length);
-        tempNumber = tempNumber.replace(/,/g, "");
+  static getNumericString(stringNumber) {
+    const number = Number(stringNumber);
+    const string = String(number);
 
-        if (negative) {
-          tempNumber = "-".concat(tempNumber);
-        }
+    if (!(0, _includes.default)(string).call(string, ".") && (0, _includes.default)(stringNumber).call(stringNumber, ".")) {
+      // check if original string has all zeros after dot or not
+      const precision = stringNumber.substring(stringNumber.indexOf(".") + 1);
 
-        if (!isNaN(tempNumber)) {
-          return DecimalFormat.getNumericString(tempNumber);
-        }
+      if (precision.replace(/0/gu, "").length > 0) {
+        return stringNumber;
       }
 
-      return tempNumber;
-    }
-    /**
-     */
-
-  }, {
-    key: "getFracAsNumber",
-    value:
-    /**
-     */
-    function getFracAsNumber(fracStr) {
-      var number = Number("0.".concat(fracStr));
-      var DECIMAL_RADIX = 10;
-      return this.maxFrac === 0 ? Math.round(number).toString(DECIMAL_RADIX) : number.toFixed(this.maxFrac);
+      return string;
     }
-    /**
-     */
 
-  }, {
-    key: "getRoundedFrac",
-    value: function getRoundedFrac(fracStr) {
-      var num = this.getFracAsNumber(fracStr); // toFixed method has bugs on IE (0.7 --> 0)
+    return stringNumber;
+  }
+  /**
+   * Converts formatted value back to non-formatted value
+   * e.g. $1,223.06 --> 1223.06
+   */
 
-      return num.substr(2);
+
+  formatBack(formattedNumber) {
+    const stringNumber = String(formattedNumber);
+
+    if (!stringNumber) {
+      return "";
     }
-    /**
-     */
-
-  }, {
-    key: "getFracCorrectLength",
-    value:
-    /**
-     */
-    function getFracCorrectLength(frac) {
-      var fracStr = frac;
-
-      if (fracStr.length > this.maxFrac) {
-        fracStr = this.getRoundedFrac(fracStr);
-      }
 
-      for (var i = fracStr.length; i < this.minFrac; i++) {
-        // if minFrac=4 then 1.12 --> 1.1200
-        fracStr = "".concat(fracStr, "0");
-      }
+    if (!isNaN(stringNumber)) {
+      return DecimalFormat.getNumericString(stringNumber);
+    }
 
-      while (fracStr.length > this.minFrac && fracStr.charAt(fracStr.length - 1) === "0") {
-        // if minInt=4 then 00034 --> 0034)
-        fracStr = fracStr.substring(0, fracStr.length - 1);
-      }
+    let tempNumber = formattedNumber;
+    let negative = false;
 
-      return fracStr;
+    if (formattedNumber.charAt(0) === "-") {
+      tempNumber = formattedNumber.substr(1);
+      negative = true;
     }
-    /**
-     */
-
-  }, {
-    key: "getInteger",
-    value: function getInteger(number) {
-      var intStr = (0, _includes.default)(number).call(number, ".") ? number.substring(0, number.indexOf(".")) : number;
-      var doCarry = Number(this.getFracAsNumber(number)) > 1;
-      var i = intStr.length - 1;
-
-      while (doCarry) {
-        if (i === -1) {
-          intStr = "1".concat(intStr);
-          break;
-        }
-
-        var x = intStr.charAt(i);
-
-        if (x === "9") {
-          x = "0";
-        } else {
-          x = "".concat(x + 1);
-          doCarry = false;
-        }
-
-        intStr = intStr.substring(0, i) + x + intStr.substring(i + 1, intStr.length);
-        i -= 1;
-      }
 
-      for (var j = intStr.length; j < this.minInt; j++) {
-        // if minInt=4 then 034 --> 0034
-        intStr = "0".concat(intStr);
-      }
+    const hasPrefix = (0, _startsWith.default)(formattedNumber).call(formattedNumber, this.prefix);
+    const suffixIndex = this.suffix === "" ? formattedNumber.length : formattedNumber.indexOf(this.suffix, this.prefix.length + 1);
+
+    if (hasPrefix && suffixIndex > 0) {
+      tempNumber = tempNumber.substr(0, suffixIndex);
+      tempNumber = tempNumber.substr(this.prefix.length);
+      tempNumber = tempNumber.replace(/,/gu, "");
 
-      while (intStr.length > this.minInt && intStr.charAt(0) === "0") {
-        // if minInt=4 then 00034 --> 0034)
-        intStr = intStr.substring(1);
+      if (negative) {
+        tempNumber = "-".concat(tempNumber);
       }
 
-      return intStr;
+      if (!isNaN(tempNumber)) {
+        return DecimalFormat.getNumericString(tempNumber);
+      }
     }
-    /**
-     */
 
-  }, {
-    key: "addGrouping",
-    value: function addGrouping(intStr) {
-      var groupedIntStr = intStr;
-      var j = 0;
+    return tempNumber;
+  }
+  /**
+   */
 
-      for (var i = groupedIntStr.length; i > 0; i--) {
-        // add commas
-        if (j !== 0 && j % this.comma === 0) {
-          var _context;
 
-          groupedIntStr = (0, _concat.default)(_context = "".concat(groupedIntStr.substring(0, i), ",")).call(_context, groupedIntStr.substring(i));
-          j = 0;
-        }
+  static scientificNumber(stringNumber) {
+    if ((0, _includes.default)(stringNumber).call(stringNumber, "e")) {
+      const number = Number(stringNumber);
 
-        j += 1;
+      if (number === Infinity || number === -Infinity) {
+        return stringNumber;
       }
 
-      return groupedIntStr;
+      return String(number);
     }
-    /**
-     */
 
-  }, {
-    key: "getFormattedValue",
-    value: function getFormattedValue(intStr, fracStr, isNegative) {
-      var _context2, _context3;
+    return stringNumber;
+  }
+  /**
+   */
 
-      var formattedValue;
-      if (fracStr.length > 0) formattedValue = (0, _concat.default)(_context2 = (0, _concat.default)(_context3 = "".concat(this.prefix + intStr, ".")).call(_context3, fracStr)).call(_context2, this.suffix);else formattedValue = this.prefix + intStr + this.suffix;
 
-      if (isNegative) {
-        formattedValue = "-".concat(formattedValue);
-      }
+  getFracAsNumber(fracStr) {
+    const number = Number("0.".concat(fracStr));
+    const DECIMAL_RADIX = 10;
+    return this.maxFrac === 0 ? Math.round(number).toString(DECIMAL_RADIX) : number.toFixed(this.maxFrac);
+  }
+  /**
+   */
+
 
-      return formattedValue;
+  getRoundedFrac(fracStr) {
+    const num = this.getFracAsNumber(fracStr); // toFixed method has bugs on IE (0.7 --> 0)
+
+    return num.substr(2);
+  }
+  /**
+   */
+
+
+  static getFraction(number) {
+    let fracStr = (0, _includes.default)(number).call(number, ".") ? number.substring(number.indexOf(".") + 1) : "";
+    fracStr = fracStr.replace(/\./, "");
+    return fracStr;
+  }
+  /**
+   */
+
+
+  getFracCorrectLength(frac) {
+    let fracStr = frac;
+
+    if (fracStr.length > this.maxFrac) {
+      fracStr = this.getRoundedFrac(fracStr);
     }
-    /**
-     * Formats given value, using the pattern
-     * e.g. $#,###.00: 1223.06 --> $1,223.06
-     */
-
-  }, {
-    key: "format",
-    value: function format() {
-      var stringNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
-
-      if (stringNumber === null) {
-        return "";
-      }
 
-      var formattedNumber = this.formatBack(stringNumber).toLowerCase();
+    for (let i = fracStr.length; i < this.minFrac; i++) {
+      // if minFrac=4 then 1.12 --> 1.1200
+      fracStr = "".concat(fracStr, "0");
+    }
 
-      if (isNaN(formattedNumber) || formattedNumber.length === 0) {
-        return stringNumber;
-      }
+    while (fracStr.length > this.minFrac && fracStr.charAt(fracStr.length - 1) === "0") {
+      // if minInt=4 then 00034 --> 0034)
+      fracStr = fracStr.substring(0, fracStr.length - 1);
+    }
+
+    return fracStr;
+  }
+  /**
+   */
 
-      formattedNumber = DecimalFormat.scientificNumber(formattedNumber);
 
-      if ((0, _includes.default)(formattedNumber).call(formattedNumber, "e")) {
-        return formattedNumber;
+  getInteger(number) {
+    let intStr = (0, _includes.default)(number).call(number, ".") ? number.substring(0, number.indexOf(".")) : number;
+    let doCarry = Number(this.getFracAsNumber(number)) > 1;
+    let i = intStr.length - 1;
+
+    while (doCarry) {
+      if (i === -1) {
+        intStr = "1".concat(intStr);
+        break;
       }
 
-      var isNegative = formattedNumber.charAt(0) === "-";
+      let x = intStr.charAt(i);
 
-      if (isNegative || formattedNumber.charAt(0) === "+") {
-        formattedNumber = formattedNumber.substring(1);
+      if (x === "9") {
+        x = "0";
+      } else {
+        x = "".concat(x + 1);
+        doCarry = false;
       }
 
-      var fracStr = DecimalFormat.getFraction(formattedNumber);
-      var intStr = this.getInteger(formattedNumber);
+      intStr = intStr.substring(0, i) + x + intStr.substring(i + 1, intStr.length);
+      i -= 1;
+    }
+
+    for (let j = intStr.length; j < this.minInt; j++) {
+      // if minInt=4 then 034 --> 0034
+      intStr = "0".concat(intStr);
+    }
+
+    while (intStr.length > this.minInt && intStr.charAt(0) === "0") {
+      // if minInt=4 then 00034 --> 0034)
+      intStr = intStr.substring(1);
+    }
+
+    return intStr;
+  }
+  /**
+   */
 
-      if (this.isPercentage) {
-        var _context4;
 
-        // Add zeros behind fraction to make sure we have at least two characters and take first two character:
-        // 1 --> 100 --> 10
-        var addZeroToFrac = "".concat(fracStr, "00").substr(0, 2); // Add zeros in front of frac and get last two characters
+  addGrouping(intStr) {
+    let groupedIntStr = intStr;
+    let j = 0;
 
-        var lastTwoFrac = "00".concat(addZeroToFrac).substr(-2);
-        intStr = (0, _concat.default)(_context4 = "".concat(intStr)).call(_context4, lastTwoFrac);
-        fracStr = fracStr.substr(2);
+    for (let i = groupedIntStr.length; i > 0; i--) {
+      // add commas
+      if (j !== 0 && j % this.comma === 0) {
+        var _context;
+
+        groupedIntStr = (0, _concat.default)(_context = "".concat(groupedIntStr.substring(0, i), ",")).call(_context, groupedIntStr.substring(i));
+        j = 0;
       }
 
-      fracStr = this.getFracCorrectLength(fracStr);
-      intStr = this.addGrouping(intStr);
-      return this.getFormattedValue(intStr, fracStr, isNegative);
+      j += 1;
     }
-  }], [{
-    key: "getNumericString",
-    value: function getNumericString(stringNumber) {
-      var number = Number(stringNumber);
-      var string = String(number);
 
-      if (!(0, _includes.default)(string).call(string, ".") && (0, _includes.default)(stringNumber).call(stringNumber, ".")) {
-        // check if original string has all zeros after dot or not
-        var precision = stringNumber.substring(stringNumber.indexOf(".") + 1);
+    return groupedIntStr;
+  }
+  /**
+   */
 
-        if (precision.replace(/0/g, "").length > 0) {
-          return stringNumber;
-        }
 
-        return string;
-      }
+  getFormattedValue(intStr, fracStr, isNegative) {
+    var _context2, _context3;
 
-      return stringNumber;
+    let formattedValue;
+    if (fracStr.length > 0) formattedValue = (0, _concat.default)(_context2 = (0, _concat.default)(_context3 = "".concat(this.prefix + intStr, ".")).call(_context3, fracStr)).call(_context2, this.suffix);else formattedValue = this.prefix + intStr + this.suffix;
+
+    if (isNegative) {
+      formattedValue = "-".concat(formattedValue);
     }
-  }, {
-    key: "scientificNumber",
-    value: function scientificNumber(stringNumber) {
-      if ((0, _includes.default)(stringNumber).call(stringNumber, "e")) {
-        var number = Number(stringNumber);
 
-        if (number === Infinity || number === -Infinity) {
-          return stringNumber;
-        }
+    return formattedValue;
+  }
+  /**
+   * Formats given value, using the pattern
+   * e.g. $#,###.00: 1223.06 --> $1,223.06
+   */
+
 
-        return String(number);
-      }
+  format() {
+    let stringNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+
+    if (stringNumber === null) {
+      return "";
+    }
 
+    let formattedNumber = this.formatBack(stringNumber).toLowerCase();
+
+    if (isNaN(formattedNumber) || formattedNumber.length === 0) {
       return stringNumber;
     }
-  }, {
-    key: "getFraction",
-    value: function getFraction(number) {
-      var fracStr = (0, _includes.default)(number).call(number, ".") ? number.substring(number.indexOf(".") + 1) : "";
-      fracStr = fracStr.replace(/\./, "");
-      return fracStr;
+
+    formattedNumber = DecimalFormat.scientificNumber(formattedNumber);
+
+    if ((0, _includes.default)(formattedNumber).call(formattedNumber, "e")) {
+      return formattedNumber;
     }
-  }]);
-  return DecimalFormat;
-}();
+
+    const isNegative = formattedNumber.charAt(0) === "-";
+
+    if (isNegative || formattedNumber.charAt(0) === "+") {
+      formattedNumber = formattedNumber.substring(1);
+    }
+
+    let fracStr = DecimalFormat.getFraction(formattedNumber);
+    let intStr = this.getInteger(formattedNumber);
+
+    if (this.isPercentage) {
+      var _context4;
+
+      // Add zeros behind fraction to make sure we have at least two characters and take first two character:
+      // 1 --> 100 --> 10
+      const addZeroToFrac = "".concat(fracStr, "00").substr(0, 2); // Add zeros in front of frac and get last two characters
+
+      const lastTwoFrac = "00".concat(addZeroToFrac).substr(-2);
+      intStr = (0, _concat.default)(_context4 = "".concat(intStr)).call(_context4, lastTwoFrac);
+      fracStr = fracStr.substr(2);
+    }
+
+    fracStr = this.getFracCorrectLength(fracStr);
+    intStr = this.addGrouping(intStr);
+    return this.getFormattedValue(intStr, fracStr, isNegative);
+  }
+
+}
 
 var _default = DecimalFormat;
 exports.default = _default;