@formatjs/intl-numberformat 4.2.1 → 4.2.6

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.2.6](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.5...@formatjs/intl-numberformat@4.2.6) (2020-06-06)
+
+**Note:** Version bump only for package @formatjs/intl-numberformat
+
+
+
+
+
+## [4.2.5](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.4...@formatjs/intl-numberformat@4.2.5) (2020-06-06)
+
+**Note:** Version bump only for package @formatjs/intl-numberformat
+
+
+
+
+
+## [4.2.4](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.3...@formatjs/intl-numberformat@4.2.4) (2020-06-04)
+
+**Note:** Version bump only for package @formatjs/intl-numberformat
+
+
+
+
+
+## [4.2.3](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.2...@formatjs/intl-numberformat@4.2.3) (2020-06-04)
+
+**Note:** Version bump only for package @formatjs/intl-numberformat
+
+
+
+
+
+## [4.2.2](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.1...@formatjs/intl-numberformat@4.2.2) (2020-06-03)
+
+
+### Bug Fixes
+
+* **@formatjs/intl-utils:** fix toRawPrecision (round up) and toRawFixed (with huge numbers) ([#1696](https://github.com/formatjs/formatjs/issues/1696)) ([df68427](https://github.com/formatjs/formatjs/commit/df68427c06cd815231ff19b9d5cc493e6df444e2)), closes [#1692](https://github.com/formatjs/formatjs/issues/1692)
+
+
+
+
+
 ## [4.2.1](https://github.com/formatjs/formatjs/compare/@formatjs/intl-numberformat@4.2.0...@formatjs/intl-numberformat@4.2.1) (2020-05-28)
 
 **Note:** Version bump only for package @formatjs/intl-numberformat

package/dist/polyfill-with-locales-for-test262.min.js

@@ -251,13 +251,7 @@
      */
     function toRawFixed(x, minFraction, maxFraction) {
         const f = maxFraction;
-        let n;
-        {
-            const exactSolve = x * Math.pow(10, f);
-            const roundDown = Math.floor(exactSolve);
-            const roundUp = Math.ceil(exactSolve);
-            n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;
-        }
+        const n = Math.round(x * Math.pow(10, f));
         const xFinal = n / Math.pow(10, f);
         // n is a positive integer, but it is possible to be greater than 1e21.
         // In such case we will go the slow path.
@@ -268,13 +262,9 @@
         }
         else {
             m = n.toString();
-            const idx1 = m.indexOf('.');
-            const idx2 = m.indexOf('e+');
-            const exponent = parseInt(m.substring(idx2 + 2), 10);
-            m =
-                m.substring(0, idx1) +
-                    m.substring(idx1 + 1, idx2) +
-                    repeat('0', exponent - (idx2 - idx1 - 1));
+            const [mantissa, exponent] = m.split('e');
+            m = mantissa.replace('.', '');
+            m = m + repeat('0', Math.max(+exponent - m.length + 1, 0));
         }
         let int;
         if (f !== 0) {
@@ -314,23 +304,38 @@
             xFinal = 0;
         }
         else {
-            e = getMagnitude(x);
-            let n;
-            {
-                const magnitude = e - p + 1;
-                const exactSolve = 
-                // Preserve floating point precision as much as possible with multiplication.
-                magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);
-                const roundDown = Math.floor(exactSolve);
-                const roundUp = Math.ceil(exactSolve);
-                n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;
+            const xToString = x.toString();
+            // If xToString is formatted as scientific notation, the number is either very small or very
+            // large. If the precision of the formatted string is lower that requested max precision, we
+            // should still infer them from the formatted string, otherwise the formatted result might have
+            // precision loss (e.g. 1e41 will not have 0 in every trailing digits).
+            const xToStringExponentIndex = xToString.indexOf('e');
+            const [xToStringMantissa, xToStringExponent] = xToString.split('e');
+            const xToStringMantissaWithoutDecimalPoint = xToStringMantissa.replace('.', '');
+            if (xToStringExponentIndex >= 0 &&
+                xToStringMantissaWithoutDecimalPoint.length <= p) {
+                e = +xToStringExponent;
+                m =
+                    xToStringMantissaWithoutDecimalPoint +
+                        repeat('0', p - xToStringMantissaWithoutDecimalPoint.length);
+                xFinal = x;
+            }
+            else {
+                e = getMagnitude(x);
+                const decimalPlaceOffset = e - p + 1;
+                // n is the integer containing the required precision digits. To derive the formatted string,
+                // we will adjust its decimal place in the logic below.
+                let n = Math.round(adjustDecimalPlace(x, decimalPlaceOffset));
+                // The rounding caused the change of magnitude, so we should increment `e` by 1.
+                if (adjustDecimalPlace(n, p - 1) >= 10) {
+                    e = e + 1;
+                    // Divide n by 10 to swallow one precision.
+                    n = Math.floor(n / 10);
+                }
+                m = n.toString();
+                // Equivalent of n * 10 ** (e - p + 1)
+                xFinal = adjustDecimalPlace(n, p - 1 - e);
             }
-            // See: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
-            // No need to worry about scientific notation because it only happens for values >= 1e21,
-            // which has 22 significant digits. So it will at least be divided by 10 here to bring the
-            // value back into non-scientific-notation range.
-            m = n.toString();
-            xFinal = n * Math.pow(10, (e - p + 1));
         }
         let int;
         if (e >= p - 1) {
@@ -356,6 +361,10 @@
             }
         }
         return { formattedString: m, roundedNumber: xFinal, integerDigitsCount: int };
+        // x / (10 ** magnitude), but try to preserve as much floating point precision as possible.
+        function adjustDecimalPlace(x, magnitude) {
+            return magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);
+        }
     }
     function repeat(s, times) {
         if (typeof s.repeat === 'function') {
@@ -4656,6 +4665,18 @@
     var polyfill = createCommonjsModule(function (module, exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
 
+    if (typeof Intl === 'undefined') {
+        if (typeof window !== 'undefined') {
+            Object.defineProperty(window, 'Intl', {
+                value: {},
+            });
+        }
+        else if (typeof commonjsGlobal !== 'undefined') {
+            Object.defineProperty(commonjsGlobal, 'Intl', {
+                value: {},
+            });
+        }
+    }
     if (!('getCanonicalLocales' in Intl) ||
         // Native Intl.getCanonicalLocales is just buggy
         Intl.getCanonicalLocales('und-x-private')[0] === 'x-private') {