n2words 1.13.0 → 1.14.0

package/lib/i18n/TR.mjs

@@ -1,45 +1,40 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsTR extends N2WordsBase {
+export class N2WordsTR extends BaseLanguage {
   constructor(options) {
-    super();
-
-    this.options = Object.assign({
-      dropSpaces: false,
-    }, options);
-
-    this.negativeWord = 'eksi';
-    this.separatorWord = 'virgül';
-    this.zero = 'sıfır';
-    this.spaceSeparator = (this.options.dropSpaces) ? '' : ' ';
-    this.cards = [
-      { '1000000000000000000': 'kentilyon' },
-      { '1000000000000000': 'katrilyon' },
-      { '1000000000000': 'trilyon' },
-      { '1000000000': 'milyar' },
-      { '1000000': 'milyon' },
-      { '1000': 'bin' },
-      { '100': 'yüz' },
-      { '90': 'doksan' },
-      { '80': 'seksen' },
-      { '70': 'yetmiş' },
-      { '60': 'altmış' },
-      { '50': 'elli' },
-      { '40': 'kırk' },
-      { '30': 'otuz' },
-      { '20': 'yirmi' },
-      { '10': 'on' },
-      { '9': 'dokuz' },
-      { '8': 'sekiz' },
-      { '7': 'yedi' },
-      { '6': 'altı' },
-      { '5': 'beş' },
-      { '4': 'dört' },
-      { '3': 'üç' },
-      { '2': 'iki' },
-      { '1': 'bir' },
-      { '0': 'sıfır' }
-    ];
+    super({
+      negativeWord: 'eksi',
+      separatorWord: 'virgül',
+      zero: 'sıfır',
+      spaceSeparator: (options.dropSpaces === true ? '' : ' '),
+    },[
+      [1000000000000000000n, 'kentilyon'],
+      [1000000000000000n, 'katrilyon'],
+      [1000000000000n, 'trilyon'],
+      [1000000000n, 'milyar'],
+      [1000000n, 'milyon'],
+      [1000n, 'bin'],
+      [100n, 'yüz'],
+      [90n, 'doksan'],
+      [80n, 'seksen'],
+      [70n, 'yetmiş'],
+      [60n, 'altmış'],
+      [50n, 'elli'],
+      [40n, 'kırk'],
+      [30n, 'otuz'],
+      [20n, 'yirmi'],
+      [10n, 'on'],
+      [9n, 'dokuz'],
+      [8n, 'sekiz'],
+      [7n, 'yedi'],
+      [6n, 'altı'],
+      [5n, 'beş'],
+      [4n, 'dört'],
+      [3n, 'üç'],
+      [2n, 'iki'],
+      [1n, 'bir'],
+      [0n, 'sıfır']
+    ]);
   }
 
   merge(lPair, rPair) {
@@ -57,6 +52,13 @@ export class N2WordsTR extends N2WordsBase {
   }
 }
 
-export default function(n, options = {}) {
-  return new N2WordsTR(options).floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @param {object} options Options for class.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value, options = {}) {
+  return new N2WordsTR(options).floatToCardinal(value);
 }

package/lib/i18n/UK.mjs

@@ -2,11 +2,12 @@ import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsUK extends N2WordsRU {
   constructor() {
-    super();
+    super({
+      negativeWord: 'мiнус',
+      separatorWord: 'кома',
+      zero: 'нуль'
+    });
 
-    this.negativeWord = 'мiнус';
-    this.separatorWord = 'кома';
-    this.zero = 'нуль';
     this.feminine = false;
     this.ones = {
       1: 'один',
@@ -78,6 +79,12 @@ export class N2WordsUK extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsUK().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsUK().floatToCardinal(value);
 }

package/lib/i18n/VI.mjs

@@ -1,12 +1,13 @@
-import N2WordsAbs from '../classes/N2WordsAbs.mjs';
+import AbstractLanguage from '../classes/AbstractLanguage.mjs';
 
-export class N2WordsID extends N2WordsAbs {
+export class N2WordsID extends AbstractLanguage {
   constructor() {
-    super();
+    super({
+      negativeWord: 'âm',
+      separatorWord: 'phẩy',
+      zero: 'không'
+    });
 
-    this.negativeWord = 'âm';
-    this.separatorWord = 'phẩy';
-    this.zero = 'không';
     this.base = {
       0: 'không',
       1: 'một',
@@ -67,15 +68,15 @@ export class N2WordsID extends N2WordsAbs {
     let unitsPart = number % 10;
     let tensPart = number - unitsPart;
     let tensPartText = this.tens[tensPart];
-    if (unitsPart === 0) {
+    if (unitsPart == 0) {
       return tensPartText;
     }
     let unitsPartText = this.base[unitsPart];
     let suffix = unitsPartText;
-    if (unitsPart === 1) {
+    if (unitsPart == 1) {
       suffix = 'mốt';
     }
-    if (unitsPart === 5) {
+    if (unitsPart == 5) {
       suffix = 'lăm';
     }
     return tensPartText + ' ' + suffix;
@@ -92,7 +93,7 @@ export class N2WordsID extends N2WordsAbs {
       if (words.length > 0) {
         words.push('lẻ');
       }
-      if (tensUnitsPart === 5) {
+      if (tensUnitsPart == 5) {
         words.push('năm');
       } else {
         words.push(this.base[tensUnitsPart]);
@@ -106,16 +107,16 @@ export class N2WordsID extends N2WordsAbs {
 
   convertMore1000(number) {
     let words = [];
-    let division = Math.floor(number / 1000);
+    let division = number / 1000n;
     let power = 1;
-    while (division >= 1000) {
-      division = Math.floor(division / 1000);
+    while (division >= 1000n) {
+      division = division / 1000n;
       power = power + 1;
     }
-    let r = number - (division * Math.pow(1000, power));
+    let r = number - (division * BigInt(Math.pow(1000, power)));
     words.push(this.toCardinal(division), this.thousands[power]);
-    if (r > 0) {
-      if (r <= 99) {
+    if (r > 0n) {
+      if (r <= 99n) {
         words.push('lẻ');
       }
       words.push(this.toCardinal(r));
@@ -124,14 +125,14 @@ export class N2WordsID extends N2WordsAbs {
   }
 
   toCardinal(number) {
-    if (number < 20) {
-      return this.base[number];
+    if (number < 20n) {
+      return this.base[Number(number)];
     } else {
-      if (number < 100) {
-        return this.convertLess100(number);
+      if (number < 100n) {
+        return this.convertLess100(Number(number));
       } else {
-        if (number < 1000) {
-          return this.convertLess1000(number);
+        if (number < 1000n) {
+          return this.convertLess1000(Number(number));
         } else { // number >= 1000
           return this.convertMore1000(number);
         }
@@ -140,6 +141,12 @@ export class N2WordsID extends N2WordsAbs {
   }
 }
 
-export default function (n) {
-  return new N2WordsID().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function (value) {
+  return new N2WordsID().floatToCardinal(value);
 }

package/lib/i18n/ZH.mjs

@@ -1,31 +1,30 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsZH extends N2WordsBase {
+export class N2WordsZH extends BaseLanguage {
   constructor() {
-    super();
-
-    this.negativeWord = '负';
-    this.separatorWord = '点';
-    this.zero = '零';
-    this.spaceSeparator = ''; // no
-    this.cards = [
-      { 1000000000000: '万' },
-      { 100000000: '亿' },
-      { 10000: '万' },
-      { 1000: '仟' },
-      { 100: '佰' },
-      { 10: '拾' },
-      { 9: '玖' },
-      { 8: '捌' },
-      { 7: '柒' },
-      { 6: '陆' },
-      { 5: '伍' },
-      { 4: '肆' },
-      { 3: '叁' },
-      { 2: '贰' },
-      { 1: '壹' },
-      { 0: '零' },
-    ];
+    super({
+      negativeWord: '负',
+      separatorWord: '点',
+      zero: '零',
+      spaceSeparator: ''
+    },[
+      [1000000000000n, '万'],
+      [100000000n, '亿'],
+      [10000n, '万'],
+      [1000n, '仟'],
+      [100n, '佰'],
+      [10n, '拾'],
+      [9n, '玖'],
+      [8n, '捌'],
+      [7n, '柒'],
+      [6n, '陆'],
+      [5n, '伍'],
+      [4n, '肆'],
+      [3n, '叁'],
+      [2n, '贰'],
+      [1n, '壹'],
+      [0n, '零']
+    ]);
   }
 
   merge(lPair, rPair) {
@@ -48,10 +47,11 @@ export class N2WordsZH extends N2WordsBase {
     return result;
   }
 
-  toDecimal(decimalPart) {
-    const decimalPartArray = Array.from(decimalPart);
+  decimalToCardinal(decimal) {
+    const decimalPartArray = decimal.split('');
+
     const decimalPartWordsArray = decimalPartArray.map(decimal =>
-      this.getValueFromCards(decimal)
+      this.getCardWord(decimal)
     );
 
     return decimalPartWordsArray.join(this.spaceSeparator);
@@ -62,10 +62,16 @@ export class N2WordsZH extends N2WordsBase {
   }
 
   zeroDigit(num) {
-    return Array.from(num.toString()).filter(c => c === '0').length;
+    return Array.from(num.toString()).filter(c => c == '0').length;
   }
 }
 
-export default function(n) {
-  return new N2WordsZH().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsZH().floatToCardinal(value);
 }

package/lib/n2words.mjs

@@ -27,115 +27,41 @@ import n2wordsUK from './i18n/UK.mjs';
 import n2wordsVI from './i18n/VI.mjs';
 import n2wordsZH from './i18n/ZH.mjs';
 
-const supportedLanguages = [
-  'en',
-  'fr',
-  'es',
-  'de',
-  'pt',
-  'it',
-  'tr',
-  'ru',
-  'cz',
-  'no',
-  'dk',
-  'pl',
-  'uk',
-  'lt',
-  'lv',
-  'ar',
-  'he',
-  'ko',
-  'nl',
-  'sr',
-  'fa',
-  'zh',
-  'hu',
-  'id',
-  'hr',
-  'vi',
-  'az',
-];
-
 /**
  * Converts a number to written form.
- *
- * @param {number} n The number to convert.
+ * @param {number|string} value The number to convert.
  * @param {object} [options={lang: "en"}] User options.
- * @returns {string} Resulting text value.
+ * @returns {string} Value in written format.
  */
-export default function(n, options = {lang: 'en'}) {
-  let lang = 'EN'; // default language
-
-  if (options) {
-    if (options.lang) {
-      // lang is given in options
-      if (supportedLanguages.indexOf(options.lang) !== -1)
-        lang = options.lang.toUpperCase();
-      else
-        throw Error(
-          'ERROR: Unsupported language. Supported languages are: ' +
-            supportedLanguages.sort().join(', ')
-        );
-    }
-  }
-
-  if (lang === 'EN') {
-    return n2wordsEN(n);
-  } else if (lang === 'FR') {
-    return n2wordsFR(n);
-  } else if (lang === 'ES') {
-    return n2wordsES(n);
-  } else if (lang === 'DE') {
-    return n2wordsDE(n);
-  } else if (lang === 'PT') {
-    return n2wordsPT(n);
-  } else if (lang === 'ID') {
-    return n2wordsID(n);
-  } else if (lang === 'IT') {
-    return n2wordsIT(n);
-  } else if (lang === 'TR') {
-    return n2wordsTR(n, options);
-  } else if (lang === 'RU') {
-    return n2wordsRU(n);
-  } else if (lang === 'CZ') {
-    return n2wordsCZ(n);
-  } else if (lang === 'NO') {
-    return n2wordsNO(n);
-  } else if (lang === 'DK') {
-    return n2wordsDK(n);
-  } else if (lang === 'PL') {
-    return n2wordsPL(n);
-  } else if (lang === 'UK') {
-    return n2wordsUK(n);
-  } else if (lang === 'LT') {
-    return n2wordsLT(n);
-  } else if (lang === 'LV') {
-    return n2wordsLV(n);
-  } else if (lang === 'AR') {
-    return n2wordsAR(n);
-  } else if (lang === 'HE') {
-    // only for numbers <= 9999
-    return n2wordsHE(n);
-  } else if (lang === 'HR') {
-    return n2wordsHR(n);
-  } else if (lang === 'HU') {
-    return n2wordsHU(n);
-  } else if (lang === 'KO') {
-    return n2wordsKO(n);
-  } else if (lang === 'NL') {
-    return n2wordsNL(n, options);
-  } else if (lang === 'SR') {
-    return n2wordsSR(n);
-  } else if (lang === 'FA') {
-    return n2wordsFA(n);
-  } else if (lang === 'ZH') {
-    return n2wordsZH(n);
-  } else if (lang === 'VI') {
-    return n2wordsVI(n);
-  } else if (lang === 'AZ') {
-    return n2wordsAZ(n);
-  } else {
-    return n2wordsEN(n);
+export default function(value, options = {lang: 'en'}) {
+  switch (options.lang) {
+    case 'en': return n2wordsEN(value);
+    case 'fr': return n2wordsFR(value);
+    case 'es': return n2wordsES(value);
+    case 'de': return n2wordsDE(value);
+    case 'pt': return n2wordsPT(value);
+    case 'it': return n2wordsIT(value);
+    case 'tr': return n2wordsTR(value, options);
+    case 'ru': return n2wordsRU(value);
+    case 'cz': return n2wordsCZ(value);
+    case 'no': return n2wordsNO(value);
+    case 'dk': return n2wordsDK(value);
+    case 'pl': return n2wordsPL(value);
+    case 'uk': return n2wordsUK(value);
+    case 'lt': return n2wordsLT(value);
+    case 'lv': return n2wordsLV(value);
+    case 'ar': return n2wordsAR(value);
+    case 'he': return n2wordsHE(value); // only for numbers <= 9999
+    case 'ko': return n2wordsKO(value);
+    case 'nl': return n2wordsNL(value, options);
+    case 'sr': return n2wordsSR(value);
+    case 'fa': return n2wordsFA(value);
+    case 'zh': return n2wordsZH(value);
+    case 'hu': return n2wordsHU(value);
+    case 'id': return n2wordsID(value);
+    case 'hr': return n2wordsHR(value);
+    case 'vi': return n2wordsVI(value);
+    case 'az': return n2wordsAZ(value);
+    default: throw Error('Unsupported language: ' + value + '.');
   }
 }

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "n2words",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Convert numbers to words, in multiple languages",
   "main": "dist/n2words.js",
   "scripts": {
     "lint": "eslint --config .eslintrc.json lib/ test/",
     "test": "ava --verbose",
     "coverage": "c8 ava",
-    "build": "webpack --config webpack.config.js --progress"
+    "build": "webpack --config webpack.config.js --progress",
+    "bench": "node bench.mjs"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/forzagreen/n2words.git"
   },
+  "engines": {
+    "node": "16 || >=18"
+  },
   "keywords": [
     "n2words",
     "convert",
@@ -57,19 +61,21 @@
   },
   "homepage": "https://github.com/forzagreen/n2words#readme",
   "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/preset-env": "^7.20.2",
+    "@babel/core": "^7.21.8",
+    "@babel/preset-env": "^7.21.5",
     "ava": "^5.2.0",
     "babel-loader": "^9.1.2",
-    "c8": "^7.12.0",
-    "core-js": "^3.27.2",
-    "eslint": "^8.33.0",
+    "benchmark": "^2.1.4",
+    "c8": "^7.13.0",
+    "core-js": "^3.30.2",
+    "eslint": "^8.40.0",
     "eslint-plugin-ava": "^14.0.0",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-jsdoc": "^39.8.0",
+    "eslint-plugin-jsdoc": "^44.2.3",
     "eslint-plugin-node": "^11.1.0",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.1"
+    "microtime": "^3.1.1",
+    "webpack": "^5.82.1",
+    "webpack-cli": "^5.1.1"
   },
   "ava": {
     "files": [

package/webpack.config.js

@@ -20,7 +20,7 @@ module.exports = {
               '@babel/preset-env',
               {
                 useBuiltIns: 'usage',
-                corejs: '3.27.2',
+                corejs: '3.30.1',
               },
             ],
           ],

package/lib/classes/N2WordsAbs.mjs

@@ -1,72 +0,0 @@
-/**
- * Abstract class that must be inherited by all languages.
- */
-export default class {
-  constructor() {
-    this.negativeWord = '';
-    this.separatorWord;
-    this.zero;
-    this.spaceSeparator = ' ';
-  }
-
-  /**
-   * Convert a number to cardinal (written) format.
-   *
-   * @param {number} value The number value to convert to cardinal form.
-   * @returns {string} Cardinal representation of number value.
-   */
-  toCardinal(value) {
-    return value;
-  }
-
-  /**
-   *
-   * @param {number} decimalPart Decimal part of the number to convert.
-   * @returns {string} Decimal part in written format.
-   */
-  toDecimal(decimalPart) {
-    let decimalPartArray = Array.from(decimalPart);
-    let decimalPartWordsArray = [];
-    while (decimalPartArray[0] === '0') {
-      // Leading zeros
-      decimalPartArray.shift();
-      decimalPartWordsArray.push(this.zero);
-    }
-    decimalPartWordsArray.push(this.toCardinal(parseInt(decimalPart, 10)));
-
-    return decimalPartWordsArray.join(this.spaceSeparator);
-  }
-
-  /**
-   *
-   * @param {number} value Float number.
-   * @throws {TypeError} Value must be a valid number.
-   * @returns {string|undefined} Cardinal number in written format.
-   */
-  floatToCardinal(value) {
-    if (isNaN(Number(value))) {
-      throw new TypeError(`Invalid number: ${value}, of type: ${typeof value}`);
-    }
-    value = Number(value);
-    let words = [];
-    let positiveValue = Math.abs(value);
-    if (value % 1 === 0 || typeof this.separatorWord === 'undefined') {
-      // if value is integer or if separatorWord is not defined
-      words = [this.toCardinal(positiveValue)];
-    } else {
-      const splittedValue = positiveValue.toString().split('.');
-      const wholeNumberStr = this.toCardinal(parseInt(splittedValue[0], 10));
-      this.wholeNumberInt = parseInt(splittedValue[0]);
-
-      let decimalPart = splittedValue[1];
-
-      const decimalPartStr = this.toDecimal(decimalPart);
-      words = [wholeNumberStr, this.separatorWord, decimalPartStr];
-    }
-    if (value < 0) {
-      // negative numbers
-      words = [this.negativeWord].concat(words);
-    }
-    return words.join(this.spaceSeparator);
-  }
-}