n2words 2.0.0 → 3.0.0

package/lib/languages/zh-Hans.js

@@ -1,111 +1,182 @@
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
-
 /**
- * Simplified Chinese language converter.
+ * Simplified Chinese language converter - Functional Implementation
+ *
+ * Self-contained converter for Simplified Chinese.
  *
- * Supports:
- * - Simplified Chinese characters (简体中文)
+ * Key features:
+ * - Myriad-based (万, 亿) grouping - 4 digits
+ * - Formal (financial) vs common numerals
+ * - Zero insertion for skipped positions
  * - No word separators (concatenated format)
- * - Optional formal (financial) vs common numerals
  */
-export class SimplifiedChinese extends GreedyScaleLanguage {
-  negativeWord = '负'
-  decimalSeparatorWord = '点'
-  zeroWord = '零'
-  wordSeparator = ''
-
-  constructor (options = {}) {
-    super()
-
-    this.setOptions({
-      formal: true
-    }, options)
-
-    if (this.options.formal) {
-      this.scaleWords = [
-        [1_000_000_000_000n, '万'],
-        [100_000_000n, '亿'],
-        [10_000n, '万'],
-        [1000n, '仟'],
-        [100n, '佰'],
-        [10n, '拾'],
-        [9n, '玖'],
-        [8n, '捌'],
-        [7n, '柒'],
-        [6n, '陆'],
-        [5n, '伍'],
-        [4n, '肆'],
-        [3n, '叁'],
-        [2n, '贰'],
-        [1n, '壹'],
-        [0n, '零']
-      ]
-    } else {
-      this.scaleWords = [
-        [1_000_000_000_000n, '万'],
-        [100_000_000n, '亿'],
-        [10_000n, '万'],
-        [1000n, '千'],
-        [100n, '百'],
-        [10n, '十'],
-        [9n, '九'],
-        [8n, '八'],
-        [7n, '七'],
-        [6n, '六'],
-        [5n, '五'],
-        [4n, '四'],
-        [3n, '三'],
-        [2n, '二'],
-        [1n, '一'],
-        [0n, '零']
-      ]
-    }
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+import { validateOptions } from '../utils/validate-options.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+// Common (everyday) numerals
+const ONES_COMMON = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']
+const TEN_COMMON = '十'
+const HUNDRED_COMMON = '百'
+const THOUSAND_COMMON = '千'
+
+// Formal (financial) numerals - harder to alter/forge
+const ONES_FORMAL = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']
+const TEN_FORMAL = '拾'
+const HUNDRED_FORMAL = '佰'
+const THOUSAND_FORMAL = '仟'
+
+// Scale words
+const WAN_WORD = '万' // 10,000
+const YI_WORD = '亿' // 100,000,000
+
+const ZERO = '零'
+const NEGATIVE = '负'
+const DECIMAL_SEP = '点'
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Convert number below 万 (10,000) to words using direct string concatenation.
+ */
+function convertBelowWan (value, ones, ten, hundred, thousand) {
+  if (value === 0n) return ''
+
+  let result = ''
+  let needsZero = false
+
+  // Thousands (千)
+  const thousandsVal = value / 1000n
+  const thousandsRemainder = value % 1000n
+  if (thousandsVal > 0n) {
+    result = ones[Number(thousandsVal)] + thousand
+    needsZero = thousandsRemainder > 0n && thousandsRemainder < 100n
   }
 
-  /** Combines two word-sets according to Chinese grammar rules. */
-  combineWordSets (preceding, following) {
-    const precedingWord = Object.keys(preceding)[0]
-    const precedingValue = Object.values(preceding)[0]
-    const followingWord = Object.keys(following)[0]
-    const followingValue = Object.values(following)[0]
+  // Hundreds (百)
+  const hundredsVal = thousandsRemainder / 100n
+  const hundredsRemainder = thousandsRemainder % 100n
+  if (hundredsVal > 0n) {
+    if (needsZero) result += ZERO
+    result += ones[Number(hundredsVal)] + hundred
+    needsZero = hundredsRemainder > 0n && hundredsRemainder < 10n
+  } else if (thousandsVal > 0n && hundredsRemainder > 0n) {
+    needsZero = true
+  }
 
-    // Implicit one: omit 1 before single digits (< 10)
-    if (precedingValue === 1n && followingValue < 10n) {
-      return following
-    }
+  // Tens (十)
+  const tensVal = hundredsRemainder / 10n
+  const onesVal = hundredsRemainder % 10n
+  if (tensVal > 0n) {
+    if (needsZero) result += ZERO
+    result += ones[Number(tensVal)] + ten
+    needsZero = false
+  } else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {
+    needsZero = true
+  }
 
-    // Multiply when following > preceding (scale words like 仁, 万, 亿)
-    if (followingValue > precedingValue) {
-      return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
-    }
+  // Ones
+  if (onesVal > 0n) {
+    if (needsZero) result += ZERO
+    result += ones[Number(onesVal)]
+  }
+
+  return result
+}
+
+/**
+ * Convert number below 亿 (100 million) to words.
+ */
+function convertBelowYi (value, ones, ten, hundred, thousand) {
+  if (value === 0n) return ''
 
-    // Insert "零" (zero) when position skip levels (e.g., 1003 = 千零三)
-    // zeroDigit() checks if gap exists between preceding and following magnitude
-    if (this.zeroDigit(precedingValue) > this.digit(followingValue)) {
-      return { [`${precedingWord}${this.zeroWord}${followingWord}`]: precedingValue + followingValue }
+  if (value >= 10_000n) {
+    const wanValue = value / 10_000n
+    const wanRemainder = value % 10_000n
+
+    let result = convertBelowWan(wanValue, ones, ten, hundred, thousand) + WAN_WORD
+
+    if (wanRemainder > 0n) {
+      const needsZero = (wanValue % 10n === 0n) || (wanRemainder < 1000n)
+      if (needsZero) result += ZERO
+      result += convertBelowWan(wanRemainder, ones, ten, hundred, thousand)
     }
 
-    // Default: concatenate without zero insertion
-    return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+    return result
   }
 
-  /** Returns the number of digits in a number. */
-  digit (number_) {
-    return number_.toString().length
+  return convertBelowWan(value, ones, ten, hundred, thousand)
+}
+
+function integerToWords (n, formal = true) {
+  if (n === 0n) return ZERO
+
+  const ones = formal ? ONES_FORMAL : ONES_COMMON
+  const ten = formal ? TEN_FORMAL : TEN_COMMON
+  const hundred = formal ? HUNDRED_FORMAL : HUNDRED_COMMON
+  const thousand = formal ? THOUSAND_FORMAL : THOUSAND_COMMON
+
+  // Handle numbers >= 亿 (100 million)
+  if (n >= 100_000_000n) {
+    const yiValue = n / 100_000_000n
+    const yiRemainder = n % 100_000_000n
+
+    let result = convertBelowYi(yiValue, ones, ten, hundred, thousand) + YI_WORD
+
+    if (yiRemainder > 0n) {
+      if (yiRemainder < 10_000_000n) result += ZERO
+      result += convertBelowYi(yiRemainder, ones, ten, hundred, thousand)
+    }
+
+    return result
   }
 
-  /** Counts the number of zero digits in a number. */
-  zeroDigit (number_) {
-    return [...number_.toString()].filter(c => c === '0').length
+  return convertBelowYi(n, ones, ten, hundred, thousand)
+}
+
+/**
+ * Convert decimal digits to words using direct concatenation.
+ */
+function decimalDigitsToWords (decimalString, ones) {
+  let result = ''
+  for (let i = 0; i < decimalString.length; i++) {
+    result += ones[Number(decimalString[i])]
   }
+  return result
+}
 
-  /** Converts decimal digits to words by reading each digit individually. */
-  decimalDigitsToWords (decimalString) {
-    const words = []
-    for (let i = 0; i < decimalString.length; i++) {
-      const digitValue = BigInt(decimalString[i])
-      words.push(this.integerToWords(digitValue))
-    }
-    return words
+/**
+ * Converts a numeric value to Simplified Chinese words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @returns {string} The number in Simplified Chinese words
+ */
+function toWords (value, options) {
+  options = validateOptions(options)
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+  const formal = options.formal !== false // Default to true
+
+  let result = isNegative ? NEGATIVE : ''
+
+  result += integerToWords(integerPart, formal)
+
+  if (decimalPart) {
+    const ones = formal ? ONES_FORMAL : ONES_COMMON
+    result += DECIMAL_SEP + decimalDigitsToWords(decimalPart, ones)
   }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/zh-Hant.d.ts

@@ -1,21 +1,11 @@
 /**
- * Traditional Chinese language converter.
+ * Converts a numeric value to Traditional Chinese words.
  *
- * Supports:
- * - Traditional Chinese characters (繁體中文)
- * - No word separators (concatenated format)
- * - Optional formal (financial) vs common numerals
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @returns {string} The number in Traditional Chinese words
  */
-export class TraditionalChinese extends GreedyScaleLanguage {
-    constructor(options?: {});
-    scaleWords: (string | bigint)[][];
-    /** Combines two word-sets with Traditional Chinese grammar rules and zero insertion. */
-    combineWordSets(preceding: any, following: any): any;
-    /** Returns the number of digits in a number. */
-    digit(number_: any): any;
-    /** Counts the number of zero digits in a number. */
-    zeroDigit(number_: any): number;
-    /** Converts decimal digits to words by reading each digit individually. */
-    decimalDigitsToWords(decimalString: any): string[];
-}
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';
+export function toWords(value: number | string | bigint, options?: {
+    formal?: boolean | undefined;
+}): string;

package/lib/languages/zh-Hant.js

@@ -1,111 +1,202 @@
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
-
 /**
- * Traditional Chinese language converter.
+ * Traditional Chinese language converter - Functional Implementation
+ *
+ * Self-contained converter for Traditional Chinese.
  *
- * Supports:
- * - Traditional Chinese characters (繁體中文)
+ * Key features:
+ * - Myriad-based (萬, 億) grouping - 4 digits
+ * - Formal (financial) vs common numerals
+ * - Zero insertion for skipped positions
  * - No word separators (concatenated format)
- * - Optional formal (financial) vs common numerals
+ *
+ * Differences from Simplified:
+ * - Different character forms (e.g., 負/负, 點/点, 億/亿, 萬/万)
+ * - Some formal numerals differ (參/叁, 貳/贰, 陸/陆)
  */
-export class TraditionalChinese extends GreedyScaleLanguage {
-  negativeWord = '負'
-  decimalSeparatorWord = '點'
-  zeroWord = '零'
-  wordSeparator = ''
-
-  constructor (options = {}) {
-    super()
-
-    this.setOptions({
-      formal: true
-    }, options)
-
-    if (this.options.formal) {
-      this.scaleWords = [
-        [1_000_000_000_000n, '萬'],
-        [100_000_000n, '億'],
-        [10_000n, '萬'],
-        [1000n, '仟'],
-        [100n, '佰'],
-        [10n, '拾'],
-        [9n, '玖'],
-        [8n, '捌'],
-        [7n, '柒'],
-        [6n, '陸'],
-        [5n, '伍'],
-        [4n, '肆'],
-        [3n, '參'],
-        [2n, '貳'],
-        [1n, '壹'],
-        [0n, '零']
-      ]
-    } else {
-      this.scaleWords = [
-        [1_000_000_000_000n, '萬'],
-        [100_000_000n, '億'],
-        [10_000n, '萬'],
-        [1000n, '千'],
-        [100n, '百'],
-        [10n, '十'],
-        [9n, '九'],
-        [8n, '八'],
-        [7n, '七'],
-        [6n, '六'],
-        [5n, '五'],
-        [4n, '四'],
-        [3n, '三'],
-        [2n, '二'],
-        [1n, '一'],
-        [0n, '零']
-      ]
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+import { validateOptions } from '../utils/validate-options.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+// Common (everyday) numerals - Traditional forms
+const ONES_COMMON = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']
+const TEN_COMMON = '十'
+const HUNDRED_COMMON = '百'
+const THOUSAND_COMMON = '千'
+
+// Formal (financial) numerals - Traditional forms
+const ONES_FORMAL = ['零', '壹', '貳', '參', '肆', '伍', '陸', '柒', '捌', '玖']
+const TEN_FORMAL = '拾'
+const HUNDRED_FORMAL = '佰'
+const THOUSAND_FORMAL = '仟'
+
+// Scale words - Traditional forms
+const WAN_WORD = '萬' // 10,000
+const YI_WORD = '億' // 100,000,000
+
+const ZERO = '零'
+const NEGATIVE = '負'
+const DECIMAL_SEP = '點'
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n, formal = true) {
+  if (n === 0n) return ZERO
+
+  const ones = formal ? ONES_FORMAL : ONES_COMMON
+  const ten = formal ? TEN_FORMAL : TEN_COMMON
+  const hundred = formal ? HUNDRED_FORMAL : HUNDRED_COMMON
+  const thousand = formal ? THOUSAND_FORMAL : THOUSAND_COMMON
+
+  // Convert number below 萬 (10,000)
+  function convertBelowWan (value) {
+    if (value === 0n) return ''
+
+    const parts = []
+    let needsZero = false
+
+    // Thousands (千)
+    const thousandsVal = value / 1000n
+    const thousandsRemainder = value % 1000n
+    if (thousandsVal > 0n) {
+      parts.push(ones[Number(thousandsVal)] + thousand)
+      needsZero = thousandsRemainder > 0n && thousandsRemainder < 100n
     }
-  }
 
-  /** Combines two word-sets with Traditional Chinese grammar rules and zero insertion. */
-  combineWordSets (preceding, following) {
-    const precedingWord = Object.keys(preceding)[0]
-    const precedingValue = Object.values(preceding)[0]
-    const followingWord = Object.keys(following)[0]
-    const followingValue = Object.values(following)[0]
+    // Hundreds (百)
+    const hundredsVal = thousandsRemainder / 100n
+    const hundredsRemainder = thousandsRemainder % 100n
+    if (hundredsVal > 0n) {
+      if (needsZero) {
+        parts.push(ZERO)
+        needsZero = false
+      }
+      parts.push(ones[Number(hundredsVal)] + hundred)
+      needsZero = hundredsRemainder > 0n && hundredsRemainder < 10n
+    } else if (thousandsVal > 0n && hundredsRemainder > 0n) {
+      needsZero = true
+    }
 
-    // Implicit one: omit 1 before single digits (< 10)
-    if (precedingValue === 1n && followingValue < 10n) {
-      return following
+    // Tens (十)
+    const tensVal = hundredsRemainder / 10n
+    const onesVal = hundredsRemainder % 10n
+    if (tensVal > 0n) {
+      if (needsZero) {
+        parts.push(ZERO)
+        needsZero = false
+      }
+      parts.push(ones[Number(tensVal)] + ten)
+    } else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {
+      needsZero = true
     }
 
-    // Multiply when following > preceding (scale words like 千, 萬, 億)
-    if (followingValue > precedingValue) {
-      return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+    // Ones
+    if (onesVal > 0n) {
+      if (needsZero) {
+        parts.push(ZERO)
+      }
+      parts.push(ones[Number(onesVal)])
     }
 
-    // Insert "零" (zero) when position skip levels (e.g., 1003 = 千零三)
-    // zeroDigit() checks if gap exists between preceding and following magnitude
-    if (this.zeroDigit(precedingValue) > this.digit(followingValue)) {
-      return { [`${precedingWord}${this.zeroWord}${followingWord}`]: precedingValue + followingValue }
+    return parts.join('')
+  }
+
+  // Convert number below 億 (100 million)
+  function convertBelowYi (value) {
+    if (value === 0n) return ''
+
+    const parts = []
+
+    if (value >= 10_000n) {
+      const wanValue = value / 10_000n
+      const wanRemainder = value % 10_000n
+
+      parts.push(convertBelowWan(wanValue) + WAN_WORD)
+
+      if (wanRemainder > 0n) {
+        const wanEndsWithZero = wanValue % 10n === 0n
+        const remainderMissesThousands = wanRemainder < 1000n
+        const needsZero = wanEndsWithZero || remainderMissesThousands
+        if (needsZero) {
+          parts.push(ZERO)
+        }
+        parts.push(convertBelowWan(wanRemainder))
+      }
+    } else {
+      parts.push(convertBelowWan(value))
     }
 
-    // Default: concatenate without zero insertion
-    return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+    return parts.join('')
   }
 
-  /** Returns the number of digits in a number. */
-  digit (number_) {
-    return number_.toString().length
+  // Main conversion
+  const parts = []
+
+  if (n >= 100_000_000n) {
+    const yiValue = n / 100_000_000n
+    const yiRemainder = n % 100_000_000n
+
+    const yiWords = convertBelowYi(yiValue)
+    parts.push(yiWords + YI_WORD)
+
+    if (yiRemainder > 0n) {
+      const needsZero = yiRemainder < 10_000_000n
+      if (needsZero) {
+        parts.push(ZERO)
+      }
+      parts.push(convertBelowYi(yiRemainder))
+    }
+  } else {
+    parts.push(convertBelowYi(n))
   }
 
-  /** Counts the number of zero digits in a number. */
-  zeroDigit (number_) {
-    return [...number_.toString()].filter(c => c === '0').length
+  return parts.join('')
+}
+
+function decimalDigitsToWords (decimalString, formal = true) {
+  const ones = formal ? ONES_FORMAL : ONES_COMMON
+  const words = []
+  for (const char of decimalString) {
+    words.push(ones[Number(char)])
   }
+  return words
+}
 
-  /** Converts decimal digits to words by reading each digit individually. */
-  decimalDigitsToWords (decimalString) {
-    const words = []
-    for (let i = 0; i < decimalString.length; i++) {
-      const digitValue = BigInt(decimalString[i])
-      words.push(this.integerToWords(digitValue))
-    }
-    return words
+/**
+ * Converts a numeric value to Traditional Chinese words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @returns {string} The number in Traditional Chinese words
+ */
+function toWords (value, options) {
+  options = validateOptions(options)
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+  const formal = options.formal !== false // Default to true
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE
   }
+
+  result += integerToWords(integerPart, formal)
+
+  if (decimalPart) {
+    result += DECIMAL_SEP + decimalDigitsToWords(decimalPart, formal).join('')
+  }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }