test: add comprehensive tests for Q1 2026 features

- WCAG contrast checking (contrastRatio, meetsContrastLevel) - 10 tests
- SchemaRenderer AriaProps injection - 6 tests
- Spec-aligned i18n formatters (plural, date, number, locale) - 20 tests
- Mobile breakpoints and responsive value resolution - 13 tests

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/core/src/theme/__tests__/ThemeEngine.test.ts

@@ -21,6 +21,8 @@ import {
   mergeThemes,
   resolveThemeInheritance,
   resolveMode,
+  contrastRatio,
+  meetsContrastLevel,
 } from '../ThemeEngine';
 
 // ============================================================================
@@ -604,3 +606,63 @@ describe('resolveMode', () => {
     window.matchMedia = original;
   });
 });
+
+// ============================================================================
+// WCAG Contrast Checking (v2.0.7)
+// ============================================================================
+
+describe('contrastRatio', () => {
+  it('should return 21 for black and white', () => {
+    expect(contrastRatio('#000000', '#ffffff')).toBeCloseTo(21, 0);
+  });
+
+  it('should return 1 for identical colors', () => {
+    expect(contrastRatio('#336699', '#336699')).toBeCloseTo(1, 1);
+  });
+
+  it('should return null for invalid hex', () => {
+    expect(contrastRatio('invalid', '#000000')).toBeNull();
+    expect(contrastRatio('#000000', 'xyz')).toBeNull();
+  });
+
+  it('should handle shorthand hex (#RGB)', () => {
+    const ratio = contrastRatio('#000', '#fff');
+    expect(ratio).toBeCloseTo(21, 0);
+  });
+
+  it('should be order-independent', () => {
+    const ratio1 = contrastRatio('#000000', '#336699');
+    const ratio2 = contrastRatio('#336699', '#000000');
+    expect(ratio1).toBe(ratio2);
+  });
+});
+
+describe('meetsContrastLevel', () => {
+  it('should pass AA for black on white (normal text)', () => {
+    expect(meetsContrastLevel('#000000', '#ffffff', 'AA')).toBe(true);
+  });
+
+  it('should pass AAA for black on white (normal text)', () => {
+    expect(meetsContrastLevel('#000000', '#ffffff', 'AAA')).toBe(true);
+  });
+
+  it('should fail AA for similar grays', () => {
+    // #777 on #999 gives ~1.6:1 ratio
+    expect(meetsContrastLevel('#777777', '#999999', 'AA')).toBe(false);
+  });
+
+  it('should use lower threshold for large text (AA)', () => {
+    // #767676 on white gives ~4.54:1 (passes AA normal, passes AA large)
+    expect(meetsContrastLevel('#767676', '#ffffff', 'AA', false)).toBe(true);
+    expect(meetsContrastLevel('#767676', '#ffffff', 'AA', true)).toBe(true);
+  });
+
+  it('should use lower threshold for large text (AAA)', () => {
+    // Black on white: 21:1 — passes both
+    expect(meetsContrastLevel('#000000', '#ffffff', 'AAA', true)).toBe(true);
+  });
+
+  it('should return false for invalid colors', () => {
+    expect(meetsContrastLevel('invalid', '#ffffff', 'AA')).toBe(false);
+  });
+});

packages/i18n/src/__tests__/spec-formatters.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolvePlural,
+  formatDateSpec,
+  formatNumberSpec,
+  applyLocaleConfig,
+  type SpecPluralRule,
+} from '../utils/spec-formatters';
+
+// ============================================================================
+// PluralRuleSchema Consumer Tests
+// ============================================================================
+
+describe('resolvePlural', () => {
+  const rule: SpecPluralRule = {
+    key: 'items.count',
+    zero: 'No items',
+    one: '{count} item',
+    other: '{count} items',
+  };
+
+  it('should resolve zero form', () => {
+    // English 'other' is used for 0 by Intl.PluralRules, but 'zero' is explicitly checked
+    // In English, 0 maps to "other" category, but we fall back to rule.other
+    const result = resolvePlural(rule, 0, 'en');
+    expect(result).toBe('0 items');
+  });
+
+  it('should resolve one form', () => {
+    expect(resolvePlural(rule, 1, 'en')).toBe('1 item');
+  });
+
+  it('should resolve other form for plural', () => {
+    expect(resolvePlural(rule, 5, 'en')).toBe('5 items');
+  });
+
+  it('should fallback to other when form is not defined', () => {
+    const simpleRule: SpecPluralRule = {
+      key: 'items',
+      other: '{count} things',
+    };
+    expect(resolvePlural(simpleRule, 3, 'en')).toBe('3 things');
+  });
+
+  it('should work with different locales', () => {
+    const ruleWithTwo: SpecPluralRule = {
+      key: 'items',
+      one: '{count} element',
+      two: '{count} éléments (dual)',
+      other: '{count} éléments',
+    };
+    // Arabic has a 'two' plural category
+    expect(resolvePlural(ruleWithTwo, 2, 'ar')).toBe('2 éléments (dual)');
+  });
+});
+
+// ============================================================================
+// DateFormatSchema Consumer Tests
+// ============================================================================
+
+describe('formatDateSpec', () => {
+  it('should format date with dateStyle', () => {
+    const date = new Date('2026-02-11T12:00:00Z');
+    const result = formatDateSpec(date, { dateStyle: 'short' }, 'en-US');
+    expect(result).toBeTruthy();
+    expect(typeof result).toBe('string');
+  });
+
+  it('should return string for invalid date', () => {
+    expect(formatDateSpec('invalid-date', { dateStyle: 'medium' })).toBe('invalid-date');
+  });
+
+  it('should handle timeZone', () => {
+    const date = new Date('2026-02-11T12:00:00Z');
+    const result = formatDateSpec(date, {
+      dateStyle: 'medium',
+      timeZone: 'America/New_York',
+    }, 'en-US');
+    expect(result).toBeTruthy();
+  });
+
+  it('should handle hour12 option', () => {
+    const date = new Date('2026-02-11T15:30:00Z');
+    const result12 = formatDateSpec(date, { timeStyle: 'short', hour12: true }, 'en-US');
+    const result24 = formatDateSpec(date, { timeStyle: 'short', hour12: false }, 'en-US');
+    expect(result12).toBeTruthy();
+    expect(result24).toBeTruthy();
+  });
+});
+
+// ============================================================================
+// NumberFormatSchema Consumer Tests
+// ============================================================================
+
+describe('formatNumberSpec', () => {
+  it('should format decimal numbers', () => {
+    const result = formatNumberSpec(1234.56, { style: 'decimal' }, 'en-US');
+    expect(result).toContain('1,234');
+  });
+
+  it('should format currency', () => {
+    const result = formatNumberSpec(42.99, {
+      style: 'currency',
+      currency: 'USD',
+    }, 'en-US');
+    expect(result).toContain('$');
+    expect(result).toContain('42.99');
+  });
+
+  it('should format percentage', () => {
+    const result = formatNumberSpec(0.75, { style: 'percent' }, 'en-US');
+    expect(result).toContain('75');
+    expect(result).toContain('%');
+  });
+
+  it('should respect fraction digits', () => {
+    const result = formatNumberSpec(3.14159, {
+      style: 'decimal',
+      maximumFractionDigits: 2,
+    }, 'en-US');
+    expect(result).toBe('3.14');
+  });
+
+  it('should respect useGrouping', () => {
+    const withGrouping = formatNumberSpec(1234567, {
+      style: 'decimal',
+      useGrouping: true,
+    }, 'en-US');
+    const withoutGrouping = formatNumberSpec(1234567, {
+      style: 'decimal',
+      useGrouping: false,
+    }, 'en-US');
+    expect(withGrouping).toContain(',');
+    expect(withoutGrouping).not.toContain(',');
+  });
+});
+
+// ============================================================================
+// LocaleConfigSchema Consumer Tests
+// ============================================================================
+
+describe('applyLocaleConfig', () => {
+  it('should create bound formatting functions', () => {
+    const locale = applyLocaleConfig({
+      code: 'en-US',
+      direction: 'ltr',
+      numberFormat: { style: 'decimal', useGrouping: true },
+      dateFormat: { dateStyle: 'medium' },
+    });
+
+    expect(locale.code).toBe('en-US');
+    expect(locale.direction).toBe('ltr');
+    expect(locale.fallbackChain).toEqual([]);
+  });
+
+  it('should format dates using configured locale', () => {
+    const locale = applyLocaleConfig({
+      code: 'en-US',
+      dateFormat: { dateStyle: 'short' },
+    });
+
+    const result = locale.formatDate(new Date('2026-02-11'));
+    expect(result).toBeTruthy();
+  });
+
+  it('should format numbers using configured locale', () => {
+    const locale = applyLocaleConfig({
+      code: 'en-US',
+      numberFormat: { style: 'decimal', maximumFractionDigits: 2 },
+    });
+
+    const result = locale.formatNumber(1234.5678);
+    expect(result).toBeTruthy();
+  });
+
+  it('should allow overrides in formatting calls', () => {
+    const locale = applyLocaleConfig({
+      code: 'en-US',
+      numberFormat: { style: 'decimal' },
+    });
+
+    const result = locale.formatNumber(42.99, {
+      style: 'currency',
+      currency: 'EUR',
+    });
+    expect(result).toContain('€');
+  });
+
+  it('should resolve plurals with configured locale', () => {
+    const locale = applyLocaleConfig({
+      code: 'en',
+    });
+
+    const rule: SpecPluralRule = {
+      key: 'items',
+      one: '{count} item',
+      other: '{count} items',
+    };
+
+    expect(locale.resolvePlural(rule, 1)).toBe('1 item');
+    expect(locale.resolvePlural(rule, 5)).toBe('5 items');
+  });
+
+  it('should default direction to ltr', () => {
+    const locale = applyLocaleConfig({ code: 'en' });
+    expect(locale.direction).toBe('ltr');
+  });
+});

packages/mobile/src/__tests__/breakpoints.test.ts

@@ -0,0 +1,84 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  BREAKPOINTS,
+  BREAKPOINT_ORDER,
+  resolveResponsiveValue,
+  getCurrentBreakpoint,
+} from '../breakpoints';
+
+describe('breakpoints', () => {
+  describe('BREAKPOINTS', () => {
+    it('should define Tailwind-compatible breakpoint values', () => {
+      expect(BREAKPOINTS.xs).toBe(0);
+      expect(BREAKPOINTS.sm).toBe(640);
+      expect(BREAKPOINTS.md).toBe(768);
+      expect(BREAKPOINTS.lg).toBe(1024);
+      expect(BREAKPOINTS.xl).toBe(1280);
+      expect(BREAKPOINTS['2xl']).toBe(1536);
+    });
+  });
+
+  describe('BREAKPOINT_ORDER', () => {
+    it('should be ordered from smallest to largest', () => {
+      expect(BREAKPOINT_ORDER).toEqual(['xs', 'sm', 'md', 'lg', 'xl', '2xl']);
+    });
+  });
+
+  describe('resolveResponsiveValue', () => {
+    it('should return direct value for non-object values', () => {
+      expect(resolveResponsiveValue(42, 'md')).toBe(42);
+      expect(resolveResponsiveValue('hello', 'lg')).toBe('hello');
+    });
+
+    it('should return value for exact breakpoint', () => {
+      expect(resolveResponsiveValue({ xs: 1, md: 2, lg: 3 }, 'md')).toBe(2);
+    });
+
+    it('should fall back to smaller breakpoint', () => {
+      expect(resolveResponsiveValue({ xs: 1, lg: 3 }, 'md')).toBe(1);
+    });
+
+    it('should return undefined when no breakpoint matches', () => {
+      expect(resolveResponsiveValue({ lg: 3 }, 'sm')).toBeUndefined();
+    });
+
+    it('should handle null values', () => {
+      expect(resolveResponsiveValue(null as any, 'md')).toBeNull();
+    });
+  });
+
+  describe('getCurrentBreakpoint', () => {
+    it('should return xs for small widths', () => {
+      expect(getCurrentBreakpoint(320)).toBe('xs');
+    });
+
+    it('should return sm for 640px', () => {
+      expect(getCurrentBreakpoint(640)).toBe('sm');
+    });
+
+    it('should return md for 768px', () => {
+      expect(getCurrentBreakpoint(768)).toBe('md');
+    });
+
+    it('should return lg for 1024px', () => {
+      expect(getCurrentBreakpoint(1024)).toBe('lg');
+    });
+
+    it('should return xl for 1280px', () => {
+      expect(getCurrentBreakpoint(1280)).toBe('xl');
+    });
+
+    it('should return 2xl for 1536px+', () => {
+      expect(getCurrentBreakpoint(1536)).toBe('2xl');
+      expect(getCurrentBreakpoint(2000)).toBe('2xl');
+    });
+  });
+});