n2words 2.0.0 → 3.1.0

package/lib/languages/nb.js

@@ -1,100 +1,285 @@
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+/**
+ * Norwegian Bokmål language converter - Functional Implementation
+ *
+ * Self-contained module with its own input validation, ready for subpath exports.
+ *
+ * Key features:
+ * - Hyphenated tens+ones: "tjue-en" (21)
+ * - "og" conjunction after hundreds
+ * - Comma separator after thousands before hundreds
+ * - Short scale: million, milliard, billion, etc.
+ */
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary (module-level constants)
+// ============================================================================
+
+const ONES = ['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'åtte', 'ni']
+
+const TEENS = ['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']
+const TENS = ['', '', 'tjue', 'tretti', 'førti', 'femti', 'seksti', 'sytti', 'åtti', 'nitti']
+
+const HUNDRED = 'hundre'
+const THOUSAND = 'tusen'
+
+const ZERO = 'null'
+const NEGATIVE = 'minus'
+const DECIMAL_SEP = 'komma'
+
+// Short scale: million, milliard, billion, etc.
+const SCALES = ['million', 'milliard', 'billion', 'billiard', 'kvintillion', 'sekstillion', 'septillion', 'oktillion']
+
+// ============================================================================
+// Segment Building
+// ============================================================================
 
 /**
- * Norwegian Bokmål language converter.
+ * Builds segment word for 0-999.
+ * Returns object with word and hasHundred flag.
+ */
+function buildSegment (n) {
+  if (n === 0) return { word: '', hasHundred: false }
+
+  const ones = n % 10
+  const tens = Math.floor(n / 10) % 10
+  const hundreds = Math.floor(n / 100)
+
+  const parts = []
+  let hasHundred = false
+
+  // Hundreds: "en hundre", "to hundre"
+  if (hundreds > 0) {
+    hasHundred = true
+    parts.push(ONES[hundreds] + ' ' + HUNDRED)
+  }
+
+  // Tens and ones
+  const tensOnes = n % 100
+
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    // Single digit
+    parts.push(ONES[ones])
+  } else if (tensOnes < 20) {
+    // Teens
+    parts.push(TEENS[ones])
+  } else if (ones === 0) {
+    // Even tens
+    parts.push(TENS[tens])
+  } else {
+    // Hyphenated: "tjue-en"
+    parts.push(TENS[tens] + '-' + ONES[ones])
+  }
+
+  // Combine with " og " between hundreds and remainder
+  if (parts.length === 2) {
+    return { word: parts[0] + ' og ' + parts[1], hasHundred: true }
+  }
+  return { word: parts[0] || '', hasHundred }
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Norwegian Bokmål words.
  *
- * Supports:
- * - Hyphenation for compound numbers (tjue-en)
- * - "og" (and) for hundreds combinations
- * - Implicit '1' omission before tens and magnitudes
+ * @param {bigint} n - Non-negative integer to convert
+ * @returns {string} Norwegian words
  */
-export class NorwegianBokmal extends GreedyScaleLanguage {
-  negativeWord = 'minus'
-  decimalSeparatorWord = 'komma'
-  zeroWord = 'null'
-
-  scaleWords = [
-    [1_000_000_000_000_000_000_000_000_000n, 'oktillion'],
-    [1_000_000_000_000_000_000_000_000n, 'septillion'],
-    [1_000_000_000_000_000_000_000n, 'sekstillion'],
-    [1_000_000_000_000_000_000n, 'kvintillion'],
-    [1_000_000_000_000_000n, 'kvadrillion'],
-    [1_000_000_000_000n, 'billion'],
-    [1_000_000_000n, 'milliard'],
-    [1_000_000n, 'million'],
-    [1000n, 'tusen'],
-    [100n, 'hundre'],
-    [90n, 'nitti'],
-    [80n, 'åtti'],
-    [70n, 'sytti'],
-    [60n, 'seksti'],
-    [50n, 'femti'],
-    [40n, 'førti'],
-    [30n, 'tretti'],
-    [20n, 'tjue'],
-    [19n, 'nitten'],
-    [18n, 'atten'],
-    [17n, 'sytten'],
-    [16n, 'seksten'],
-    [15n, 'femten'],
-    [14n, 'fjorten'],
-    [13n, 'tretten'],
-    [12n, 'tolv'],
-    [11n, 'elleve'],
-    [10n, 'ti'],
-    [9n, 'ni'],
-    [8n, 'åtte'],
-    [7n, 'syv'],
-    [6n, 'seks'],
-    [5n, 'fem'],
-    [4n, 'fire'],
-    [3n, 'tre'],
-    [2n, 'to'],
-    [1n, 'en'],
-    [0n, 'null']
-  ]
-
-  /**
-   * Merges two adjacent word-sets according to Norwegian grammar rules.
-   *
-   * Norwegian-specific rules:
-   * - Implicit "en": `combineWordSets({ 'en': 1n }, { 'hundre': 100n })` → `{ 'hundre': 100n }`
-   * - Hyphenation for compound tens: `combineWordSets({ 'tjue': 20n }, { 'en': 1n })` → `{ 'tjue-en': 21n }`
-   * - "og" (and) after hundreds: `combineWordSets({ 'hundre': 100n }, { 'en': 1n })` → `{ 'hundre og en': 101n }`
-   * - Space-separated for large numbers (thousands+)
-   * - Comma separator for non-magnitude additions (e.g., \"tusen, en\")
-   *
-   * @param {Object} preceding The preceding word-set as `{ word: BigInt }`.
-   * @param {Object} following The following word-set as `{ word: BigInt }`.
-   * @returns {Object} Merged pair with combined word and resulting numeric value.
-   *
-   * @example
-   * combineWordSets({ 'en': 1n }, { 'hundre': 100n }); // { 'hundre': 100n }
-   * combineWordSets({ 'tjue': 20n }, { 'tre': 3n }); // { 'tjue-tre': 23n }
-   */
-  // Norwegian merge rules mirror the former Scandinavian base logic
-  combineWordSets (preceding, following) {
-    const precedingWord = Object.keys(preceding)[0]
-    const followingWord = Object.keys(following)[0]
-    const precedingValue = Object.values(preceding)[0]
-    const followingValue = Object.values(following)[0]
-
-    if (precedingValue === 1n && followingValue < 100n) {
-      return following
-    }
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  // Fast path: numbers < 1000
+  if (n < 1000n) {
+    return buildSegment(Number(n)).word
+  }
+
+  // Fast path: numbers < 1,000,000 (thousands)
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    let result = buildSegment(thousands).word + ' ' + THOUSAND
 
-    if (precedingValue < 100n && precedingValue > followingValue) {
-      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
+    if (remainder > 0) {
+      const remainderResult = buildSegment(remainder)
+      // Comma before hundreds, " og " before small numbers
+      if (remainderResult.hasHundred) {
+        result += ', ' + remainderResult.word
+      } else {
+        result += ' og ' + remainderResult.word
+      }
     }
 
-    if (precedingValue >= 100n && followingValue < 100n) {
-      return { [`${precedingWord} og ${followingWord}`]: precedingValue + followingValue }
+    return result
+  }
+
+  // For numbers >= 1,000,000, use scale decomposition
+  return buildLargeNumberWords(n)
+}
+
+/**
+ * Builds words for numbers >= 1,000,000.
+ *
+ * @param {bigint} n - Number >= 1,000,000
+ * @returns {string} Norwegian words
+ */
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  // Build segments of 3 digits from right to left
+  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
+  }
+
+  // Convert segments to words
+  const parts = []
+  let scaleIndex = segments.length - 1
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      const segmentResult = buildSegment(segment)
+
+      if (scaleIndex === 0) {
+        // Units segment
+        parts.push({ word: segmentResult.word, hasHundred: segmentResult.hasHundred, type: 'units' })
+      } else if (scaleIndex === 1) {
+        // Thousands
+        parts.push({ word: segmentResult.word + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })
+      } else {
+        // Millions+
+        const scaleWord = SCALES[scaleIndex - 2]
+        parts.push({ word: segmentResult.word + ' ' + scaleWord, hasHundred: false, type: 'million' })
+      }
     }
 
-    if (followingValue > precedingValue) {
-      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+    scaleIndex--
+  }
+
+  // Join parts with Norwegian rules
+  return joinNorwegianParts(parts)
+}
+
+/**
+ * Joins parts with Norwegian spacing and comma rules.
+ *
+ * @param {Array} parts - Parts with type metadata
+ * @returns {string} Joined string
+ */
+function joinNorwegianParts (parts) {
+  if (parts.length === 0) return ZERO
+  if (parts.length === 1) return parts[0].word
+
+  const result = []
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+    const nextPart = parts[i + 1]
+
+    result.push(part.word)
+
+    if (nextPart) {
+      if (part.type === 'thousand') {
+        // After thousands: comma if next has hundred, else " og "
+        if (nextPart.hasHundred) {
+          result.push(', ')
+        } else {
+          result.push(' og ')
+        }
+      } else if (part.type === 'million') {
+        // After millions: " og " for units without hundred, space otherwise
+        if (nextPart.type === 'units' && !nextPart.hasHundred) {
+          result.push(' og ')
+        } else {
+          result.push(' ')
+        }
+      } else {
+        result.push(' ')
+      }
     }
+  }
+
+  return result.join('')
+}
 
-    return { [`${precedingWord}, ${followingWord}`]: precedingValue + followingValue }
+/**
+ * Converts decimal digits to Norwegian words.
+ *
+ * @param {string} decimalPart - Decimal digits (without the point)
+ * @returns {string} Norwegian words for decimal part
+ */
+function decimalPartToWords (decimalPart) {
+  let result = ''
+
+  // Handle leading zeros
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
+  }
+
+  // Convert remainder as a single number
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
+
+  return result
+}
+
+/**
+ * Converts a numeric value to Norwegian Bokmål words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Norwegian words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)       // 'tjue-en'
+ * toWords(101)      // 'en hundre og en'
+ * toWords(1000000)  // 'en million'
+ */
+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
 }
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+export { toWords }

package/lib/languages/nl.d.ts

@@ -1,16 +1,26 @@
 /**
- * Dutch language converter.
+ * Converts a numeric value to Dutch words.
  *
- * Supports:
- * - Optional "en" (and) separator for tens
- * - Optional comma before hundreds
- * - Compound word formation without hyphenation
+ * 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.accentOne=true] - Use "één" instead of "een"
+ * @param {boolean} [options.includeOptionalAnd=false] - Include "en" before small numbers
+ * @param {boolean} [options.noHundredPairing=false] - Disable hundred pairing (1104→duizend honderdvier)
+ * @returns {string} The number in Dutch words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)                        // 'eenentwintig'
+ * toWords(1)                         // 'één'
+ * toWords(1, {accentOne: false})     // 'een'
+ * toWords(1104)                      // 'elfhonderd vier'
  */
-export class Dutch extends GreedyScaleLanguage {
-    constructor(options?: {});
-    scaleWords: (string | bigint)[][];
-    /** Combines two word-sets according to Dutch grammar rules. */
-    combineWordSets(preceding: any, following: any): any;
-    integerToWords(integerPart: any): string;
-}
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';
+export function toWords(value: number | string | bigint, options?: {
+    accentOne?: boolean | undefined;
+    includeOptionalAnd?: boolean | undefined;
+    noHundredPairing?: boolean | undefined;
+}): string;