reduce-precision 1.0.0 → 1.0.1

package/lib/format/index.d.ts

@@ -0,0 +1,47 @@
+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;
+}
+interface FormattedObject {
+    value?: string;
+    prefix: string;
+    postfix: string;
+    sign: string;
+    wholeNumber: string;
+    fractionalPart: string;
+    fractionalNonZeros: string;
+    fractionalZerosCount: number;
+    unit?: string;
+}
+interface LanguageConfig {
+    prefixMarker?: string;
+    postfixMarker?: string;
+    prefix?: string;
+    postfix?: string;
+}
+declare class NumberFormatter {
+    private options;
+    constructor(options?: Options);
+    setLanguage(lang: Language, config?: LanguageConfig): NumberFormatter;
+    setTemplate(template: Template, precision: Precision): NumberFormatter;
+    toJson(input: string | number): FormattedObject;
+    toString(input: string | number): string;
+    toPlainString(input: string | number): string;
+    toHtmlString(input: string | number): string;
+    toMdString(input: string | number): string;
+    private isENotation;
+    private format;
+    private convertENotationToRegularNumber;
+    private reducePrecision;
+}
+export default NumberFormatter;

package/lib/format/index.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NumberFormatter {
+    constructor(options = {}) {
+        this.options = {
+            language: 'en',
+            template: 'number',
+            precision: 'high',
+            outputFormat: 'plain',
+            prefixMarker: 'i',
+            postfixMarker: 'i',
+            prefix: '',
+            postfix: '',
+        };
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+    setLanguage(lang, config = {}) {
+        this.options.language = lang;
+        this.options.prefixMarker =
+            config.prefixMarker || this.options.prefixMarker;
+        this.options.postfixMarker =
+            config.postfixMarker || this.options.postfixMarker;
+        this.options.prefix = config.prefix || this.options.prefix;
+        this.options.postfix = config.postfix || this.options.postfix;
+        return this;
+    }
+    setTemplate(template, precision) {
+        this.options.template = template;
+        this.options.precision = precision;
+        return this;
+    }
+    toJson(input) {
+        const formattedObject = this.format(input);
+        delete formattedObject.value;
+        return formattedObject;
+    }
+    toString(input) {
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toPlainString(input) {
+        this.options.outputFormat = 'plain';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toHtmlString(input) {
+        this.options.outputFormat = 'html';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toMdString(input) {
+        this.options.outputFormat = 'markdown';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    // Private methods...
+    isENotation(input) {
+        return /^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)$/.test(input);
+    }
+    format(input) {
+        let { precision, template } = this.options;
+        const { language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, } = this.options;
+        if (!input)
+            return {};
+        if (!(template === null || template === void 0 ? void 0 : template.match(/^(number|usd|irt|irr|percent)$/g)))
+            template = 'number';
+        if (this.isENotation(input.toString())) {
+            input = this.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 this.reducePrecision(numberString, p, d, r, c, f, template, language, outputFormat, prefixMarker, postfixMarker, prefix, postfix);
+    }
+    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);
+    }
+    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 {};
+        }
+        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 {};
+        }
+        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 {};
+            }
+            // 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);
+                        }
+                    }
+                }
+            }
+        }
+        const orginalFractionalZeroStr = fractionalZeroStr;
+        // 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]);
+            });
+        }
+        const formattedObject = {
+            value: out,
+            prefix: unitPrefix,
+            postfix: unitPostfix.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,
+        };
+        return formattedObject;
+    }
+}
+exports.default = NumberFormatter;

package/lib/index.d.ts

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

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.NumberFormatter = void 0;
+const format_1 = __importDefault(require("./format"));
+exports.NumberFormatter = format_1.default;

package/package.json

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