fix(tables): group a lone dot only when a zero-decimal amount came formatted

Greptile found that a bare `1.235` typed into a JPY column stored 1235. The
zero-decimal branch read the dot as grouping without asking where the value
came from, so typing, pasting, a tool write, or an import all inflated a
thousandfold in silence.

The rule was inverted relative to its own evidence. Grouping was justified as
"the one lone-separator form a formatter emits" — and a formatter always emits
its marker too. The marker is exactly what separates formatter output from
someone typing, and I had removed it as redundant two commits ago.

So a lone dot groups only for a zero-decimal currency AND only when a marker
came with it. `1.235 ¥` and `JPY 1.235` still read as 1235; a bare `1.235`
now stores 1.235 and displays `¥1` — wrong in a way the writer can see and
correct, rather than a silent thousandfold error.

This does not walk back the earlier fix. For a currency with one or two
decimal places a formatter always emits BOTH separators, so a lone dot there
never came from one and stays a decimal whether or not a marker is present —
`$1.234` is still 1.234. The marker only carries information in the
zero-decimal case, which is the only case that now consults it.

The two overlapping lone-separator tests are replaced by three that each state
one rule. Verified the new one fails when the marker requirement is reverted.

Author: waleedlatif1

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

@@ -160,36 +160,37 @@ describe('parseCurrencyInput', () => {
     expect(parseCurrencyInput('CHF 1’234.56')).toBe(1234.56)
   })
 
-  it('resolves a lone separator using the marker and the currency', () => {
-    // `1.235 ¥` is 1235 yen; a typed `1.235` is one-and-a-bit. A marker means a
-    // formatter produced it, and formatters group — except for the currencies
-    // that genuinely carry three decimals.
-    expect(parseCurrencyInput('1.235 ¥', 'JPY')).toBe(1235)
-    expect(parseCurrencyInput('0,500 KWD', 'KWD')).toBe(0.5)
-    expect(parseCurrencyInput('12,000 TND', 'TND')).toBe(12)
-    // Bare input keeps the typed reading.
+  it('reads a lone dot as the decimal point people type', () => {
+    // Typing `1.234` in a USD cell means 1.234, which the display rounds to
+    // $1.23 exactly as a spreadsheet does. Reading it as 1,234 would be a
+    // thousandfold surprise, marker or no marker.
+    expect(parseCurrencyInput('$1.234', 'USD')).toBe(1.234)
     expect(parseCurrencyInput('1.234')).toBe(1.234)
-    expect(parseCurrencyInput('1,500')).toBe(1500)
+    expect(parseCurrencyInput('1.234', 'EUR')).toBe(1.234)
   })
 
-  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.
-    // A dot stays the decimal point: typing `1.234` in a USD cell means 1.234,
-    // which the display rounds to $1.23 exactly as a spreadsheet does. Reading
-    // it as 1,234 would be a thousandfold surprise.
-    expect(parseCurrencyInput('$1.234', 'USD')).toBe(1.234)
-    expect(parseCurrencyInput('1.234')).toBe(1.234)
-    // Except where the currency has no decimals — the one lone-separator form
-    // a formatter actually emits.
+  it('groups a lone dot only for a zero-decimal currency that came formatted', () => {
+    // `1.235 ¥` cannot be a fraction of a yen, and is the single lone-separator
+    // form a formatter emits — but a formatter always emits its marker too.
     expect(parseCurrencyInput('1.235 ¥', 'JPY')).toBe(1235)
-    // A comma is grouping by convention, except for three-decimal currencies.
+    expect(parseCurrencyInput('JPY 1.235', 'JPY')).toBe(1235)
+    // Bare, it is someone typing. Inflating that to 1235 would be a silent
+    // thousandfold error; read literally it stores 1.235 and displays ¥1 —
+    // wrong in a way the writer can see and fix.
+    expect(parseCurrencyInput('1.235', 'JPY')).toBe(1.235)
+    expect(parseCurrencyInput('1.235', 'CLP')).toBe(1.235)
+  })
+
+  it('reads a lone comma as grouping, except where the currency has three decimals', () => {
+    // `1,500` is fifteen hundred by convention. A three-decimal currency's
+    // trailing three digits are decimals however the value arrived — which
+    // matters most for CSV import, where nothing carries a marker.
     expect(parseCurrencyInput('1,500', 'USD')).toBe(1500)
+    expect(parseCurrencyInput('1,500')).toBe(1500)
     expect(parseCurrencyInput('0,500', 'KWD')).toBe(0.5)
+    expect(parseCurrencyInput('0,500 KWD', 'KWD')).toBe(0.5)
     expect(parseCurrencyInput('12,000', 'TND')).toBe(12)
+    expect(parseCurrencyInput('12,000 TND', 'TND')).toBe(12)
   })
 
   it('refuses a scale suffix rather than shrinking the value', () => {

apps/sim/lib/table/currency.ts

@@ -294,12 +294,19 @@ export function parseCurrencyInput(raw: unknown, currencyCode?: string): number
   // that actually NAMES a currency is stripped — a magnitude word like `1.2 M`
   // or `3,4 mrd` is left in place, so it fails the amount-shape check below
   // instead of silently reading as 1.2, orders of magnitude too small.
-  const withoutPrefix = body.replace(CURRENCY_MARKER_PREFIX, (match, sign, letters, symbol) =>
-    isStrippableMarker(letters, symbol) ? sign : match
-  )
-  const withoutMarkers = withoutPrefix.replace(CURRENCY_MARKER_SUFFIX, (match, letters, symbol) =>
-    isStrippableMarker(letters, symbol) ? '' : match
-  )
+  // Whether a marker was actually stripped decides one ambiguous case below —
+  // see {@link loneSeparatorIsGrouping}.
+  let hadMarker = false
+  const withoutPrefix = body.replace(CURRENCY_MARKER_PREFIX, (match, sign, letters, symbol) => {
+    if (!isStrippableMarker(letters, symbol)) return match
+    hadMarker = true
+    return sign
+  })
+  const withoutMarkers = withoutPrefix.replace(CURRENCY_MARKER_SUFFIX, (match, letters, symbol) => {
+    if (!isStrippableMarker(letters, symbol)) return match
+    hadMarker = true
+    return ''
+  })
   const cleaned = withoutMarkers.replace(/[\s\u00a0\u202f\u2019']/gu, '')
   // What remains must be ONLY digits and separators. Anything else — a
   // US-format date, leftover prose — is not an amount.
@@ -321,7 +328,8 @@ export function parseCurrencyInput(raw: unknown, currencyCode?: string): number
     normalized = `${integerPart.split(groupSeparator).join('')}.${decimalParts[0]}`
   } else if (lastComma !== -1) {
     const repeated = digitsAndSeps.indexOf(',') !== lastComma
-    const grouping = repeated || loneSeparatorIsGrouping(digitsAndSeps, ',', currencyCode)
+    const grouping =
+      repeated || loneSeparatorIsGrouping(digitsAndSeps, ',', currencyCode, hadMarker)
     if (grouping) {
       if (!hasValidGrouping(digitsAndSeps, ',')) return null
       normalized = digitsAndSeps.split(',').join('')
@@ -330,7 +338,8 @@ export function parseCurrencyInput(raw: unknown, currencyCode?: string): number
     }
   } else if (lastDot !== -1) {
     const repeated = digitsAndSeps.indexOf('.') !== lastDot
-    const grouping = repeated || loneSeparatorIsGrouping(digitsAndSeps, '.', currencyCode)
+    const grouping =
+      repeated || loneSeparatorIsGrouping(digitsAndSeps, '.', currencyCode, hadMarker)
     if (grouping) {
       if (!hasValidGrouping(digitsAndSeps, '.')) return null
       normalized = digitsAndSeps.split('.').join('')
@@ -355,25 +364,31 @@ export function parseCurrencyInput(raw: unknown, currencyCode?: string): number
  * - A **dot** is the decimal point in the notation most people type, so it
  *   stays a decimal — typing `1.234` in a USD cell means 1.234, which the
  *   display then rounds to `$1.23`, exactly as a spreadsheet does. Reading it
- *   as 1,234 would be a thousandfold surprise. The exception is a currency with
- *   no decimal places at all: `1.235 ¥` cannot be a fraction of a yen, and is
- *   the one lone-separator form a formatter actually emits.
+ *   as 1,234 would be a thousandfold surprise.
  * - A **comma** is grouping by convention — `1,500` is fifteen hundred, not one
- *   and a half. The exception mirrors the first: a currency with three decimal
- *   places (KWD, TND) legitimately ends in three digits after its separator,
- *   so `0,500` is a half.
+ *   and a half. The exception: a currency with three decimal places (KWD, TND)
+ *   legitimately ends in three digits after its separator, so `0,500` is a half.
  *
- * A currency with one or two decimal places always formats with BOTH
- * separators, so no formatter output is decided here.
+ * The one case where a dot groups is a currency with NO decimal places, and
+ * only when a currency marker came with it. `1.235 ¥` cannot be a fraction of a
+ * yen, and is the single lone-separator form a formatter emits — but a formatter
+ * always emits its marker too. A bare `1.235` is someone typing, and inflating
+ * that to 1235 is a silent thousandfold error, where reading it literally stores
+ * 1.235 and displays `¥1` — wrong in a way the writer can see and correct.
+ *
+ * The marker carries no information for any other currency: one with one or two
+ * decimal places always formats with BOTH separators, so a lone separator there
+ * never came from a formatter in the first place.
  */
 function loneSeparatorIsGrouping(
   digitsAndSeps: string,
   separator: string,
-  currencyCode: string | undefined
+  currencyCode: string | undefined,
+  hadMarker: boolean
 ): boolean {
   if (!new RegExp(`\\${separator}\\d{3}$`).test(digitsAndSeps)) return false
   const fractionDigits = currencyFractionDigits(currencyCode)
-  return separator === ',' ? fractionDigits !== 3 : fractionDigits === 0
+  return separator === ',' ? fractionDigits !== 3 : fractionDigits === 0 && hadMarker
 }
 
 /** A currency's conventional decimal places, defaulting to 2 when unknown. */