n2words 2.0.0 → 3.1.0

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 }

package/lib/n2words.d.ts

@@ -1,209 +1,55 @@
-/**
- * Numeric value that can be converted to words.
- * Accepts number, bigint, or numeric string representations.
- */
-export type NumericValue = number | bigint | string;
-export type ArabicOptions = {
-    /**
-     * Word for negative numbers
-     */
-    negativeWord?: string | undefined;
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type BiblicalHebrewOptions = {
-    /**
-     * Conjunction character (typically 'ו' for and)
-     */
-    andWord?: string | undefined;
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type CroatianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type CzechOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type DanishOptions = {
-    /**
-     * Enable ordinal number conversion
-     */
-    ordFlag?: boolean | undefined;
-};
-export type DutchOptions = {
-    /**
-     * Include optional "en" separator
-     */
-    includeOptionalAnd?: boolean | undefined;
-    /**
-     * Disable hundred-pairing (e.g., "twelve hundred" becomes "one thousand two hundred")
-     */
-    noHundredPairing?: boolean | undefined;
-    /**
-     * Use accented "één" for one
-     */
-    accentOne?: boolean | undefined;
-};
-export type FrenchOptions = {
-    /**
-     * Use hyphens (true) instead of spaces (false) in compounds
-     */
-    withHyphenSeparator?: boolean | undefined;
-};
-export type FrenchBelgiumOptions = {
-    /**
-     * Use hyphens (true) instead of spaces (false) in compounds
-     */
-    withHyphenSeparator?: boolean | undefined;
-};
-export type HebrewOptions = {
-    /**
-     * Conjunction character (typically 'ו' for and)
-     */
-    andWord?: string | undefined;
-};
-export type LatvianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type LithuanianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type PolishOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type RomanianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type RussianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type SerbianCyrillicOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type SerbianLatinOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type SimplifiedChineseOptions = {
-    /**
-     * Use formal/financial numerals (壹贰叁) vs. common numerals (一二三)
-     */
-    formal?: boolean | undefined;
-};
-export type SpanishOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type TraditionalChineseOptions = {
-    /**
-     * Use formal/financial numerals (壹貳參) vs. common numerals (一二三)
-     */
-    formal?: boolean | undefined;
-};
-export type TurkishOptions = {
-    /**
-     * Remove spaces between words if true
-     */
-    dropSpaces?: boolean | undefined;
-};
-export type UkrainianOptions = {
-    /**
-     * Grammatical gender for number forms
-     */
-    gender?: "feminine" | "masculine" | undefined;
-};
-export type ParsedNumericValue = {
-    /**
-     * - Whether the value is negative
-     */
-    isNegative: boolean;
-    /**
-     * - The absolute integer part
-     */
-    integerPart: bigint;
-    /**
-     * - The decimal digits (without the point)
-     */
-    decimalPart?: string | undefined;
-};
-export const ArabicConverter: (value: NumericValue, options?: ArabicOptions) => string;
-export const AzerbaijaniConverter: (value: NumericValue) => string;
-export const BanglaConverter: (value: NumericValue) => string;
-export const BiblicalHebrewConverter: (value: NumericValue, options?: BiblicalHebrewOptions) => string;
-export const CroatianConverter: (value: NumericValue, options?: CroatianOptions) => string;
-export const CzechConverter: (value: NumericValue, options?: CzechOptions) => string;
-export const DanishConverter: (value: NumericValue, options?: DanishOptions) => string;
-export const DutchConverter: (value: NumericValue, options?: DutchOptions) => string;
-export const EnglishConverter: (value: NumericValue) => string;
-export const FilipinoConverter: (value: NumericValue) => string;
-export const FrenchConverter: (value: NumericValue, options?: FrenchOptions) => string;
-export const FrenchBelgiumConverter: (value: NumericValue, options?: FrenchBelgiumOptions) => string;
-export const GermanConverter: (value: NumericValue) => string;
-export const GreekConverter: (value: NumericValue) => string;
-export const GujaratiConverter: (value: NumericValue) => string;
-export const HebrewConverter: (value: NumericValue, options?: HebrewOptions) => string;
-export const HindiConverter: (value: NumericValue) => string;
-export const HungarianConverter: (value: NumericValue) => string;
-export const IndonesianConverter: (value: NumericValue) => string;
-export const ItalianConverter: (value: NumericValue) => string;
-export const JapaneseConverter: (value: NumericValue) => string;
-export const KannadaConverter: (value: NumericValue) => string;
-export const KoreanConverter: (value: NumericValue) => string;
-export const LatvianConverter: (value: NumericValue, options?: LatvianOptions) => string;
-export const LithuanianConverter: (value: NumericValue, options?: LithuanianOptions) => string;
-export const MalayConverter: (value: NumericValue) => string;
-export const MarathiConverter: (value: NumericValue) => string;
-export const NorwegianBokmalConverter: (value: NumericValue) => string;
-export const PersianConverter: (value: NumericValue) => string;
-export const PolishConverter: (value: NumericValue, options?: PolishOptions) => string;
-export const PortugueseConverter: (value: NumericValue) => string;
-export const PunjabiConverter: (value: NumericValue) => string;
-export const RomanianConverter: (value: NumericValue, options?: RomanianOptions) => string;
-export const RussianConverter: (value: NumericValue, options?: RussianOptions) => string;
-export const SerbianCyrillicConverter: (value: NumericValue, options?: SerbianCyrillicOptions) => string;
-export const SerbianLatinConverter: (value: NumericValue, options?: SerbianLatinOptions) => string;
-export const SimplifiedChineseConverter: (value: NumericValue, options?: SimplifiedChineseOptions) => string;
-export const SpanishConverter: (value: NumericValue, options?: SpanishOptions) => string;
-export const SwahiliConverter: (value: NumericValue) => string;
-export const SwedishConverter: (value: NumericValue) => string;
-export const TamilConverter: (value: NumericValue) => string;
-export const TeluguConverter: (value: NumericValue) => string;
-export const ThaiConverter: (value: NumericValue) => string;
-export const TraditionalChineseConverter: (value: NumericValue, options?: TraditionalChineseOptions) => string;
-export const TurkishConverter: (value: NumericValue, options?: TurkishOptions) => string;
-export const UkrainianConverter: (value: NumericValue, options?: UkrainianOptions) => string;
-export const UrduConverter: (value: NumericValue) => string;
-export const VietnameseConverter: (value: NumericValue) => string;
+import { toWords as am } from './languages/am.js';
+import { toWords as amLatn } from './languages/am-Latn.js';
+import { toWords as ar } from './languages/ar.js';
+import { toWords as az } from './languages/az.js';
+import { toWords as bn } from './languages/bn.js';
+import { toWords as cs } from './languages/cs.js';
+import { toWords as da } from './languages/da.js';
+import { toWords as de } from './languages/de.js';
+import { toWords as el } from './languages/el.js';
+import { toWords as en } from './languages/en.js';
+import { toWords as es } from './languages/es.js';
+import { toWords as fa } from './languages/fa.js';
+import { toWords as fi } from './languages/fi.js';
+import { toWords as fil } from './languages/fil.js';
+import { toWords as fr } from './languages/fr.js';
+import { toWords as frBE } from './languages/fr-BE.js';
+import { toWords as gu } from './languages/gu.js';
+import { toWords as ha } from './languages/ha.js';
+import { toWords as hbo } from './languages/hbo.js';
+import { toWords as he } from './languages/he.js';
+import { toWords as hi } from './languages/hi.js';
+import { toWords as hr } from './languages/hr.js';
+import { toWords as hu } from './languages/hu.js';
+import { toWords as id } from './languages/id.js';
+import { toWords as it } from './languages/it.js';
+import { toWords as ja } from './languages/ja.js';
+import { toWords as ka } from './languages/ka.js';
+import { toWords as kn } from './languages/kn.js';
+import { toWords as ko } from './languages/ko.js';
+import { toWords as lt } from './languages/lt.js';
+import { toWords as lv } from './languages/lv.js';
+import { toWords as mr } from './languages/mr.js';
+import { toWords as ms } from './languages/ms.js';
+import { toWords as nb } from './languages/nb.js';
+import { toWords as nl } from './languages/nl.js';
+import { toWords as pa } from './languages/pa.js';
+import { toWords as pl } from './languages/pl.js';
+import { toWords as pt } from './languages/pt.js';
+import { toWords as ro } from './languages/ro.js';
+import { toWords as ru } from './languages/ru.js';
+import { toWords as srCyrl } from './languages/sr-Cyrl.js';
+import { toWords as srLatn } from './languages/sr-Latn.js';
+import { toWords as sv } from './languages/sv.js';
+import { toWords as sw } from './languages/sw.js';
+import { toWords as ta } from './languages/ta.js';
+import { toWords as te } from './languages/te.js';
+import { toWords as th } from './languages/th.js';
+import { toWords as tr } from './languages/tr.js';
+import { toWords as uk } from './languages/uk.js';
+import { toWords as ur } from './languages/ur.js';
+import { toWords as vi } from './languages/vi.js';
+import { toWords as yo } from './languages/yo.js';
+import { toWords as zhHans } from './languages/zh-Hans.js';
+import { toWords as zhHant } from './languages/zh-Hant.js';
+export { am, amLatn, ar, az, bn, cs, da, de, el, en, es, fa, fi, fil, fr, frBE, gu, ha, hbo, he, hi, hr, hu, id, it, ja, ka, kn, ko, lt, lv, mr, ms, nb, nl, pa, pl, pt, ro, ru, srCyrl, srLatn, sv, sw, ta, te, th, tr, uk, ur, vi, yo, zhHans, zhHant };