reduce-precision 0.0.2 → 1.0.0

package/README.md

@@ -1,5 +1,11 @@
 # reduce-precision
 
+[![Known Vulnerabilities](https://snyk.io/test/github/ArzDigitalLabs/reduce-precision/badge.svg?targetFile=package.json)](https://snyk.io/test/github/ArzDigitalLabs/reduce-precision?targetFile=package.json)
+[![Build Status](https://travis-ci.org/ArzDigitalLabs/reduce-precision.svg?branch=master)](https://travis-ci.org/ArzDigitalLabs/reduce-precision)
+[![codecov.io Code Coverage](https://img.shields.io/codecov/c/github/ArzDigitalLabs/reduce-precision.svg?maxAge=2592000)](https://codecov.io/github/ArzDigitalLabs/reduce-precision?branch=master)
+[![Code Climate](https://codeclimate.com/github/ArzDigitalLabs/reduce-precision/badges/gpa.svg)](https://codeclimate.com/github/ArzDigitalLabs/reduce-precision)
+[![NPM Version](https://badge.fury.io/js/reduce-precision.svg?style=flat)](https://npmjs.org/package/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
@@ -21,22 +27,36 @@ You can install `reduce-precision` using npm:
 npm install reduce-precision
 ```
 
+[![NPM Download Stats](https://nodei.co/npm/reduce-precision.png?downloads=true)](https://www.npmjs.com/package/reduce-precision)
+
 ## Usage
 
 ### JavaScript (CommonJS)
 
 ```javascript
-const { format } = require('reduce-precision');
+const { NumberFormatter } = require('reduce-precision');
+
+const formatter = new NumberFormatter();
 
-const formatted = format(123456, options);
+formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' });
+
+console.log(formatter.toHtmlString(123456789));
+console.log(formatter.format(123456789));
+console.log(formatter.toString(123456789));
 ```
 
 ### TypeScript or ES Modules
 
 ```typescript
-import { format } from 'reduce-precision';
+import { NumberFormatter } from 'reduce-precision';
+
+const formatter = new NumberFormatter();
 
-const formatted = format(123456, options);
+formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' });
+
+console.log(formatter.toHtmlString(123456789));
+console.log(formatter.format(123456789));
+console.log(formatter.toString(123456789));
 ```
 
 ## Options
@@ -57,32 +77,118 @@ The `format` function accepts an optional `options` object with the following pr
 ## Examples
 
 ```typescript
-import { format } from 'reduce-precision';
+import { NumberFormatter } from 'reduce-precision';
+
+// Create a formatter instance with default options
+const formatter = new NumberFormatter();
+
+// Create a formatter instance with custom options
+const formatterWithOptions = new NumberFormatter({
+  language: 'fa',
+  template: 'irr',
+  precision: 'medium',
+  prefixMarker: 'strong',
+  postfixMarker: 'em',
+  prefix: 'مبلغ: ',
+  postfix: ' ریال'
+});
+
+// Basic usage
+formatter.setLanguage('en');
 
 // Basic number formatting
-format(1234.5678); // Output: 1,234.5678
+formatter.format(1234.5678); // Output: { value: '1,234.6', ... }
 
 // Formatting with medium precision
-format(1234.5678, { precision: 'medium' }); // Output: 1,234.57
+formatter.setTemplate('number', 'medium').format(1234.5678); // Output: { value: '1.23K', ... }
 
 // Formatting as USD
-format(1234.5678, { template: 'usd' }); // Output: $1,234.5678
+formatter.setTemplate('usd', 'high').format(1234.5678); // Output: { value: '$1,234.6', ... }
 
 // Formatting as Iranian Rial with Persian numerals
-format(1234.5678, { template: 'irr', language: 'fa' }); // Output: ۱٬۲۳۴٫۵۷ ر
+formatterWithOptions.format(1234.5678);
+// Output: { value: 'مبلغ: ۱٫۲۳ هزار ت', ... }
 
 // Formatting as a percentage with low precision
-format(0.1234, { template: 'percent', precision: 'low' }); // Output: 12%
+formatter.setTemplate('percent', 'low').format(0.1234); // Output: { value: '0.12%', ... }
 
 // Formatting with HTML output and custom markers
-format(1234.5678, { outputFormat: 'html', prefixMarker: 'strong', prefix: 'USD ' });
-// Output: <strong>USD </strong>1,234.5678
+
+formatter.setLanguage('en', { prefixMarker: 'strong', prefix: 'USD ' }).toHtmlString(1234.5678);
+// Output: <strong>USD </strong>1,234.6
 
 // Formatting with string input for small or big numbers
-format("0.00000000000000000000005678521", { template: 'usd', precision: 'medium' });
-// Output: $0.0₂₂5678
+
+formatter.setTemplate('usd', 'medium').format("0.00000000000000000000005678521");
+// Output: { value: '$0.0₂₂5678', ... }
 ```
 
+## API
+
+### `FormattedObject` Interface
+
+The `FormattedObject` interface represents the structure of the formatted number object returned by the `format` method.
+
+```typescript
+interface FormattedObject {
+  value: string;           // The formatted value as a string
+  prefix: string;          // The prefix string
+  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
+}
+```
+
+### `NumberFormatter` Class
+
+#### `constructor(options?: FormatterOptions)`
+
+Creates a new instance of the `NumberFormatter` class with optional configuration options.
+
+- `options` (optional): An object containing the initial configuration options for the formatter.
+
+#### `setLanguage(lang: Language, config?: LanguageConfig): NumberFormatter`
+
+Sets the language and optional language configuration for the formatter.
+
+- `lang`: The language to be used for formatting (`'en'` for English or `'fa'` for Persian).
+- `config` (optional): An object containing additional language configuration options.
+  - `prefixMarker` (optional): The marker for the prefix in HTML or Markdown output (default: `'i'`).
+  - `postfixMarker` (optional): The marker for the postfix in HTML or Markdown output (default: `'i'`).
+  - `prefix` (optional): The prefix string to be added before the formatted number.
+  - `postfix` (optional): The postfix string to be added after the formatted number.
+
+Returns the `NumberFormatter` instance for method chaining.
+
+#### `setTemplate(template: Template, precision: Precision): NumberFormatter`
+
+Sets the template and precision for the formatter.
+
+- `template`: The template to be used for formatting (`'number'`, `'usd'`, `'irt'`, `'irr'`, or `'percent'`).
+- `precision`: The precision level for formatting (`'high'`, `'medium'`, `'low'`, or `'auto'`).
+
+Returns the `NumberFormatter` instance for method chaining.
+
+#### `format(input: string | number): FormattedObject`
+
+Formats the input number and returns the formatted object.
+
+- `input`: The number to be formatted, either as a string or a number.
+
+Returns the formatted object.
+
+#### `toHtmlString(): string`
+
+Returns the formatted value as an HTML string.
+
+#### `toString(): string`
+
+Returns the formatted value as a plain string.
+
 ## TypeScript
 
 `reduce-precision` is written in TypeScript and includes type definitions for all exported functions and interfaces.

package/package.json

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

package/lib/format/index.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,402 +0,0 @@
-"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

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

package/lib/index.js

@@ -1,8 +0,0 @@
-"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;