reduce-precision 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ArzDigital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# reduce-precision
+
+`reduce-precision` is a versatile JavaScript/TypeScript package for formatting and reducing the precision of numbers, currencies, and percentages. It supports various templates, precision levels, languages, and output formats, making it easy to generate formatted strings for different use cases.
+
+## Features
+
+- Format numbers with customizable precision levels: high, medium, low, or auto
+- Support for multiple templates: number, USD, IRT (Iranian Toman), IRR (Iranian Rial), and percent
+- Multilingual support: English and Persian (Farsi)
+- Output formats: plain text, HTML, and Markdown
+- Customizable prefix and postfix markers for HTML and Markdown output
+- Intelligent handling of very small and very large numbers
+- Automatic thousand separators and decimal points based on the selected language
+- TypeScript type definitions included
+
+## Installation
+
+You can install `reduce-precision` using npm:
+
+```bash
+npm install reduce-precision
+```
+
+## Usage
+
+### JavaScript (CommonJS)
+
+```javascript
+const { format } = require('reduce-precision');
+
+const formatted = format(123456, options);
+```
+
+### TypeScript or ES Modules
+
+```typescript
+import { format } from 'reduce-precision';
+
+const formatted = format(123456, options);
+```
+
+## Options
+
+The `format` function accepts an optional `options` object with the following properties:
+
+| Option        | Type                                        | Default   | Description                                                        |
+| ------------- | ------------------------------------------- | --------- | ------------------------------------------------------------------ |
+| `precision`   | `'auto'` \| `'high'` \| `'medium'` \| `'low'` | `'high'`   | Precision level for formatting                                     |
+| `template`    | `'number'` \| `'usd'` \| `'irt'` \| `'irr'` \| `'percent'` | `'number'` | Template for formatting                                            |
+| `language`    | `'en'` \| `'fa'`                              | `'en'`     | Language for formatting (English or Persian)                       |
+| `outputFormat` | `'plain'` \| `'html'` \| `'markdown'`          | `'plain'`  | Output format                                                      |
+| `prefixMarker` | `string`                                    | `'i'`      | Prefix marker for HTML and Markdown output                         |
+| `postfixMarker` | `string`                                    | `'i'`      | Postfix marker for HTML and Markdown output                        |
+| `prefix`       | `string`                                    | `''`       | Prefix string to be added before the formatted number              |
+| `postfix`      | `string`                                    | `''`       | Postfix string to be added after the formatted number              |
+
+## Examples
+
+```typescript
+import { format } from 'reduce-precision';
+
+// Basic number formatting
+format(1234.5678); // Output: 1,234.5678
+
+// Formatting with medium precision
+format(1234.5678, { precision: 'medium' }); // Output: 1,234.57
+
+// Formatting as USD
+format(1234.5678, { template: 'usd' }); // Output: $1,234.5678
+
+// Formatting as Iranian Rial with Persian numerals
+format(1234.5678, { template: 'irr', language: 'fa' }); // Output: ۱٬۲۳۴٫۵۷ ر
+
+// Formatting as a percentage with low precision
+format(0.1234, { template: 'percent', precision: 'low' }); // Output: 12%
+
+// Formatting with HTML output and custom markers
+format(1234.5678, { outputFormat: 'html', prefixMarker: 'strong', prefix: 'USD ' });
+// Output: <strong>USD </strong>1,234.5678
+
+// Formatting with string input for small or big numbers
+format("0.00000000000000000000005678521", { template: 'usd', precision: 'medium' });
+// Output: $0.0₂₂5678
+```
+
+## TypeScript
+
+`reduce-precision` is written in TypeScript and includes type definitions for all exported functions and interfaces.
+
+## Contributing
+
+Contributions are welcome! If you find a bug or have a feature request, please open an issue on the [GitHub repository](https://github.com/ArzDigitalLabs/reduce-precision). If you'd like to contribute code, please fork the repository and submit a pull request.
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

package/lib/format/index.d.ts

@@ -0,0 +1,16 @@
+declare type Template = 'number' | 'usd' | 'irt' | 'irr' | 'percent';
+declare type Precision = 'auto' | 'high' | 'medium' | 'low';
+declare type Language = 'en' | 'fa';
+declare type OutputFormat = 'plain' | 'html' | 'markdown';
+interface Options {
+    precision?: Precision;
+    template?: Template;
+    language?: Language;
+    outputFormat?: OutputFormat;
+    prefixMarker?: string;
+    postfixMarker?: string;
+    prefix?: string;
+    postfix?: string;
+}
+declare function format(input: string | number, options?: Options): string | number;
+export default format;

package/lib/format/index.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isENotation(input) {
+    return /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/.test(input);
+}
+function convertENotationToRegularNumber(eNotation) {
+    const [coefficientStr, exponentStr] = eNotation.toString().split('e');
+    const coefficientLength = coefficientStr
+        .replace('.', '')
+        .replace('-', '').length;
+    const exponent = parseFloat(exponentStr);
+    const precision = Math.max(coefficientLength - exponent, 1);
+    return eNotation.toFixed(precision);
+}
+function format(input, options = {
+    precision: 'high',
+    template: 'number',
+    language: 'en',
+    outputFormat: 'plain',
+    prefixMarker: 'i',
+    postfixMarker: 'i',
+    prefix: '',
+    postfix: '',
+}) {
+    let { precision, template } = options;
+    const { language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, } = options;
+    if (!input)
+        return 0;
+    if (!(template === null || template === void 0 ? void 0 : template.match(/^(number|usd|irt|irr|percent)$/g)))
+        template = 'number';
+    if (isENotation(input.toString())) {
+        input = convertENotationToRegularNumber(Number(input));
+    }
+    // Replace each Persian/Arabic numeral in the string with its English counterpart and strip all non-numeric chars
+    let numberString = input
+        .toString()
+        .replace(/[\u0660-\u0669\u06F0-\u06F9]/g, function (match) {
+        return String(match.charCodeAt(0) & 0xf);
+    })
+        .replace(/[^\d.-]/g, '');
+    // Stripping leading zeros and trailing zeros after a decimal point
+    numberString = numberString
+        .replace(/^0+(?=\d)/g, '')
+        .replace(/(?<=\.\d*)0+$|(?<=\.\d)0+\b/g, '');
+    const number = Math.abs(Number(numberString));
+    let p, d, r, c;
+    let f = 0;
+    // Auto precision selection
+    if (precision === 'auto') {
+        if (template.match(/^(usd|irt|irr)$/g)) {
+            if (number >= 0.0001 && number < 100000000000) {
+                precision = 'high';
+            }
+            else {
+                precision = 'medium';
+            }
+        }
+        else if (template === 'number') {
+            precision = 'medium';
+        }
+        else if (template === 'percent') {
+            precision = 'low';
+        }
+    }
+    if (precision === 'medium') {
+        if (number >= 0 && number < 0.0001) {
+            p = 33;
+            d = 4;
+            r = false;
+            c = true;
+        }
+        else if (number >= 0.0001 && number < 0.001) {
+            p = 7;
+            d = 4;
+            r = false;
+            c = false;
+        }
+        else if (number >= 0.001 && number < 0.01) {
+            p = 5;
+            d = 3;
+            r = false;
+            c = false;
+        }
+        else if (number >= 0.001 && number < 0.1) {
+            p = 3;
+            d = 2;
+            r = false;
+            c = false;
+        }
+        else if (number >= 0.1 && number < 1) {
+            p = 1;
+            d = 1;
+            r = false;
+            c = false;
+        }
+        else if (number >= 1 && number < 10) {
+            p = 3;
+            d = 3;
+            r = false;
+            c = false;
+        }
+        else if (number >= 10 && number < 100) {
+            p = 2;
+            d = 2;
+            r = false;
+            c = false;
+        }
+        else if (number >= 100 && number < 1000) {
+            p = 1;
+            d = 1;
+            r = false;
+            c = false;
+        }
+        else if (number >= 1000) {
+            const x = Math.floor(Math.log10(number)) % 3;
+            p = 2 - x;
+            d = 2 - x;
+            r = true;
+            c = true;
+        }
+        else {
+            p = 0;
+            d = 0;
+            r = true;
+            c = true;
+        }
+    }
+    else if (precision === 'low') {
+        if (number >= 0 && number < 0.01) {
+            p = 2;
+            d = 0;
+            r = true;
+            c = false;
+            f = 2;
+        }
+        else if (number >= 0.01 && number < 0.1) {
+            p = 2;
+            d = 1;
+            r = true;
+            c = false;
+        }
+        else if (number >= 0.1 && number < 1) {
+            p = 2;
+            d = 2;
+            r = true;
+            c = false;
+        }
+        else if (number >= 1 && number < 10) {
+            p = 2;
+            d = 2;
+            r = true;
+            c = false;
+            f = 2;
+        }
+        else if (number >= 10 && number < 100) {
+            p = 1;
+            d = 1;
+            r = true;
+            c = false;
+            f = 1;
+        }
+        else if (number >= 100 && number < 1000) {
+            p = 0;
+            d = 0;
+            r = true;
+            c = false;
+        }
+        else if (number >= 1000) {
+            const x = Math.floor(Math.log10(number)) % 3;
+            p = 1 - x;
+            d = 1 - x;
+            r = true;
+            c = true;
+        }
+        else {
+            p = 0;
+            d = 0;
+            r = true;
+            c = true;
+            f = 2;
+        }
+    }
+    else {
+        // precision === "high"
+        if (number >= 0 && number < 1) {
+            p = 33;
+            d = 4;
+            r = false;
+            c = false;
+        }
+        else if (number >= 1 && number < 10) {
+            p = 3;
+            d = 3;
+            r = true;
+            c = false;
+        }
+        else if (number >= 10 && number < 100) {
+            p = 2;
+            d = 2;
+            r = true;
+            c = false;
+        }
+        else if (number >= 100 && number < 1000) {
+            p = 2;
+            d = 2;
+            r = true;
+            c = false;
+        }
+        else if (number >= 1000 && number < 10000) {
+            p = 1;
+            d = 1;
+            r = true;
+            c = false;
+        }
+        else {
+            p = 0;
+            d = 0;
+            r = true;
+            c = false;
+        }
+    }
+    return reducePrecision(numberString, p, d, r, c, f, template, language, outputFormat, prefixMarker, postfixMarker, prefix, postfix);
+}
+function reducePrecision(numberString, precision = 30, nonZeroDigits = 4, round = false, compress = false, fixedDecimalZeros = 0, template = 'number', language = 'en', outputFormat = 'plain', prefixMarker = 'span', postfixMarker = 'span', prefix = '', postfix = '') {
+    if (!numberString)
+        return 0;
+    numberString = numberString.toString();
+    const maxPrecision = 30;
+    const maxIntegerDigits = 21;
+    const scaleUnits = template.match(/^(number|percent)$/g)
+        ? {
+            '': '',
+            K: ' هزار',
+            M: ' میلیون',
+            B: ' میلیارد',
+            T: ' تریلیون',
+            Qd: ' کادریلیون',
+            Qt: ' کنتیلیون',
+        }
+        : {
+            '': '',
+            K: ' هزار ت',
+            M: ' میلیون ت',
+            B: ' میلیارد ت',
+            T: ' همت',
+            Qd: ' هزار همت',
+            Qt: ' میلیون همت',
+        };
+    let parts = /^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(numberString);
+    if (!parts) {
+        return 0;
+    }
+    const sign = parts[1] || '';
+    let wholeNumberStr = parts[2];
+    let fractionalZeroStr = parts[3];
+    let fractionalNonZeroStr = parts[4];
+    let unitPrefix = '';
+    let unitPostfix = '';
+    if (fractionalZeroStr.length >= maxPrecision) {
+        // Number is smaller than maximum precision
+        fractionalZeroStr = '0'.padEnd(maxPrecision - 1, '0');
+        fractionalNonZeroStr = '1';
+    }
+    else if (fractionalZeroStr.length + nonZeroDigits > precision) {
+        // decrease non-zero digits
+        nonZeroDigits = precision - fractionalZeroStr.length;
+        if (nonZeroDigits < 1)
+            nonZeroDigits = 1;
+    }
+    else if (wholeNumberStr.length > maxIntegerDigits) {
+        wholeNumberStr = '0';
+        fractionalZeroStr = '';
+        fractionalNonZeroStr = '';
+    }
+    // compress large numbers
+    if (compress && wholeNumberStr.length >= 4) {
+        const scaleUnitKeys = Object.keys(scaleUnits);
+        let scaledWholeNumber = wholeNumberStr;
+        let unitIndex = 0;
+        while (+scaledWholeNumber > 999 && unitIndex < scaleUnitKeys.length - 1) {
+            scaledWholeNumber = (+scaledWholeNumber / 1000).toFixed(2);
+            unitIndex++;
+        }
+        unitPostfix = scaleUnitKeys[unitIndex];
+        parts = /^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(scaledWholeNumber.toString());
+        if (!parts) {
+            return 0;
+        }
+        // sign = parts[1] || "";
+        wholeNumberStr = parts[2];
+        fractionalZeroStr = parts[3];
+        fractionalNonZeroStr = parts[4];
+    }
+    // Truncate the fractional part or round it
+    // if (precision > 0 && nonZeroDigits > 0 && fractionalNonZeroStr.length > nonZeroDigits) {
+    if (fractionalNonZeroStr.length > nonZeroDigits) {
+        if (!round) {
+            fractionalNonZeroStr = fractionalNonZeroStr.substring(0, nonZeroDigits);
+        }
+        else {
+            if (parseInt(fractionalNonZeroStr[nonZeroDigits]) < 5) {
+                fractionalNonZeroStr = fractionalNonZeroStr.substring(0, nonZeroDigits);
+            }
+            else {
+                fractionalNonZeroStr = (parseInt(fractionalNonZeroStr.substring(0, nonZeroDigits)) + 1).toString();
+                // If overflow occurs (e.g., 999 + 1 = 1000), adjust the substring length
+                if (fractionalNonZeroStr.length > nonZeroDigits) {
+                    if (fractionalZeroStr.length > 0) {
+                        fractionalZeroStr = fractionalZeroStr.substring(0, fractionalZeroStr.length - 1);
+                    }
+                    else {
+                        wholeNumberStr = (Number(wholeNumberStr) + 1).toString();
+                        fractionalNonZeroStr = fractionalNonZeroStr.substring(1);
+                    }
+                }
+            }
+        }
+    }
+    // Using dex style
+    if (compress && fractionalZeroStr !== '' && unitPostfix === '') {
+        fractionalZeroStr =
+            '0' +
+                fractionalZeroStr.length.toString().replace(/\d/g, function (match) {
+                    return [
+                        '₀',
+                        '₁',
+                        '₂',
+                        '₃',
+                        '₄',
+                        '₅',
+                        '₆',
+                        '₇',
+                        '₈',
+                        '₉',
+                    ][parseInt(match, 10)];
+                });
+    }
+    let fractionalPartStr = `${fractionalZeroStr}${fractionalNonZeroStr}`;
+    fractionalPartStr = fractionalPartStr.substring(0, precision);
+    fractionalPartStr = fractionalPartStr.replace(/^(\d*[1-9])0+$/g, '$1');
+    // Output Formating, Prefix, Postfix
+    if (template === 'usd') {
+        unitPrefix = language === 'en' ? '$' : '';
+    }
+    else if (template === 'irr') {
+        if (!unitPostfix)
+            unitPostfix = language === 'fa' ? ' ر' : ' R';
+    }
+    else if (template === 'irt') {
+        if (!unitPostfix)
+            unitPostfix = language === 'fa' ? ' ت' : ' T';
+    }
+    else if (template === 'percent') {
+        if (language === 'en') {
+            unitPostfix += '%';
+        }
+        else {
+            unitPostfix += !unitPostfix ? '٪' : ' درصد';
+        }
+    }
+    unitPrefix = prefix + unitPrefix;
+    unitPostfix += postfix;
+    if (outputFormat === 'html') {
+        if (unitPrefix)
+            unitPrefix = `<${prefixMarker}>${unitPrefix}</${prefixMarker}>`;
+        if (unitPostfix)
+            unitPostfix = `<${postfixMarker}>${unitPostfix}</${postfixMarker}>`;
+    }
+    else if (outputFormat === 'markdown') {
+        if (unitPrefix)
+            unitPrefix = `${prefixMarker}${unitPrefix}${prefixMarker}`;
+        if (unitPostfix)
+            unitPostfix = `${postfixMarker}${unitPostfix}${postfixMarker}`;
+    }
+    const thousandSeparatorRegex = /\B(?=(\d{3})+(?!\d))/g;
+    const fixedDecimalZeroStr = fixedDecimalZeros
+        ? '.'.padEnd(fixedDecimalZeros + 1, '0')
+        : '';
+    let out = '';
+    if (precision <= 0 || nonZeroDigits <= 0 || !fractionalNonZeroStr) {
+        out = `${sign}${unitPrefix}${wholeNumberStr.replace(thousandSeparatorRegex, ',')}${fixedDecimalZeroStr}${unitPostfix}`;
+    }
+    else {
+        out = `${sign}${unitPrefix}${wholeNumberStr.replace(thousandSeparatorRegex, ',')}.${fractionalPartStr}${unitPostfix}`;
+    }
+    // Convert output to Persian numerals if language is "fa"
+    if (language === 'fa') {
+        out = out
+            .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]);
+        });
+    }
+    return out;
+}
+console.log(format(3.1227533815325955e-10, { precision: 'low' }));
+console.log(format(3.1227533815325955e-30, { precision: 'low' }));
+console.log(format(3123123123, { precision: 'low' }));
+console.log(format(2, { precision: 'low' }));
+exports.default = format;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import format from './format';
+export { format };

package/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+const format_1 = __importDefault(require("./format"));
+exports.format = format_1.default;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "reduce-precision",
+  "version": "0.0.2",
+  "description": "",
+  "main": "./lib/index.js",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf ./lib/",
+    "lint": "eslint ./src/ --fix",
+    "test:watch": "jest --watch",
+    "test": "jest --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArzDigitalLabs/reduce-precision.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Mohammad Anaraki",
+    "email": "m.anaraki1376@gmail.com",
+    "url": "https://github.com/mohammadanaraki"
+  },
+  "bugs": {
+    "url": "https://github.com/ArzDigitalLabs/reduce-precision/issues"
+  },
+  "homepage": "https://github.com/ArzDigitalLabs/reduce-precision#readme",
+  "devDependencies": {
+    "@types/jest": "^27.5.2",
+    "@types/node": "^12.20.11",
+    "@typescript-eslint/eslint-plugin": "^4.22.0",
+    "@typescript-eslint/parser": "^4.22.0",
+    "eslint": "^7.25.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "jest": "^27.2.0",
+    "lint-staged": "^13.2.1",
+    "prettier": "^2.2.1",
+    "ts-jest": "^27.0.5",
+    "ts-node": "^10.2.1",
+    "typescript": "^4.2.4"
+  },
+  "lint-staged": {
+    "*.ts": "eslint --cache --cache-location .eslintcache --fix"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ]
+  }
+}