@tokentop/ttop 0.2.2

package/src/utils/currency.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  formatBudgetDisplay,
+  formatCurrency,
+  isValidCurrencyInput,
+  parseCurrencyInput,
+} from './currency.ts';
+
+describe('parseCurrencyInput', () => {
+  test('returns null for empty or whitespace input', () => {
+    expect(parseCurrencyInput('')).toBeNull();
+    expect(parseCurrencyInput('   ')).toBeNull();
+  });
+
+  test('parses US format with thousands and decimal separators', () => {
+    expect(parseCurrencyInput('1,234.56')).toBe(1234.56);
+  });
+
+  test('parses European format with period thousands and comma decimal', () => {
+    expect(parseCurrencyInput('1.234,56')).toBe(1234.56);
+  });
+
+  test('parses plain numbers', () => {
+    expect(parseCurrencyInput('42.50')).toBe(42.5);
+  });
+
+  test('strips supported currency symbols before parsing', () => {
+    expect(parseCurrencyInput('$100')).toBe(100);
+    expect(parseCurrencyInput('€100')).toBe(100);
+    expect(parseCurrencyInput('£100')).toBe(100);
+  });
+
+  test('treats comma as decimal separator when not thousands grouping', () => {
+    expect(parseCurrencyInput('10,50')).toBe(10.5);
+  });
+
+  test('treats comma as thousands separator with 3 digits after comma', () => {
+    expect(parseCurrencyInput('1,234')).toBe(1234);
+  });
+
+  test('returns null for invalid input', () => {
+    expect(parseCurrencyInput('abc')).toBeNull();
+  });
+
+  test('rounds parsed values to 2 decimal places', () => {
+    const parsed = parseCurrencyInput('10.129');
+    expect(parsed).toBe(Math.round(10.129 * 100) / 100);
+  });
+});
+
+describe('formatCurrency', () => {
+  test('returns None for null input', () => {
+    expect(formatCurrency(null)).toBe('None');
+  });
+
+  test('formats compact values >= 1000 as k notation', () => {
+    expect(formatCurrency(1234, { compact: true })).toBe('$1.2k');
+  });
+
+  test('formats compact values >= 100 as rounded integer', () => {
+    expect(formatCurrency(234.4, { compact: true })).toBe('$234');
+  });
+
+  test('formats compact values >= 10 with one decimal place', () => {
+    expect(formatCurrency(42.34, { compact: true })).toBe('$42.3');
+  });
+
+  test('formats compact values < 10 with two decimal places', () => {
+    expect(formatCurrency(9.5, { compact: true })).toBe('$9.50');
+  });
+
+  test('formats non-compact values with locale separators and two decimals', () => {
+    expect(formatCurrency(1234.5)).toBe('$1,234.50');
+  });
+
+  test('omits currency symbol when showSymbol is false', () => {
+    expect(formatCurrency(1234.5, { showSymbol: false })).toBe('1,234.50');
+    expect(formatCurrency(1234, { compact: true, showSymbol: false })).toBe('1.2k');
+  });
+});
+
+describe('formatBudgetDisplay', () => {
+  test('returns None for null input', () => {
+    expect(formatBudgetDisplay(null)).toBe('None');
+  });
+
+  test('delegates formatting to formatCurrency for numeric values', () => {
+    expect(formatBudgetDisplay(1234.5)).toBe(formatCurrency(1234.5));
+  });
+});
+
+describe('isValidCurrencyInput', () => {
+  test('returns true for empty input (represents no value)', () => {
+    expect(isValidCurrencyInput('')).toBe(true);
+    expect(isValidCurrencyInput('   ')).toBe(true);
+  });
+
+  test('returns true for valid numeric input', () => {
+    expect(isValidCurrencyInput('42.50')).toBe(true);
+    expect(isValidCurrencyInput('1.234,56')).toBe(true);
+  });
+
+  test('returns false for invalid input', () => {
+    expect(isValidCurrencyInput('abc')).toBe(false);
+  });
+});

package/src/utils/currency.ts

@@ -0,0 +1,79 @@
+/**
+ * Parse a currency input string that may use either . or , as decimal separator.
+ * Handles US format (1,234.56) and European format (1.234,56).
+ */
+export function parseCurrencyInput(input: string): number | null {
+  if (!input || input.trim() === '') {
+    return null;
+  }
+  
+  let normalized = input.trim().replace(/[$€£]/g, '').replace(/\s/g, '');
+  
+  const hasComma = normalized.includes(',');
+  const hasPeriod = normalized.includes('.');
+  
+  if (hasComma && hasPeriod) {
+    const lastComma = normalized.lastIndexOf(',');
+    const lastPeriod = normalized.lastIndexOf('.');
+    
+    if (lastComma > lastPeriod) {
+      // European: 1.234,56 → remove periods, comma becomes decimal
+      normalized = normalized.replace(/\./g, '').replace(',', '.');
+    } else {
+      // US: 1,234.56 → remove commas
+      normalized = normalized.replace(/,/g, '');
+    }
+  } else if (hasComma) {
+    const parts = normalized.split(',');
+    // 3 digits after comma = thousands separator (1,234), otherwise decimal (10,50)
+    if (parts.length === 2 && parts[1]!.length === 3 && parts[0]!.length > 0) {
+      normalized = normalized.replace(',', '');
+    } else {
+      normalized = normalized.replace(',', '.');
+    }
+  }
+  
+  const parsed = parseFloat(normalized);
+  
+  if (isNaN(parsed) || !isFinite(parsed)) {
+    return null;
+  }
+  
+  return Math.round(parsed * 100) / 100;
+}
+
+export function formatCurrency(value: number | null, options?: { 
+  compact?: boolean;
+  showSymbol?: boolean;
+}): string {
+  if (value === null) {
+    return 'None';
+  }
+  
+  const { compact = false, showSymbol = true } = options ?? {};
+  const symbol = showSymbol ? '$' : '';
+  
+  if (compact) {
+    if (value >= 1000) return `${symbol}${(value / 1000).toFixed(1)}k`;
+    if (value >= 100) return `${symbol}${Math.round(value)}`;
+    if (value >= 10) return `${symbol}${value.toFixed(1)}`;
+    return `${symbol}${value.toFixed(2)}`;
+  }
+  
+  return `${symbol}${value.toLocaleString('en-US', { 
+    minimumFractionDigits: 2, 
+    maximumFractionDigits: 2 
+  })}`;
+}
+
+export function formatBudgetDisplay(value: number | null): string {
+  if (value === null) {
+    return 'None';
+  }
+  return formatCurrency(value);
+}
+
+export function isValidCurrencyInput(input: string): boolean {
+  if (input.trim() === '') return true;
+  return parseCurrencyInput(input) !== null;
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.2.2'; // x-release-please-version