fix(tables): read a lone separator against the column's currency

Review of the previous commit found the marker signal alone was too coarse.

The evidence: a currency with decimal places ALWAYS formats with both
separators — `1.234,56 €`, `$1,234.56`, `1.234,000 KWD`. Only a zero-decimal
currency emits a lone one (`1.235 ¥`). So a marker does not imply grouping; the
currency's own decimal places decide, and a three-decimal currency's trailing
three digits are decimals however the value arrived.

That matters most for CSV import, which passed no currency at all: a KWD column
importing `0,500` read as five hundred rather than a half. The column's code is
now forwarded, since nothing in a CSV carries a marker to fall back on.

A bare typed `1.234` still reads as decimals.

Author: waleedlatif1

apps/sim/lib/table/__tests__/currency.test.ts

@@ -172,6 +172,19 @@ describe('parseCurrencyInput', () => {
     expect(parseCurrencyInput('1,500')).toBe(1500)
   })
 
+  it('reads a lone separator against the currency, not just the marker', () => {
+    // A currency with decimals always formats with BOTH separators, so a lone
+    // one never comes from a formatter for those — only zero-decimal
+    // currencies produce `1.235 ¥`. And a three-decimal currency's trailing
+    // three digits are decimals however the value arrived, which matters for
+    // CSV import, where nothing carries a marker.
+    expect(parseCurrencyInput('1.235 ¥', 'JPY')).toBe(1235)
+    expect(parseCurrencyInput('0,500', 'KWD')).toBe(0.5)
+    expect(parseCurrencyInput('12,000', 'TND')).toBe(12)
+    expect(parseCurrencyInput('1,500', 'USD')).toBe(1500)
+    expect(parseCurrencyInput('1.234')).toBe(1.234)
+  })
+
   it('refuses a scale suffix rather than shrinking the value', () => {
     // `1.2 M` read as 1.2 would rewrite a column of millions a millionfold too
     // small — the same invented-value failure as an identifier, inverted.

apps/sim/lib/table/currency.ts

@@ -314,9 +314,15 @@ function loneSeparatorIsGrouping(
   currencyCode: string | undefined
 ): boolean {
   if (!new RegExp(`\\${separator}\\d{3}$`).test(digitsAndSeps)) return false
-  if (separator === ',' && !hadMarker) return true
-  if (!hadMarker) return false
-  return currencyFractionDigits(currencyCode) !== 3
+  // A currency with three decimal places (KWD, TND) legitimately ends in three
+  // digits after its separator, so for those the reading is always decimal —
+  // regardless of how the value arrived, since a CSV import carries no marker.
+  if (currencyFractionDigits(currencyCode) === 3) return false
+  // A comma tail of exactly three digits is grouping by convention (`1,500`).
+  if (separator === ',') return true
+  // A dot is the decimal point in the notation most users type, so it only
+  // reads as grouping when a marker shows a formatter produced the string.
+  return hadMarker
 }
 
 /** A currency's conventional decimal places, defaulting to 2 when unknown. */

apps/sim/lib/table/import.test.ts

@@ -145,6 +145,15 @@ describe('import', () => {
       expect(coerceValue('ask sales', 'currency')).toBeNull()
     })
 
+    it('reads an imported amount against the column currency', () => {
+      // Nothing in a CSV carries a currency marker, so the column's own code is
+      // the only signal for a three-decimal currency: `0,500` KWD is a half,
+      // not five hundred.
+      expect(coerceValue('0,500', 'currency', { currencyCode: 'KWD' })).toBe(0.5)
+      expect(coerceValue('12,000', 'currency', { currencyCode: 'TND' })).toBe(12)
+      expect(coerceValue('1,500', 'currency', { currencyCode: 'USD' })).toBe(1500)
+    })
+
     it('coerces booleans strictly', () => {
       expect(coerceValue('true', 'boolean')).toBe(true)
       expect(coerceValue('FALSE', 'boolean')).toBe(false)

apps/sim/lib/table/import.ts

@@ -385,7 +385,7 @@ export function inferSchemaFromCsv(
 export function coerceValue(
   value: unknown,
   colType: CsvColumnType,
-  options?: NormalizeDateCellOptions
+  options?: NormalizeDateCellOptions & { currencyCode?: string }
 ): string | number | boolean | null | Record<string, unknown> | unknown[] {
   if (value === null || value === undefined || value === '') return null
   switch (colType) {
@@ -394,9 +394,11 @@ export function coerceValue(
       return Number.isNaN(n) ? null : n
     }
     // Importing into an existing currency column: the file carries the
-    // formatted amount (`$1,234.56`) but the cell stores a bare number.
+    // formatted amount (`$1,234.56`) but the cell stores a bare number. The
+    // column's currency is forwarded because it decides how a lone separator
+    // reads — a three-decimal currency's `0,500` is a half, not five hundred.
     case 'currency':
-      return parseCurrencyInput(value)
+      return parseCurrencyInput(value, options?.currencyCode)
     case 'boolean': {
       const s = String(value).toLowerCase()
       if (s === 'true') return true
@@ -590,7 +592,10 @@ export function coerceRowsForTable(
       const col = colByName.get(colName)
       if (!col) continue
       const colType = (col.type as CsvColumnType) ?? 'string'
-      coerced[getColumnId(col)] = coerceValue(value, colType, options) as RowData[string]
+      coerced[getColumnId(col)] = coerceValue(value, colType, {
+        ...options,
+        ...(col.currencyCode !== undefined ? { currencyCode: col.currencyCode } : {}),
+      }) as RowData[string]
     }
     return coerced
   })