n2words 1.24.0 → 3.0.0

package/lib/languages/fr-BE.js

@@ -1,61 +1,300 @@
-import { French } from './fr.js'
-
 /**
- * @typedef {Object} BelgianFrenchOptions
- * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- */
-
-/**
- * Belgian French language converter.
+ * French (Belgium) language converter - Functional Implementation
  *
- * Extends the French converter with Belgian French regional variant:
- * - Uses "septante" (70) instead of "soixante-dix"
- * - Uses "nonante" (90) instead of "quatre-vingt-dix"
- * - Maintains standard French "quatre-vingts" for 80
- * - More regular and logical number system than standard French
+ * Self-contained converter with precomputed lookup tables.
  *
- * Features:
- * - Regional number word variations (septante, nonante)
- * - Simplified tens naming (no complex arithmetic)
- * - Inherits all other French grammar rules from FR class
- * - Same pluralization and hyphenation patterns as standard French
+ * Belgian French differences from standard French:
+ * - septante (70) instead of soixante-dix
+ * - nonante (90) instead of quatre-vingt-dix
+ * - Keeps quatre-vingts (80) like standard French
+ * - Uses "septante et un" (71), "nonante et un" (91)
  */
-export class BelgianFrench extends French {
-  /**
-   * Initializes the Belgian French converter.
-   *
-   * @param {BelgianFrenchOptions} [options={}] Configuration options.
-   */
-  constructor (options = {}) {
-    super(options)
-    // Fill the empty placeholder slots with Belgian variants
-    // First empty slot (index 10) is for 90n (between 100n and 80n)
-    // Second empty slot (index 12) is for 70n (between 80n and 60n)
-    this.scaleWordPairs = this.scaleWordPairs.map((pair, index) => {
-      if (Array.isArray(pair) && pair.length === 0) {
-        // Check next pair to determine which slot this is
-        const nextPair = this.scaleWordPairs[index + 1]
-        if (nextPair && nextPair[0] === 80n) {
-          return [90n, 'nonante']
-        } else if (nextPair && nextPair[0] === 60n) {
-          return [70n, 'septante']
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+import { validateOptions } from '../utils/validate-options.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf']
+const TEENS = ['dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf']
+const TENS = ['', '', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'septante', 'quatre-vingt', 'nonante']
+
+// Scale words (long scale with -ard forms)
+const SCALES = ['million', 'billion', 'trillion', 'quadrillion']
+const SCALES_ARD = ['milliard', 'billiard', 'trilliard', 'quadrilliard']
+
+const THOUSAND = 'mille'
+const HUNDRED = 'cent'
+const ZERO = 'zéro'
+const NEGATIVE = 'moins'
+const DECIMAL_SEP = 'virgule'
+
+// ============================================================================
+// Precomputed Lookup Tables
+// ============================================================================
+
+function buildSegment (n) {
+  if (n === 0) return { word: '', endsWithCents: false, endsWithVingts: false }
+
+  const tensOnes = n % 100
+  const hundreds = Math.floor(n / 100)
+
+  const parts = []
+  let endsWithCents = false
+  let endsWithVingts = false
+
+  // Hundreds
+  if (hundreds > 0) {
+    if (hundreds === 1) {
+      parts.push(HUNDRED)
+    } else {
+      if (tensOnes === 0) {
+        parts.push(ONES[hundreds] + ' ' + HUNDRED + 's')
+        endsWithCents = true
+      } else {
+        parts.push(ONES[hundreds] + ' ' + HUNDRED)
+      }
+    }
+  }
+
+  // Tens and ones - Belgian pattern
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    parts.push(ONES[tensOnes])
+  } else if (tensOnes < 17) {
+    parts.push(TEENS[tensOnes - 10])
+  } else if (tensOnes < 20) {
+    parts.push(TEENS[tensOnes - 10])
+  } else if (tensOnes < 70) {
+    // 20-69: standard pattern
+    const t = Math.floor(tensOnes / 10)
+    const o = tensOnes % 10
+    if (o === 0) {
+      parts.push(TENS[t])
+    } else if (o === 1) {
+      parts.push(TENS[t] + ' et ' + ONES[1])
+    } else {
+      parts.push(TENS[t] + '-' + ONES[o])
+    }
+  } else if (tensOnes < 80) {
+    // 70-79: septante pattern (Belgian)
+    const o = tensOnes % 10
+    if (o === 0) {
+      parts.push('septante')
+    } else if (o === 1) {
+      parts.push('septante et ' + ONES[1])
+    } else {
+      parts.push('septante-' + ONES[o])
+    }
+  } else if (tensOnes === 80) {
+    // 80: quatre-vingts (same as standard)
+    parts.push('quatre-vingts')
+    endsWithVingts = true
+  } else if (tensOnes < 90) {
+    // 81-89: quatre-vingt-X (same as standard)
+    const remainder = tensOnes - 80
+    parts.push('quatre-vingt-' + ONES[remainder])
+  } else {
+    // 90-99: nonante pattern (Belgian)
+    const o = tensOnes % 10
+    if (o === 0) {
+      parts.push('nonante')
+    } else if (o === 1) {
+      parts.push('nonante et ' + ONES[1])
+    } else {
+      parts.push('nonante-' + ONES[o])
+    }
+  }
+
+  return { word: parts.join(' '), endsWithCents, endsWithVingts }
+}
+
+// Precompute all 1000 segment words
+const SEGMENTS = new Array(1000)
+const SEGMENTS_ENDS_CENTS = new Array(1000)
+const SEGMENTS_ENDS_VINGTS = new Array(1000)
+
+for (let i = 0; i < 1000; i++) {
+  const result = buildSegment(i)
+  SEGMENTS[i] = result.word
+  SEGMENTS_ENDS_CENTS[i] = result.endsWithCents
+  SEGMENTS_ENDS_VINGTS[i] = result.endsWithVingts
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function getScaleWord (scaleIndex, segment) {
+  if (scaleIndex === 1) return THOUSAND
+
+  if (scaleIndex % 2 === 0) {
+    const arrayIndex = (scaleIndex / 2) - 1
+    const baseWord = SCALES[arrayIndex]
+    if (!baseWord) return ''
+    return segment > 1n ? baseWord + 's' : baseWord
+  } else {
+    const arrayIndex = ((scaleIndex - 1) / 2) - 1
+    const ardWord = SCALES_ARD[arrayIndex]
+    if (!ardWord) return THOUSAND
+    return segment > 1n ? ardWord + 's' : ardWord
+  }
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n, withHyphen = false) {
+  if (n === 0n) return ZERO
+
+  if (n < 1000n) {
+    const word = SEGMENTS[Number(n)]
+    return withHyphen ? word.replace(/ /g, '-') : word
+  }
+
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    let result
+    if (thousands === 1) {
+      result = THOUSAND
+    } else {
+      let thousandsWord = SEGMENTS[thousands]
+      if (SEGMENTS_ENDS_CENTS[thousands] || SEGMENTS_ENDS_VINGTS[thousands]) {
+        thousandsWord = thousandsWord.slice(0, -1)
+      }
+      result = thousandsWord + (withHyphen ? '-' : ' ') + THOUSAND
+    }
+
+    if (remainder > 0) {
+      result += (withHyphen ? '-' : ' ') + SEGMENTS[remainder]
+    }
+
+    if (withHyphen) {
+      result = result.replace(/ /g, '-')
+    }
+
+    return result
+  }
+
+  return buildLargeNumberWords(n, withHyphen)
+}
+
+function buildLargeNumberWords (n, withHyphen) {
+  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
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      const scaleWord = scaleIndex > 0 ? getScaleWord(scaleIndex, BigInt(segment)) : ''
+
+      if (scaleIndex === 0) {
+        parts.push(SEGMENTS[segment])
+      } else if (scaleIndex === 1) {
+        if (segment === 1) {
+          parts.push(THOUSAND)
+        } else {
+          let segWords = SEGMENTS[segment]
+          if (SEGMENTS_ENDS_CENTS[segment] || SEGMENTS_ENDS_VINGTS[segment]) {
+            segWords = segWords.slice(0, -1)
+          }
+          parts.push(segWords)
+          parts.push(scaleWord)
         }
+      } else {
+        parts.push(SEGMENTS[segment])
+        parts.push(scaleWord)
       }
-      return pair
-    })
+    }
+
+    scaleIndex--
+  }
+
+  const sep = withHyphen ? '-' : ' '
+  let result = parts.join(sep)
+
+  if (withHyphen) {
+    result = result.replace(/ /g, '-')
   }
+
+  return result
+}
+
+function decimalPartToWords (decimalPart, withHyphen) {
+  let result = ''
+  const sep = withHyphen ? '-' : ' '
+
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += sep
+    result += ZERO
+    i++
+  }
+
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += sep
+    result += integerToWords(BigInt(remainder), withHyphen)
+  }
+
+  return result
 }
 
 /**
- * Converts a number to Belgian French cardinal (written) form.
+ * Converts a numeric value to Belgian French words.
  *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- * @returns {string} The number expressed in Belgian French words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.withHyphenSeparator=false] - Use hyphens between words
+ * @returns {string} The number in Belgian French words
  */
-export default function convertToWords (value, options = {}) {
-  return new BelgianFrench(options).convertToWords(value)
+function toWords (value, options) {
+  options = validateOptions(options)
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+  const withHyphen = options.withHyphenSeparator || false
+
+  let result = ''
+  const sep = withHyphen ? '-' : ' '
+
+  if (isNegative) {
+    result = NEGATIVE + sep
+  }
+
+  result += integerToWords(integerPart, withHyphen)
+
+  if (decimalPart) {
+    result += sep + DECIMAL_SEP + sep + decimalPartToWords(decimalPart, withHyphen)
+  }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/fr.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Converts a numeric value to French words.
+ *
+ * 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
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.withHyphenSeparator=false] - Use hyphens between all words
+ * @returns {string} The number in French words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)           // 'vingt et un'
+ * toWords(80)           // 'quatre-vingts'
+ * toWords(1000000)      // 'un million'
+ */
+export function toWords(value: number | string | bigint, options?: {
+    withHyphenSeparator?: boolean | undefined;
+}): string;