@react-spa-scaffold/mcp 0.4.1 → 1.1.1

package/templates/src/lib/format.ts

@@ -1,119 +0,0 @@
-/**
- * Formatting utilities for dates, numbers, and currencies.
- * All formatters are locale-aware.
- */
-
-/**
- * Format a date with locale support
- */
-export function formatDate(
-  date: Date | string | number,
-  options: Intl.DateTimeFormatOptions = {},
-  locale?: string,
-): string {
-  const dateObj = date instanceof Date ? date : new Date(date);
-
-  if (isNaN(dateObj.getTime())) {
-    return 'Invalid date';
-  }
-
-  const defaultOptions: Intl.DateTimeFormatOptions = {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-    ...options,
-  };
-
-  return new Intl.DateTimeFormat(locale, defaultOptions).format(dateObj);
-}
-
-/**
- * Format a date with time
- */
-export function formatDateTime(
-  date: Date | string | number,
-  options: Intl.DateTimeFormatOptions = {},
-  locale?: string,
-): string {
-  return formatDate(
-    date,
-    {
-      hour: '2-digit',
-      minute: '2-digit',
-      ...options,
-    },
-    locale,
-  );
-}
-
-/**
- * Format relative time (e.g., "2 hours ago", "in 3 days")
- */
-export function formatRelativeTime(date: Date | string | number, locale?: string): string {
-  const dateObj = date instanceof Date ? date : new Date(date);
-
-  if (isNaN(dateObj.getTime())) {
-    return 'Invalid date';
-  }
-
-  const now = new Date();
-  const diffInSeconds = Math.floor((dateObj.getTime() - now.getTime()) / 1000);
-  const absoluteDiff = Math.abs(diffInSeconds);
-
-  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
-
-  if (absoluteDiff < 60) {
-    return rtf.format(diffInSeconds, 'second');
-  } else if (absoluteDiff < 3600) {
-    return rtf.format(Math.floor(diffInSeconds / 60), 'minute');
-  } else if (absoluteDiff < 86400) {
-    return rtf.format(Math.floor(diffInSeconds / 3600), 'hour');
-  } else if (absoluteDiff < 2592000) {
-    return rtf.format(Math.floor(diffInSeconds / 86400), 'day');
-  } else if (absoluteDiff < 31536000) {
-    return rtf.format(Math.floor(diffInSeconds / 2592000), 'month');
-  } else {
-    return rtf.format(Math.floor(diffInSeconds / 31536000), 'year');
-  }
-}
-
-/**
- * Format a number with locale support
- */
-export function formatNumber(value: number, options: Intl.NumberFormatOptions = {}, locale?: string): string {
-  return new Intl.NumberFormat(locale, options).format(value);
-}
-
-/**
- * Format a number as currency
- */
-export function formatCurrency(value: number, currency = 'USD', locale?: string): string {
-  return new Intl.NumberFormat(locale, {
-    style: 'currency',
-    currency,
-  }).format(value);
-}
-
-/**
- * Format a number as percentage
- */
-export function formatPercent(value: number, decimals = 0, locale?: string): string {
-  return new Intl.NumberFormat(locale, {
-    style: 'percent',
-    minimumFractionDigits: decimals,
-    maximumFractionDigits: decimals,
-  }).format(value);
-}
-
-/**
- * Format bytes to human readable string
- */
-export function formatBytes(bytes: number, decimals = 2): string {
-  if (bytes === 0) return '0 Bytes';
-
-  const k = 1024;
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
-}

package/templates/tests/unit/hooks/useContactForm.test.ts

@@ -1,60 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
-
-import { useContactForm } from '@/hooks/useContactForm';
-
-describe('useContactForm', () => {
-  describe('initial state', () => {
-    it('initializes with empty values and no errors', () => {
-      const { result } = renderHook(() => useContactForm());
-
-      expect(result.current.form.getValues()).toEqual({ name: '', email: '', message: '' });
-      expect(result.current.errors).toEqual({});
-      expect(result.current.isSubmitting).toBe(false);
-      expect(typeof result.current.onSubmit).toBe('function');
-    });
-  });
-
-  describe('validation', () => {
-    it.each([
-      { field: 'name', value: 'J', valid: { email: 'test@example.com', message: 'Valid message here' } },
-      { field: 'email', value: 'invalid', valid: { name: 'John', message: 'Valid message here' } },
-      { field: 'message', value: 'Short', valid: { name: 'John', email: 'test@example.com' } },
-    ])('rejects invalid $field', async ({ field, value, valid }) => {
-      const { result } = renderHook(() => useContactForm());
-
-      act(() => {
-        result.current.form.setValue(field as 'name' | 'email' | 'message', value);
-        Object.entries(valid).forEach(([k, v]) => {
-          result.current.form.setValue(k as 'name' | 'email' | 'message', v);
-        });
-      });
-
-      await act(async () => {
-        await result.current.form.trigger();
-      });
-
-      await waitFor(() => {
-        expect(result.current.errors[field as keyof typeof result.current.errors]).toBeDefined();
-      });
-    });
-
-    it('passes with valid data', async () => {
-      const { result } = renderHook(() => useContactForm());
-
-      act(() => {
-        result.current.form.setValue('name', 'John Doe');
-        result.current.form.setValue('email', 'test@example.com');
-        result.current.form.setValue('message', 'This is a valid message that is long enough.');
-      });
-
-      await act(async () => {
-        await result.current.form.trigger();
-      });
-
-      await waitFor(() => {
-        expect(result.current.errors).toEqual({});
-      });
-    });
-  });
-});

package/templates/tests/unit/lib/format.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  formatBytes,
-  formatCurrency,
-  formatDate,
-  formatDateTime,
-  formatNumber,
-  formatPercent,
-  formatRelativeTime,
-} from '@/lib/format';
-
-describe('formatDate', () => {
-  it('formats date objects and strings', () => {
-    const date = new Date('2024-01-15T12:00:00Z');
-    expect(formatDate(date, {}, 'en-US')).toContain('2024');
-    expect(formatDate('2024-06-20', {}, 'en-US')).toContain('2024');
-  });
-
-  it('returns "Invalid date" for invalid input', () => {
-    expect(formatDate('invalid')).toBe('Invalid date');
-  });
-
-  it('respects custom options', () => {
-    const date = new Date('2024-01-15');
-    expect(formatDate(date, { weekday: 'long' }, 'en-US')).toContain('Monday');
-  });
-});
-
-describe('formatDateTime', () => {
-  it('includes time in output', () => {
-    const date = new Date('2024-01-15T14:30:00Z');
-    expect(formatDateTime(date, {}, 'en-US')).toMatch(/\d{1,2}:\d{2}/);
-  });
-});
-
-describe('formatRelativeTime', () => {
-  it.each([
-    { offset: -30 * 1000, unit: 'seconds', pattern: /second|now/i },
-    { offset: -5 * 60 * 1000, unit: 'minutes', pattern: /minute/i },
-    { offset: -60 * 60 * 1000, unit: 'hours', pattern: /hour|ago/i },
-    { offset: 24 * 60 * 60 * 1000, unit: 'days (future)', pattern: /day|tomorrow/i },
-    { offset: -45 * 24 * 60 * 60 * 1000, unit: 'months', pattern: /month/i },
-    { offset: -400 * 24 * 60 * 60 * 1000, unit: 'years', pattern: /year/i },
-  ])('formats $unit correctly', ({ offset, pattern }) => {
-    const date = new Date(Date.now() + offset);
-    expect(formatRelativeTime(date, 'en-US')).toMatch(pattern);
-  });
-
-  it('returns "Invalid date" for invalid input', () => {
-    expect(formatRelativeTime('invalid')).toBe('Invalid date');
-  });
-
-  it('accepts timestamp numbers', () => {
-    const timestamp = Date.now() - 60 * 60 * 1000;
-    expect(formatRelativeTime(timestamp, 'en-US')).toMatch(/hour|ago/i);
-  });
-});
-
-describe('formatNumber', () => {
-  it.each([
-    { value: 1234567.89, options: {}, expected: '1,234,567.89' },
-    { value: 1234.5, options: { minimumFractionDigits: 2 }, expected: '1,234.50' },
-  ])('formats $value with options', ({ value, options, expected }) => {
-    expect(formatNumber(value, options, 'en-US')).toBe(expected);
-  });
-});
-
-describe('formatCurrency', () => {
-  it.each([
-    { value: 99.99, currency: 'USD', locale: 'en-US', expected: '$99.99' },
-    { value: 99.99, currency: 'EUR', locale: 'de-DE', contains: '€' },
-  ])('formats $currency correctly', ({ value, currency, locale, expected, contains }) => {
-    const result = formatCurrency(value, currency, locale);
-    if (expected) expect(result).toBe(expected);
-    if (contains) expect(result).toContain(contains);
-  });
-});
-
-describe('formatPercent', () => {
-  it.each([
-    { value: 0.25, decimals: 0, expected: '25%' },
-    { value: 0.2567, decimals: 2, expected: '25.67%' },
-  ])('formats $value with $decimals decimals', ({ value, decimals, expected }) => {
-    expect(formatPercent(value, decimals, 'en-US')).toBe(expected);
-  });
-});
-
-describe('formatBytes', () => {
-  it.each([
-    { bytes: 0, expected: '0 Bytes' },
-    { bytes: 1024, expected: '1 KB' },
-    { bytes: 1024 * 1024, expected: '1 MB' },
-    { bytes: 1024 * 1024 * 1024, expected: '1 GB' },
-    { bytes: 1536, decimals: 1, expected: '1.5 KB' },
-    { bytes: 1536, decimals: 0, expected: '2 KB' },
-  ])('formats $bytes bytes', ({ bytes, decimals, expected }) => {
-    expect(formatBytes(bytes, decimals)).toBe(expected);
-  });
-});