reduce-precision 1.0.1 → 1.0.2

package/README.md

@@ -41,7 +41,7 @@ const formatter = new NumberFormatter();
 formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' });
 
 console.log(formatter.toHtmlString(123456789));
-console.log(formatter.format(123456789));
+console.log(formatter.toJson(123456789));
 console.log(formatter.toString(123456789));
 ```
 
@@ -55,7 +55,7 @@ const formatter = new NumberFormatter();
 formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' });
 
 console.log(formatter.toHtmlString(123456789));
-console.log(formatter.format(123456789));
+console.log(formatter.toJson(123456789));
 console.log(formatter.toString(123456789));
 ```
 
@@ -97,20 +97,20 @@ const formatterWithOptions = new NumberFormatter({
 formatter.setLanguage('en');
 
 // Basic number formatting
-formatter.format(1234.5678); // Output: { value: '1,234.6', ... }
+formatter.toJson(1234.5678); // Output: { value: '1,234.6', ... }
 
 // Formatting with medium precision
-formatter.setTemplate('number', 'medium').format(1234.5678); // Output: { value: '1.23K', ... }
+formatter.setTemplate('number', 'medium').toJson(1234.5678); // Output: { value: '1.23K', ... }
 
 // Formatting as USD
-formatter.setTemplate('usd', 'high').format(1234.5678); // Output: { value: '$1,234.6', ... }
+formatter.setTemplate('usd', 'high').toJson(1234.5678); // Output: { value: '$1,234.6', ... }
 
 // Formatting as Iranian Rial with Persian numerals
-formatterWithOptions.format(1234.5678);
+formatterWithOptions.toJson(1234.5678);
 // Output: { value: 'مبلغ: ۱٫۲۳ هزار ت', ... }
 
 // Formatting as a percentage with low precision
-formatter.setTemplate('percent', 'low').format(0.1234); // Output: { value: '0.12%', ... }
+formatter.setTemplate('percent', 'low').toJson(0.1234); // Output: { value: '0.12%', ... }
 
 // Formatting with HTML output and custom markers
 
@@ -119,7 +119,7 @@ formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' }).toHtmlSt
 
 // Formatting with string input for small or big numbers
 
-formatter.setTemplate('usd', 'medium').format("0.00000000000000000000005678521");
+formatter.setTemplate('usd', 'medium').toJson("0.00000000000000000000005678521");
 // Output: { value: '$0.0₂₂5678', ... }
 ```
 
@@ -136,10 +136,6 @@ interface FormattedObject {
   postfix: string;         // The postfix string
   sign: string;            // The sign of the number (either an empty string or '-')
   wholeNumber: string;     // The whole number part of the value
-  fractionalPart: string;  // The complete fractional part of the value
-  fractionalNonZeros: string;  // The non-zero digits in the fractional part
-  fractionalZerosCount: number;  // The count of zeros in the fractional part
-  unit: string;            // The unit postfix
 }
 ```
 
@@ -173,7 +169,7 @@ Sets the template and precision for the formatter.
 
 Returns the `NumberFormatter` instance for method chaining.
 
-#### `format(input: string | number): FormattedObject`
+#### `toJson(input: string | number): FormattedObject`
 
 Formats the input number and returns the formatted object.
 
@@ -200,3 +196,4 @@ Contributions are welcome! If you find a bug or have a feature request, please o
 ## License
 
 This project is licensed under the [MIT License](LICENSE).
+

package/lib/format/index.d.ts

@@ -18,10 +18,6 @@ interface FormattedObject {
     postfix: string;
     sign: string;
     wholeNumber: string;
-    fractionalPart: string;
-    fractionalNonZeros: string;
-    fractionalZerosCount: number;
-    unit?: string;
 }
 interface LanguageConfig {
     prefixMarker?: string;

package/lib/format/index.js

@@ -267,6 +267,7 @@ class NumberFormatter {
         return eNotation.toFixed(precision);
     }
     reducePrecision(numberString, precision = 30, nonZeroDigits = 4, round = false, compress = false, fixedDecimalZeros = 0, template = 'number', language = 'en', outputFormat = 'plain', prefixMarker = 'span', postfixMarker = 'span', prefix = '', postfix = '') {
+        var _a;
         if (!numberString) {
             return {};
         }
@@ -297,7 +298,7 @@ class NumberFormatter {
             return {};
         }
         const sign = parts[1] || '';
-        let wholeNumberStr = parts[2];
+        let nonFractionalStr = parts[2];
         let fractionalZeroStr = parts[3];
         let fractionalNonZeroStr = parts[4];
         let unitPrefix = '';
@@ -313,15 +314,15 @@ class NumberFormatter {
             if (nonZeroDigits < 1)
                 nonZeroDigits = 1;
         }
-        else if (wholeNumberStr.length > maxIntegerDigits) {
-            wholeNumberStr = '0';
+        else if (nonFractionalStr.length > maxIntegerDigits) {
+            nonFractionalStr = '0';
             fractionalZeroStr = '';
             fractionalNonZeroStr = '';
         }
         // compress large numbers
-        if (compress && wholeNumberStr.length >= 4) {
+        if (compress && nonFractionalStr.length >= 4) {
             const scaleUnitKeys = Object.keys(scaleUnits);
-            let scaledWholeNumber = wholeNumberStr;
+            let scaledWholeNumber = nonFractionalStr;
             let unitIndex = 0;
             while (+scaledWholeNumber > 999 && unitIndex < scaleUnitKeys.length - 1) {
                 scaledWholeNumber = (+scaledWholeNumber / 1000).toFixed(2);
@@ -333,7 +334,7 @@ class NumberFormatter {
                 return {};
             }
             // sign = parts[1] || "";
-            wholeNumberStr = parts[2];
+            nonFractionalStr = parts[2];
             fractionalZeroStr = parts[3];
             fractionalNonZeroStr = parts[4];
         }
@@ -355,14 +356,13 @@ class NumberFormatter {
                             fractionalZeroStr = fractionalZeroStr.substring(0, fractionalZeroStr.length - 1);
                         }
                         else {
-                            wholeNumberStr = (Number(wholeNumberStr) + 1).toString();
+                            nonFractionalStr = (Number(nonFractionalStr) + 1).toString();
                             fractionalNonZeroStr = fractionalNonZeroStr.substring(1);
                         }
                     }
                 }
             }
         }
-        const orginalFractionalZeroStr = fractionalZeroStr;
         // Using dex style
         if (compress && fractionalZeroStr !== '' && unitPostfix === '') {
             fractionalZeroStr =
@@ -388,6 +388,8 @@ class NumberFormatter {
         // Output Formating, Prefix, Postfix
         if (template === 'usd') {
             unitPrefix = language === 'en' ? '$' : '';
+            if (!unitPostfix)
+                unitPostfix = language === 'fa' ? ' دلار' : '';
         }
         else if (template === 'irr') {
             if (!unitPostfix)
@@ -424,34 +426,41 @@ class NumberFormatter {
             ? '.'.padEnd(fixedDecimalZeros + 1, '0')
             : '';
         let out = '';
+        let wholeNumberStr;
         if (precision <= 0 || nonZeroDigits <= 0 || !fractionalNonZeroStr) {
-            out = `${sign}${unitPrefix}${wholeNumberStr.replace(thousandSeparatorRegex, ',')}${fixedDecimalZeroStr}${unitPostfix}`;
+            wholeNumberStr = `${nonFractionalStr.replace(thousandSeparatorRegex, ',')}${fixedDecimalZeroStr}`;
         }
         else {
-            out = `${sign}${unitPrefix}${wholeNumberStr.replace(thousandSeparatorRegex, ',')}.${fractionalPartStr}${unitPostfix}`;
+            wholeNumberStr = `${nonFractionalStr.replace(thousandSeparatorRegex, ',')}.${fractionalPartStr}`;
         }
+        out = `${sign}${unitPrefix}${wholeNumberStr}${unitPostfix}`;
+        const formattedObject = {
+            value: out,
+            prefix: unitPrefix,
+            postfix: unitPostfix,
+            sign: sign,
+            wholeNumber: wholeNumberStr,
+        };
         // Convert output to Persian numerals if language is "fa"
         if (language === 'fa') {
-            out = out
+            formattedObject.value = ((_a = formattedObject === null || formattedObject === void 0 ? void 0 : formattedObject.value) !== null && _a !== void 0 ? _a : '')
                 .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
                 .replace(/,/g, '٬')
                 .replace(/\./g, '٫')
                 .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
                 return String(scaleUnits[c]);
             });
-        }
-        const formattedObject = {
-            value: out,
-            prefix: unitPrefix,
-            postfix: unitPostfix.replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+            formattedObject.postfix = formattedObject.postfix
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
                 return String(scaleUnits[c]);
-            }),
-            sign: sign,
-            wholeNumber: wholeNumberStr.replace(thousandSeparatorRegex, ','),
-            fractionalPart: fractionalPartStr,
-            fractionalNonZeros: fractionalNonZeroStr,
-            fractionalZerosCount: orginalFractionalZeroStr.length,
-        };
+            });
+            formattedObject.wholeNumber = formattedObject.wholeNumber
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+                return String(scaleUnits[c]);
+            });
+        }
         return formattedObject;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reduce-precision",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "./lib/index.js",
   "files": [