n2words 2.0.0 → 3.1.0

package/lib/languages/id.js

@@ -1,159 +1,196 @@
-import { AbstractLanguage } from '../classes/abstract-language.js'
-
 /**
- * Indonesian language converter.
+ * Indonesian language converter - Functional Implementation
+ *
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Supports:
- * - "Se-" prefix for one (seratus, seribu, sejuta)
+ * Key features:
+ * - "Se-" prefix for 100 (seratus) and 1000 (seribu)
  * - Regular patterns (puluh for tens, ratus for hundreds)
- * - Space-separated number components
+ * - Teens with "belas" suffix
+ * - Indonesian uses "satu juta" (not "sejuta") for millions+
  */
-export class Indonesian extends AbstractLanguage {
-  negativeWord = 'min'
-  decimalSeparatorWord = 'koma'
-  zeroWord = 'nol'
-
-  /**
-   * Word forms for digits 0-9.
-   * @type {Object.<number, string[]>}
-   */
-  digitWords = {
-    0: [],
-    1: ['satu'],
-    2: ['dua'],
-    3: ['tiga'],
-    4: ['empat'],
-    5: ['lima'],
-    6: ['enam'],
-    7: ['tujuh'],
-    8: ['delapan'],
-    9: ['sembilan']
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'delapan', 'sembilan']
+const TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'delapan belas', 'sembilan belas']
+const TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'delapan puluh', 'sembilan puluh']
+
+const HUNDRED_WORD = 'ratus'
+const THOUSAND_WORD = 'ribu'
+const SCALE_WORDS = ['juta', 'miliar', 'triliun', 'kuadriliun', 'kuantiliun', 'sekstiliun', 'septiliun', 'oktiliun', 'noniliun', 'desiliun']
+
+const ZERO = 'nol'
+const NEGATIVE = 'min'
+const DECIMAL_SEP = 'koma'
+
+// ============================================================================
+// Segment Building
+// ============================================================================
+
+function buildSegment (n) {
+  if (n === 0) return ''
+
+  const onesDigit = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
+
+  const parts = []
+
+  // Hundreds: seratus (100) or N ratus (200-900)
+  if (hundredsDigit > 0) {
+    if (hundredsDigit === 1) {
+      parts.push('se' + HUNDRED_WORD)
+    } else {
+      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)
+    }
   }
 
-  /**
-   * Scale magnitude words keyed by exponent (10^n).
-   * @type {Object.<number, string>}
-   */
-  scaleWords = {
-    3: 'ribu', // 10^3
-    6: 'juta', // 10^6
-    9: 'miliar', // 10^9
-    12: 'triliun',
-    15: 'kuadriliun',
-    18: 'kuantiliun',
-    21: 'sekstiliun',
-    24: 'septiliun',
-    27: 'oktiliun',
-    30: 'noniliun',
-    33: 'desiliun'
+  // Tens and ones
+  const tensOnes = n % 100
+
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    parts.push(ONES[tensOnes])
+  } else if (tensOnes < 20) {
+    parts.push(TEENS[tensOnes - 10])
+  } else if (onesDigit === 0) {
+    parts.push(TENS[tensDigit])
+  } else {
+    parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])
   }
 
-  /** Splits number into groups of 3 digits. */
-  splitBy3 (number) {
-    // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
-    const blocks = []
-    const stringNumber = number.toString()
-    const length = stringNumber.length
-    let firstBlock
+  return parts.join(' ')
+}
 
-    if (length < 3) {
-      blocks.push([stringNumber])
-    } else {
-      const firstBlockLength = length % 3
+// ============================================================================
+// Conversion Functions
+// ============================================================================
 
-      if (firstBlockLength > 0) {
-        firstBlock = [stringNumber.slice(0, firstBlockLength)]
-        blocks.push(firstBlock)
-      }
+function integerToWords (n) {
+  if (n === 0n) return ZERO
 
-      for (let index = firstBlockLength; index < length; index += 3) {
-        const nextBlock = [stringNumber.slice(index, index + 3)]
-        blocks.push(nextBlock)
-      }
-    }
-    return blocks
+  if (n < 1000n) {
+    return buildSegment(Number(n))
   }
 
-  /** Converts digit blocks to Indonesian words. */
-  spell (blocks) {
-    let wordBlocks = []
-    let spelling
-    const firstBlock = blocks[0]
-    if (firstBlock[0].length === 1) {
-      spelling = firstBlock[0] === '0' ? ['nol'] : this.digitWords[Math.trunc(firstBlock[0])]
-    } else if (firstBlock[0].length === 2) {
-      spelling = this.getTens(firstBlock[0])
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    let result
+    if (thousands === 1) {
+      result = 'se' + THOUSAND_WORD
     } else {
-      spelling = [...this.getHundreds(firstBlock[0][0]), ...this.getTens(firstBlock[0].slice(1, 3))]
+      result = buildSegment(thousands) + ' ' + THOUSAND_WORD
     }
-    wordBlocks = [...wordBlocks, [firstBlock[0], spelling]]
-    for (let index = 1; index < blocks.length; index++) {
-      let block = blocks[index]
-      spelling = [...this.getHundreds(block[0][0]), ...this.getTens(block[0].slice(1, 3))]
-      block = [...block, spelling]
-      wordBlocks = [...wordBlocks, block]
+
+    if (remainder > 0) {
+      result += ' ' + buildSegment(remainder)
     }
-    return wordBlocks
+
+    return result
   }
 
-  /** Converts hundreds digit with "seratus" or "ratus" suffix. */
-  getHundreds (number) {
-    if (number === '1') {
-      return ['seratus']
-    } else if (number === '0') {
-      return []
-    } else {
-      return [...this.digitWords[Math.trunc(number)], 'ratus']
-    }
+  return buildLargeNumberWords(n)
+}
+
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  const segments = []
+  const segmentSize = 3
+
+  const remainderLen = len % segmentSize
+  let pos = 0
+  if (remainderLen > 0) {
+    segments.push(Number(numStr.slice(0, remainderLen)))
+    pos = remainderLen
   }
+  while (pos < len) {
+    segments.push(Number(numStr.slice(pos, pos + segmentSize)))
+    pos += segmentSize
+  }
+
+  const parts = []
+  let scaleIndex = segments.length - 1
 
-  /** Converts tens and units digits with "puluh" or "belas" suffix. */
-  getTens (number) {
-    if (number[0] === '1') {
-      if (number[1] === '0') {
-        return ['sepuluh']
-      } else if (number[1] === '1') {
-        return ['sebelas']
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      if (scaleIndex === 0) {
+        parts.push(buildSegment(segment))
+      } else if (scaleIndex === 1) {
+        if (segment === 1) {
+          parts.push('se' + THOUSAND_WORD)
+        } else {
+          parts.push(buildSegment(segment) + ' ' + THOUSAND_WORD)
+        }
+      } else {
+        // Indonesian: "satu juta" not "sejuta"
+        const scaleWord = SCALE_WORDS[scaleIndex - 2]
+        parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
-      return [...this.digitWords[Math.trunc(number[1])], 'belas']
     }
 
-    if (number[0] === '0') {
-      return this.digitWords[Math.trunc(number[1])]
-    }
+    scaleIndex--
+  }
 
-    return [...this.digitWords[Math.trunc(number[0])], 'puluh', ...this.digitWords[Math.trunc(number[1])]]
+  return parts.join(' ')
+}
+
+function decimalPartToWords (decimalPart) {
+  let result = ''
+
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
   }
 
-  /** Joins word blocks with magnitude scale words. */
-  join (wordBlocks) {
-    let wordList = []
-    const length = wordBlocks.length - 1
-    const firstBlock = [wordBlocks[0]]
-    let start = 0
-    if (length === 1 && firstBlock[0][0] === '1') {
-      wordList.push('seribu')
-      start = 1
-    }
-    for (let index = start; index < length + 1; index++) {
-      wordList = [...wordList, ...wordBlocks[index][1]]
-      if (wordBlocks[index][1].length === 0) {
-        continue
-      }
-      if (index === length) {
-        break
-      }
-      wordList = [...wordList, this.scaleWords[(length - index) * 3]]
-    }
-    return wordList.join(' ')
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
   }
 
-  /** Converts integer part using Indonesian group-based conversion. */
-  integerToWords (integerPart) {
-    return this.join(
-      this.spell(
-        this.splitBy3(integerPart)
-      )
-    ).trim()
+  return result
+}
+
+/**
+ * Converts a numeric value to Indonesian words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Indonesian words
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE + ' '
   }
+
+  result += integerToWords(integerPart)
+
+  if (decimalPart) {
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)
+  }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/it.d.ts

@@ -1,37 +1,19 @@
 /**
- * Italian language converter.
+ * Converts a numeric value to Italian words.
  *
- * Supports:
- * - Phonetic contractions (vowel elision: "ventotto" not "ventiotto")
- * - Accentuation rules for "tre" in compounds ("ventitré")
- * - Custom word construction for irregular patterns
+ * This is the main public API. It accepts any valid numeric input
+ * (number, string, or bigint) and handles parsing internally.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Italian words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(28)           // 'ventotto'
+ * toWords(23)           // 'ventitré'
+ * toWords(1000)         // 'mille'
+ * toWords(2000)         // 'duemila'
+ * toWords(1000000)      // 'un milione'
  */
-export class Italian extends AbstractLanguage {
-    onesWords: string[];
-    tensWords: {
-        2: string;
-        3: string;
-        4: string;
-        6: string;
-    };
-    exponentPrefixes: string[];
-    /** Adds accent to final "tre" in compound words (ventitré). */
-    accentuate(string: any): any;
-    /** Omits word if it represents zero. */
-    omitIfZero(numberToString: any): any;
-    /** Removes duplicate vowels for phonetic contractions. */
-    phoneticContraction(string: any): any;
-    /** Converts tens (20-99) with phonetic contractions. */
-    tensToCardinal(number: any): any;
-    /** Converts hundreds (100-999) with "cento" composition. */
-    hundredsToCardinal(number: any): any;
-    /** Converts thousands (1000-999999) with "mille/mila" composition. */
-    thousandsToCardinal(number: any): string;
-    /** Converts exponent length to Italian scale word (milione, miliardo, etc.). */
-    exponentLengthToString(exponentLength: any): string;
-    /** Converts large numbers (millions and above) with exponent-based naming. */
-    bigNumberToCardinal(number: any): string;
-    /** Converts integer part using Italian custom algorithm with accentuation. */
-    integerToWords(integerPart: any): any;
-}
-import { AbstractLanguage } from '../classes/abstract-language.js';
+export function toWords(value: number | string | bigint): string;