n2words 1.13.0 → 1.15.0

package/lib/i18n/CZ.mjs

@@ -1,97 +1,100 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsCZ extends N2WordsRU {
-  constructor() {
-    super();
+  ones = {
+    1: 'jedna',
+    2: 'dva',
+    3: 'tři',
+    4: 'čtyři',
+    5: 'pět',
+    6: 'šest',
+    7: 'sedm',
+    8: 'osm',
+    9: 'devět'
+  };
 
-    this.negativeWord = 'mínus';
-    this.zero = 'nula';
-    this.ones = {
-      1: 'jedna',
-      2: 'dva',
-      3: 'tři',
-      4: 'čtyři',
-      5: 'pět',
-      6: 'šest',
-      7: 'sedm',
-      8: 'osm',
-      9: 'devět'
-    };
-    this.tens = {
-      0: 'deset',
-      1: 'jedenáct',
-      2: 'dvanáct',
-      3: 'třináct',
-      4: 'čtrnáct',
-      5: 'patnáct',
-      6: 'šestnáct',
-      7: 'sedmnáct',
-      8: 'osmnáct',
-      9: 'devatenáct'
-    };
-    this.twenties = {
-      2: 'dvacet',
-      3: 'třicet',
-      4: 'čtyřicet',
-      5: 'padesát',
-      6: 'šedesát',
-      7: 'sedmdesát',
-      8: 'osmdesát',
-      9: 'devadesát'
-    };
-    this.hundreds = {
-      1: 'sto',
-      2: 'dvě stě',
-      3: 'tři sta',
-      4: 'čtyři sta',
-      5: 'pět set',
-      6: 'šest set',
-      7: 'sedm set',
-      8: 'osm set',
-      9: 'devět set'
-    };
-    this.thousands = {
-      1: ['tisíc', 'tisíce', 'tisíc'], // 10^ 3
-      2: ['milion', 'miliony', 'milionů'], // 10^ 6
-      3: ['miliarda', 'miliardy', 'miliard'], // 10^ 9
-      4: ['bilion', 'biliony', 'bilionů'], // 10^ 12
-      5: ['biliarda', 'biliardy', 'biliard'], // 10^ 15
-      6: ['trilion', 'triliony', 'trilionů'], // 10^ 18
-      7: ['triliarda', 'triliardy', 'triliard'], // 10^ 21
-      8: ['kvadrilion', 'kvadriliony', 'kvadrilionů'], // 10^ 24
-      9: ['kvadriliarda', 'kvadriliardy', 'kvadriliard'], // 10^ 27
-      10: ['quintillion', 'quintilliony', 'quintillionů'], // 10^ 30
-    };
+  tens = {
+    0: 'deset',
+    1: 'jedenáct',
+    2: 'dvanáct',
+    3: 'třináct',
+    4: 'čtrnáct',
+    5: 'patnáct',
+    6: 'šestnáct',
+    7: 'sedmnáct',
+    8: 'osmnáct',
+    9: 'devatenáct'
+  };
+
+  twenties = {
+    2: 'dvacet',
+    3: 'třicet',
+    4: 'čtyřicet',
+    5: 'padesát',
+    6: 'šedesát',
+    7: 'sedmdesát',
+    8: 'osmdesát',
+    9: 'devadesát'
+  };
+
+  hundreds = {
+    1: 'sto',
+    2: 'dvě stě',
+    3: 'tři sta',
+    4: 'čtyři sta',
+    5: 'pět set',
+    6: 'šest set',
+    7: 'sedm set',
+    8: 'osm set',
+    9: 'devět set'
+  };
+
+  thousands = {
+    1: ['tisíc', 'tisíce', 'tisíc'], // 10^ 3
+    2: ['milion', 'miliony', 'milionů'], // 10^ 6
+    3: ['miliarda', 'miliardy', 'miliard'], // 10^ 9
+    4: ['bilion', 'biliony', 'bilionů'], // 10^ 12
+    5: ['biliarda', 'biliardy', 'biliard'], // 10^ 15
+    6: ['trilion', 'triliony', 'trilionů'], // 10^ 18
+    7: ['triliarda', 'triliardy', 'triliard'], // 10^ 21
+    8: ['kvadrilion', 'kvadriliony', 'kvadrilionů'], // 10^ 24
+    9: ['kvadriliarda', 'kvadriliardy', 'kvadriliard'], // 10^ 27
+    10: ['quintillion', 'quintilliony', 'quintillionů'], // 10^ 30
+  };
+
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'mínus',
+      zero: 'nula'
+    }, options));
   }
 
   get separatorWord() {
-    if (this.wholeNumberInt === 0 || this.wholeNumberInt === 1) {
+    if (this.wholeNumber == 0n || this.wholeNumber == 1n) {
       return 'celá';
-    } else if (this.wholeNumberInt >= 2 && this.wholeNumberInt <= 4) {
+    } else if (this.wholeNumber >= 2n && this.wholeNumber <= 4n) {
       return 'celé';
     } else {
       return 'celých';
     }
   }
 
-  set separatorWord(value) {}
-
   pluralize(n, forms) {
     let form = 2;
     if (n == 1) {
       form = 0;
-    } else if (((n % 10 < 5) && (n % 10 > 1)) && (n % 100 < 10 || n % 100 > 20)) {
+    } else if (((n % 10n < 5n) && (n % 10n > 1n)) && (n % 100n < 10n || n % 100n > 20n)) {
       form = 1;
     }
     return forms[form];
   }
 
   toCardinal(number) {
-    if (parseInt(number) == 0) {
+    if (number == 0) {
       return this.zero;
     }
     const words = [];
-    const chunks = this.splitByX(JSON.stringify(number), 3);
+    const chunks = this.splitByX(number.toString(), 3);
     let i = chunks.length;
     for (let j = 0; j < chunks.length; j++) {
       const x = chunks[j];
@@ -119,6 +122,13 @@ export class N2WordsCZ extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsCZ().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 N2WordsCZ(options).floatToCardinal(value);
 }

package/lib/i18n/DE.mjs

@@ -1,52 +1,51 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsDE extends N2WordsBase {
-  constructor() {
-    super();
-
-    this.negativeWord = 'minus';
-    this.separatorWord = 'komma';
-    this.zero = 'null';
-    this.cards = [
-      { '1000000000000000000000000000': 'Quadrilliarde' },
-      { '1000000000000000000000000': 'Quadrillion' },
-      { '1000000000000000000000': 'Trilliarde' },
-      { 1000000000000000000: 'Trillion' },
-      { 1000000000000000: 'Billiarde' },
-      { 1000000000000: 'Billion' },
-      { 1000000000: 'Milliarde' },
-      { 1000000: 'Million' },
-      { 1000: 'tausend' },
-      { 100: 'hundert' },
-      { 90: 'neunzig' },
-      { 80: 'achtzig' },
-      { 70: 'siebzig' },
-      { 60: 'sechzig' },
-      { 50: 'fünfzig' },
-      { 40: 'vierzig' },
-      { 30: 'dreißig' },
-      { 20: 'zwanzig' },
-      { 19: 'neunzehn' },
-      { 18: 'achtzehn' },
-      { 17: 'siebzehn' },
-      { 16: 'sechzehn' },
-      { 15: 'fünfzehn' },
-      { 14: 'vierzehn' },
-      { 13: 'dreizehn' },
-      { 12: 'zwölf' },
-      { 11: 'elf' },
-      { 10: 'zehn' },
-      { 9: 'neun' },
-      { 8: 'acht' },
-      { 7: 'sieben' },
-      { 6: 'sechs' },
-      { 5: 'fünf' },
-      { 4: 'vier' },
-      { 3: 'drei' },
-      { 2: 'zwei' },
-      { 1: 'eins' },
-      { 0: 'null' }
-    ];
+export class N2WordsDE extends BaseLanguage {
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'null'
+    }, options), [
+      [1000000000000000000000000000n, 'Quadrilliarde'],
+      [1000000000000000000000000n, 'Quadrillion'],
+      [1000000000000000000000n, 'Trilliarde'],
+      [1000000000000000000n, 'Trillion'],
+      [1000000000000000n, 'Billiarde'],
+      [1000000000000n, 'Billion'],
+      [1000000000n, 'Milliarde'],
+      [1000000n, 'Million'],
+      [1000n, 'tausend'],
+      [100n, 'hundert'],
+      [90n, 'neunzig'],
+      [80n, 'achtzig'],
+      [70n, 'siebzig'],
+      [60n, 'sechzig'],
+      [50n, 'fünfzig'],
+      [40n, 'vierzig'],
+      [30n, 'dreißig'],
+      [20n, 'zwanzig'],
+      [19n, 'neunzehn'],
+      [18n, 'achtzehn'],
+      [17n, 'siebzehn'],
+      [16n, 'sechzehn'],
+      [15n, 'fünfzehn'],
+      [14n, 'vierzehn'],
+      [13n, 'dreizehn'],
+      [12n, 'zwölf'],
+      [11n, 'elf'],
+      [10n, 'zehn'],
+      [9n, 'neun'],
+      [8n, 'acht'],
+      [7n, 'sieben'],
+      [6n, 'sechs'],
+      [5n, 'fünf'],
+      [4n, 'vier'],
+      [3n, 'drei'],
+      [2n, 'zwei'],
+      [1n, 'eins'],
+      [0n, 'null']
+    ]);
   }
 
   merge(curr, next) {
@@ -94,6 +93,13 @@ export class N2WordsDE extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsDE().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 N2WordsDE(options).floatToCardinal(value);
 }

package/lib/i18n/DK.mjs

@@ -1,53 +1,58 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsDK extends N2WordsBase {
-  constructor() {
-    super();
+export class N2WordsDK extends BaseLanguage {
+  ordFlag;
 
-    this.negativeWord = 'minus';
-    this.separatorWord = 'komma';
-    this.zero = 'nul';
-    this.ordFlag = false;
-    this.cards = [
-      { '1000000000000000000000000000': 'quadrillarder' },
-      { '1000000000000000000000000': 'quadrillioner' },
-      { '1000000000000000000000': 'trillarder' },
-      { '1000000000000000000': 'trillioner' },
-      { '1000000000000000': 'billarder' },
-      { '1000000000000': 'billioner' },
-      { '1000000000': 'millarder' },
-      { '1000000': 'millioner' },
-      { '1000': 'tusind' },
-      { '100': 'hundrede' },
-      { '90': 'halvfems' },
-      { '80': 'firs' },
-      { '70': 'halvfjerds' },
-      { '60': 'treds' },
-      { '50': 'halvtreds' },
-      { '40': 'fyrre' },
-      { '30': 'tredive' },
-      { '20': 'tyve' },
-      { '19': 'nitten' },
-      { '18': 'atten' },
-      { '17': 'sytten' },
-      { '16': 'seksten' },
-      { '15': 'femten' },
-      { '14': 'fjorten' },
-      { '13': 'tretten' },
-      { '12': 'tolv' },
-      { '11': 'elleve' },
-      { '10': 'ti' },
-      { '9': 'ni' },
-      { '8': 'otte' },
-      { '7': 'syv' },
-      { '6': 'seks' },
-      { '5': 'fem' },
-      { '4': 'fire' },
-      { '3': 'tre' },
-      { '2': 'to' },
-      { '1': 'et' },
-      { '0': 'nul' }
-    ];
+  constructor(options) {
+    options = Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'nul',
+      ordFlag: false
+    }, options);
+
+    super(options, [
+      [1000000000000000000000000000n, 'quadrillarder'],
+      [1000000000000000000000000n, 'quadrillioner'],
+      [1000000000000000000000n, 'trillarder'],
+      [1000000000000000000n, 'trillioner'],
+      [1000000000000000n, 'billarder'],
+      [1000000000000n, 'billioner'],
+      [1000000000n, 'millarder'],
+      [1000000n, 'millioner'],
+      [1000n, 'tusind'],
+      [100n, 'hundrede'],
+      [90n, 'halvfems'],
+      [80n, 'firs'],
+      [70n, 'halvfjerds'],
+      [60n, 'treds'],
+      [50n, 'halvtreds'],
+      [40n, 'fyrre'],
+      [30n, 'tredive'],
+      [20n, 'tyve'],
+      [19n, 'nitten'],
+      [18n, 'atten'],
+      [17n, 'sytten'],
+      [16n, 'seksten'],
+      [15n, 'femten'],
+      [14n, 'fjorten'],
+      [13n, 'tretten'],
+      [12n, 'tolv'],
+      [11n, 'elleve'],
+      [10n, 'ti'],
+      [9n, 'ni'],
+      [8n, 'otte'],
+      [7n, 'syv'],
+      [6n, 'seks'],
+      [5n, 'fem'],
+      [4n, 'fire'],
+      [3n, 'tre'],
+      [2n, 'to'],
+      [1n, 'et'],
+      [0n, 'nul']
+    ]);
+
+    this.ordFlag = options.ordFlag;
   }
 
   merge(curr, next) {
@@ -93,6 +98,13 @@ export class N2WordsDK extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsDK().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 N2WordsDK(options).floatToCardinal(value);
 }

package/lib/i18n/EN.mjs

@@ -1,72 +1,84 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-class N2WordsEN extends N2WordsBase {
-  constructor() {
-    super();
-
-    this.negativeWord = 'minus';
-    this.separatorWord = 'point';
-    this.zero = 'zero';
-    this.cards = [
-      { '1000000000000000000000000000': 'octillion' },
-      { '1000000000000000000000000': 'septillion' },
-      { '1000000000000000000000': 'sextillion' },
-      { '1000000000000000000': 'quintillion' },
-      { '1000000000000000': 'quadrillion' },
-      { '1000000000000': 'trillion' },
-      { '1000000000': 'billion' },
-      { '1000000': 'million' },
-      { '1000': 'thousand' },
-      { '100': 'hundred' },
-      { '90': 'ninety' },
-      { '80': 'eighty' },
-      { '70': 'seventy' },
-      { '60': 'sixty' },
-      { '50': 'fifty' },
-      { '40': 'forty' },
-      { '30': 'thirty' },
-      { '20': 'twenty' },
-      { '19': 'nineteen' },
-      { '18': 'eighteen' },
-      { '17': 'seventeen' },
-      { '16': 'sixteen' },
-      { '15': 'fifteen' },
-      { '14': 'fourteen' },
-      { '13': 'thirteen' },
-      { '12': 'twelve' },
-      { '11': 'eleven' },
-      { '10': 'ten' },
-      { '9': 'nine' },
-      { '8': 'eight' },
-      { '7': 'seven' },
-      { '6': 'six' },
-      { '5': 'five' },
-      { '4': 'four' },
-      { '3': 'three' },
-      { '2': 'two' },
-      { '1': 'one' },
-      { '0': 'zero' }
-    ];
+/**
+ * This class is for converting numbers to english words.
+ */
+class English extends BaseLanguage {
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'point',
+      zero: 'zero'
+    }, options), [
+      [1000000000000000000000000000n, 'octillion'],
+      [1000000000000000000000000n, 'septillion'],
+      [1000000000000000000000n, 'sextillion'],
+      [1000000000000000000n, 'quintillion'],
+      [1000000000000000n, 'quadrillion'],
+      [1000000000000n, 'trillion'],
+      [1000000000n, 'billion'],
+      [1000000n, 'million'],
+      [1000n, 'thousand'],
+      [100n, 'hundred'],
+      [90n, 'ninety'],
+      [80n, 'eighty'],
+      [70n, 'seventy'],
+      [60n, 'sixty'],
+      [50n, 'fifty'],
+      [40n, 'forty'],
+      [30n, 'thirty'],
+      [20n, 'twenty'],
+      [19n, 'nineteen'],
+      [18n, 'eighteen'],
+      [17n, 'seventeen'],
+      [16n, 'sixteen'],
+      [15n, 'fifteen'],
+      [14n, 'fourteen'],
+      [13n, 'thirteen'],
+      [12n, 'twelve'],
+      [11n, 'eleven'],
+      [10n, 'ten'],
+      [9n, 'nine'],
+      [8n, 'eight'],
+      [7n, 'seven'],
+      [6n, 'six'],
+      [5n, 'five'],
+      [4n, 'four'],
+      [3n, 'three'],
+      [2n, 'two'],
+      [1n, 'one'],
+      [0n, 'zero']
+    ]);
   }
 
   /**
-   *
-   *
+   * Merge word set pairs
    * @param {object} lPair {'one':1}
    * @param {object} rPair {'hundred':100}
    * @returns {object} {'one hundred': 100}
    */
   merge(lPair, rPair) {
-    const lText = Object.keys(lPair)[0]; const lNum = parseInt(Object.values(lPair)[0]);
-    const rText = Object.keys(rPair)[0]; const rNum = parseInt(Object.values(rPair)[0]);
+    const lText = Object.keys(lPair)[0];
+    const lNum = parseInt(Object.values(lPair)[0]);
+    const rText = Object.keys(rPair)[0];
+    const rNum = parseInt(Object.values(rPair)[0]);
+
     if (lNum == 1 && rNum < 100) return { [rText]: rNum };
     else if (100 > lNum && lNum > rNum) return { [`${lText}-${rText}`]: lNum + rNum };
     else if (lNum >= 100 && 100 > rNum) return { [`${lText} and ${rText}`]: lNum + rNum };
     else if (rNum > lNum) return { [`${lText} ${rText}`]: lNum * rNum };
+
     return { [`${lText} ${rText}`]: lNum + rNum };
   }
 }
 
-export default function(n) {
-  return new N2WordsEN().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 English(options).floatToCardinal(value);
 }