Hot fix for compact numbers...

Author: EncryptSL

src/main/kotlin/com/github/encryptsl/lite/eco/common/extensions/MoneyFormat.kt

@@ -1,5 +1,6 @@
 package com.github.encryptsl.lite.eco.common.extensions
 import java.math.BigDecimal
+import java.math.BigInteger
 import java.math.RoundingMode
 import java.text.DecimalFormat
 import java.text.DecimalFormatSymbols
@@ -9,53 +10,42 @@ private val units = arrayOf(
     "", "K", "M", "B", "T", "Q", "Qn", "S", "Se", "O", "N", "D"
 )
 
-/**
- * Converts a string to BigDecimal, including truncated units (e.g., "1.5M" → 1500000).
- */
 fun String.toValidDecimal(): BigDecimal? {
-    if (this.isBlank() || this.contains(" ")) return null
-    return decompressNumber(this)
+    val s = this.trim()
+    if (s.isBlank() || s.contains(" ")) return null
+    return decompressNumber(s)
 }
 
-/**
- * Returns a number in abbreviated format (e.g., 1500 → "1.5K").
- */
 fun BigDecimal.compactFormat(pattern: String, compactPattern: String, locale: String): String {
-    val (value, unit) = compactNumber(this) ?: (null to null)
-    return value?.let {
-        formatNumber(it, compactPattern, locale, compacted = true) + unit
-    } ?: formatNumber(this, pattern, locale)
+    val pair = compactNumber(this)
+    return if (pair != null) {
+        val (value, unit) = pair
+        formatNumber(value, compactPattern, locale, compacted = true) + unit
+    } else {
+        formatNumber(this, pattern, locale)
+    }
 }
 
-/**
- * Returns a number as currency according to the specified pattern and locale.
- */
 fun BigDecimal.moneyFormat(pattern: String, locale: String): String {
     return formatNumber(this, pattern, locale)
 }
 
-/**
- * Formats a number according to a pattern and locale.
- */
 private fun formatNumber(number: BigDecimal, pattern: String, locale: String, compacted: Boolean = false): String {
     val formatter = DecimalFormat().apply {
         decimalFormatSymbols = DecimalFormatSymbols.getInstance(getLocale(locale))
-        roundingMode = if (compacted) RoundingMode.UNNECESSARY else RoundingMode.HALF_UP
+        // always safe rounding; UNNECESSARY caused exceptions
+        roundingMode = if (compacted) RoundingMode.HALF_UP else RoundingMode.HALF_UP
         applyPattern(pattern)
     }
     return formatter.format(number)
 }
 
-/**
- * Decompress string → BigDecimal (e.g., "2.5M" → 2500000).
- */
 private fun decompressNumber(str: String): BigDecimal? {
-    val upper = str.uppercase(Locale.getDefault())
+    val upper = str.trim().uppercase(Locale.getDefault())
 
-    // find suffix
     val unit = units
         .filter { it.isNotEmpty() }
-        .sortedByDescending { it.length } // so that "Qn" takes precedence over "Q"
+        .sortedByDescending { it.length }
         .firstOrNull { upper.endsWith(it) }
 
     return if (unit != null) {
@@ -67,36 +57,28 @@ private fun decompressNumber(str: String): BigDecimal? {
     }
 }
 
-/**
- * Compact BigDecimal → Pair(value, unit).
- */
 private fun compactNumber(number: BigDecimal): Pair<BigDecimal, String>? {
-    if (number == BigDecimal.ZERO) return null
+    if (number.compareTo(BigDecimal.ZERO) == 0) return null
 
-    val absNum = number.abs()
-    val exp = absNum.toBigInteger().toString().length - 1 // log10 over string length
-    val unitIndex = exp / 3
+    // use integer part to determine number of digits -> stable decision unit
+    val absIntPart: BigInteger = number.abs().toBigInteger()
+    if (absIntPart == BigInteger.ZERO) return null
 
+    val digits = absIntPart.toString().length
+    val unitIndex = (digits - 1) / 3
     if (unitIndex == 0) return null
 
-    if (unitIndex >= units.size) {
-        // fallback: use the last known unit
-        val divisor = BigDecimal.TEN.pow((units.size - 1) * 3)
-        return number.divide(divisor) to units.last()
-    }
+    val index = if (unitIndex >= units.size) units.size - 1 else unitIndex
+    val divisor = BigDecimal.TEN.pow(index * 3)
 
-    val divisor = BigDecimal.TEN.pow(unitIndex * 3)
-    return number.divide(divisor) to units[unitIndex]
+    // scale = 1 -> display up to 1 decimal place (for 44_888 -> 44.9K)
+    // If you always want no decimal places (44K), use scale = 0 and RoundingMode.DOWN
+    val scaled = number.divide(divisor, 1, RoundingMode.HALF_UP)
+
+    return scaled to units[index]
 }
 
-/**
- * Returns the locale based on a string (e.g., "en", "en-US", "zh_CN").
- */
 private fun getLocale(localeStr: String): Locale {
-    val parts = localeStr.split("-", "_")
-    return when (parts.size) {
-        1 -> Locale.of(parts[0])
-        2 -> Locale.of(parts[0], parts[1])
-        else -> Locale.of(parts[0], parts[1], parts[2])
-    }
+    // compatible and safe: "en", "en-US", "zh_CN" -> "en", "en-US", "zh-CN"
+    return Locale.forLanguageTag(localeStr.replace('_', '-'))
 }