metaowl 0.1.3 → 0.2.0

package/test/error-boundary.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  onError,
+  setErrorContext,
+  getErrorContext,
+  clearErrorContext,
+  captureError,
+  initGlobalErrorHandling
+} from '../modules/error-boundary.js'
+
+describe('Error Boundary', () => {
+  beforeEach(() => {
+    clearErrorContext()
+    // Clear all handlers
+    vi.clearAllMocks()
+  })
+
+  describe('onError', () => {
+    it('registers an error handler', () => {
+      const handler = vi.fn()
+      const unsubscribe = onError(handler)
+
+      // Simulate error
+      const error = new Error('Test error')
+      captureError(error)
+
+      expect(handler).toHaveBeenCalled()
+      unsubscribe()
+    })
+
+    it('returns unsubscribe function', () => {
+      const handler = vi.fn()
+      const unsubscribe = onError(handler)
+
+      unsubscribe()
+
+      // Simulate error after unsubscribe
+      const error = new Error('Test error')
+      captureError(error)
+
+      expect(handler).not.toHaveBeenCalled()
+    })
+
+    it('calls multiple handlers', () => {
+      const handler1 = vi.fn()
+      const handler2 = vi.fn()
+
+      onError(handler1)
+      onError(handler2)
+
+      const error = new Error('Test error')
+      captureError(error)
+
+      expect(handler1).toHaveBeenCalled()
+      expect(handler2).toHaveBeenCalled()
+    })
+
+    it('passes error and context to handler', () => {
+      const handler = vi.fn()
+      setErrorContext({ route: '/test' })
+
+      onError(handler)
+
+      const error = new Error('Test error')
+      captureError(error, { component: 'TestComponent' })
+
+      expect(handler).toHaveBeenCalledWith(error, {
+        route: '/test',
+        component: 'TestComponent'
+      })
+    })
+  })
+
+  describe('setErrorContext / getErrorContext', () => {
+    it('sets and gets error context', () => {
+      setErrorContext({ route: '/home' })
+
+      expect(getErrorContext()).toEqual({ route: '/home' })
+    })
+
+    it('merges context objects', () => {
+      setErrorContext({ route: '/home' })
+      setErrorContext({ user: 'john' })
+
+      expect(getErrorContext()).toEqual({
+        route: '/home',
+        user: 'john'
+      })
+    })
+  })
+
+  describe('clearErrorContext', () => {
+    it('clears all context', () => {
+      setErrorContext({ route: '/home', user: 'john' })
+      clearErrorContext()
+
+      expect(getErrorContext()).toEqual({})
+    })
+  })
+
+  describe('captureError', () => {
+    it('captures error and notifies handlers', () => {
+      const handler = vi.fn()
+      onError(handler)
+
+      const error = new Error('Captured error')
+      captureError(error)
+
+      expect(handler).toHaveBeenCalledWith(error, {})
+    })
+
+    it('includes context in captured error', () => {
+      const handler = vi.fn()
+      setErrorContext({ app: 'test' })
+      onError(handler)
+
+      const error = new Error('Test error')
+      captureError(error, { component: 'Home' })
+
+      expect(handler).toHaveBeenCalledWith(error, {
+        app: 'test',
+        component: 'Home'
+      })
+    })
+  })
+})

package/test/forms.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useForm, validators, createSchema } from '../modules/forms.js'
+
+describe('Forms', () => {
+  describe('useForm', () => {
+    it('creates form with initial values', () => {
+      const form = useForm({
+        name: { default: 'John' },
+        email: { default: '' }
+      })
+
+      expect(form.fields.name).toBe('John')
+      expect(form.fields.email).toBe('')
+    })
+
+    it('tracks dirty state', () => {
+      const form = useForm({
+        name: { default: '' }
+      })
+
+      expect(form.isDirty).toBe(false)
+      form.setValue('name', 'Jane')
+      expect(form.isDirty).toBe(true)
+    })
+
+    it('tracks touched state', () => {
+      const form = useForm({
+        name: { default: '' }
+      })
+
+      expect(form.isTouched).toBe(false)
+      form.setTouched('name')
+      expect(form.isTouched).toBe(true)
+    })
+
+    it('validates with sync validators', async () => {
+      const form = useForm({
+        name: {
+          default: '',
+          validation: (v) => v.length >= 3 || 'Min 3 chars'
+        }
+      })
+
+      // Invalid
+      form.setValue('name', 'Jo')
+      const isValid1 = await form.validateField('name')
+      expect(isValid1).toBe(false)
+      expect(form.errors.name).toBe('Min 3 chars')
+
+      // Valid
+      form.setValue('name', 'John')
+      const isValid2 = await form.validateField('name')
+      expect(isValid2).toBe(true)
+      expect(form.errors.name).toBe(null)
+    })
+
+    it('validates all fields', async () => {
+      const form = useForm({
+        name: {
+          default: '',
+          validation: (v) => !!v || 'Required'
+        },
+        email: {
+          default: '',
+          validation: (v) => !!v || 'Required'
+        }
+      })
+
+      const isValid = await form.validate()
+      expect(isValid).toBe(false)
+      expect(form.errors.name).toBe('Required')
+      expect(form.errors.email).toBe('Required')
+    })
+
+    it('handles submit', async () => {
+      const onSubmit = vi.fn()
+      const form = useForm({
+        name: { default: 'John' }
+      })
+
+      const handleSubmit = form.handleSubmit(onSubmit)
+      await handleSubmit()
+
+      expect(onSubmit).toHaveBeenCalledWith({ name: 'John' })
+    })
+
+    it('validates before submit', async () => {
+      const onSubmit = vi.fn()
+      const form = useForm({
+        name: {
+          default: '',
+          validation: (v) => !!v || 'Required'
+        }
+      })
+
+      const handleSubmit = form.handleSubmit(onSubmit)
+      await handleSubmit()
+
+      expect(onSubmit).not.toHaveBeenCalled()
+      expect(form.errors.name).toBe('Required')
+    })
+
+    it('resets form', () => {
+      const form = useForm({
+        name: { default: 'John' }
+      })
+
+      form.setValue('name', 'Jane')
+      form.setTouched('name')
+      form.reset()
+
+      expect(form.fields.name).toBe('John')
+      expect(form.isDirty).toBe(false)
+      expect(form.isTouched).toBe(false)
+    })
+
+    it('supports register method', () => {
+      const form = useForm({
+        name: { default: '' }
+      })
+
+      const props = form.register('name')
+
+      expect(props.value).toBe('')
+      expect(typeof props.onChange).toBe('function')
+      expect(typeof props.onBlur).toBe('function')
+    })
+  })
+
+  describe('validators', () => {
+    describe('required', () => {
+      it('validates non-empty', () => {
+        const validator = validators.required()
+        expect(validator('')).toBe('Required')
+        expect(validator('test')).toBe(true)
+      })
+
+      it('allows custom message', () => {
+        const validator = validators.required('Field required')
+        expect(validator('')).toBe('Field required')
+      })
+    })
+
+    describe('minLength', () => {
+      it('validates min length', () => {
+        const validator = validators.minLength(3)
+        expect(validator('ab')).toBe('Min 3 characters')
+        expect(validator('abc')).toBe(true)
+      })
+    })
+
+    describe('maxLength', () => {
+      it('validates max length', () => {
+        const validator = validators.maxLength(5)
+        expect(validator('abcdef')).toBe('Max 5 characters')
+        expect(validator('abc')).toBe(true)
+      })
+    })
+
+    describe('email', () => {
+      it('validates email format', () => {
+        const validator = validators.email()
+        expect(validator('invalid')).toBe('Invalid email')
+        expect(validator('test@example.com')).toBe(true)
+      })
+    })
+
+    describe('match', () => {
+      it('validates field match', () => {
+        const validator = validators.match('password', 'Passwords must match')
+        expect(validator('secret', { password: 'different' })).toBe('Passwords must match')
+        expect(validator('secret', { password: 'secret' })).toBe(true)
+      })
+    })
+  })
+
+  describe('createSchema', () => {
+    it('creates form config from schema', () => {
+      const schema = createSchema({
+        name: [validators.required(), validators.minLength(3)],
+        email: validators.email()
+      })
+
+      expect(schema.name).toBeDefined()
+      expect(schema.email).toBeDefined()
+
+      // Test validation
+      const nameValidator = schema.name.validation
+      expect(nameValidator('ab', {})).toBe('Min 3 characters')
+      expect(nameValidator('john', {})).toBe(true)
+    })
+
+    it('accepts single validator', () => {
+      const schema = createSchema({
+        email: validators.email()
+      })
+
+      const emailValidator = schema.email.validation
+      expect(emailValidator('test', {})).toBe('Invalid email')
+      expect(emailValidator('test@example.com', {})).toBe(true)
+    })
+  })
+})

package/test/i18n.test.js

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  configureI18n,
+  t,
+  getLocale,
+  setLocale,
+  i18n,
+  loadLocaleMessages,
+  formatDate,
+  formatNumber,
+  formatCurrency,
+  formatRelativeTime,
+  createNamespacedT
+} from '../modules/i18n.js'
+
+describe('i18n', () => {
+  beforeEach(() => {
+    configureI18n({
+      locale: 'en',
+      fallbackLocale: 'en',
+      messages: {
+        en: {
+          hello: 'Hello',
+          greeting: 'Hello {{name}}',
+          count: {
+            zero: 'No items',
+            one: 'One item',
+            other: '{{n}} items'
+          }
+        },
+        de: {
+          hello: 'Hallo',
+          greeting: 'Hallo {{name}}'
+        }
+      }
+    })
+  })
+
+  describe('t()', () => {
+    it('translates simple key', () => {
+      expect(t('hello')).toBe('Hello')
+    })
+
+    it('interpolates values', () => {
+      expect(t('greeting', { name: 'World' })).toBe('Hello World')
+    })
+
+    it('returns key if translation not found', () => {
+      expect(t('nonexistent.key')).toBe('nonexistent.key')
+    })
+
+    it('uses fallback locale', () => {
+      configureI18n({ locale: 'fr', fallbackLocale: 'en' })
+      expect(t('hello')).toBe('Hello') // Falls back to English
+    })
+  })
+
+  describe('pluralization', () => {
+    it('handles zero', () => {
+      const result = t('count', { n: 0 })
+      expect(result).toBe('No items')
+    })
+
+    it('handles one', () => {
+      const result = t('count', { n: 1 })
+      expect(result).toBe('One item')
+    })
+
+    it('handles other', () => {
+      const result = t('count', { n: 5 })
+      expect(result).toBe('5 items')
+    })
+
+    it('uses fallback when form not defined', () => {
+      configureI18n({
+        locale: 'de',
+        messages: {
+          de: {
+            items: {
+              one: 'Ein Artikel'
+              // missing 'other'
+            }
+          }
+        }
+      })
+    })
+  })
+
+  describe('locale switching', () => {
+    it('sets and gets locale', async () => {
+      await setLocale('de')
+      expect(getLocale()).toBe('de')
+      expect(document.documentElement.lang).toBe('de')
+    })
+
+    it('updates html lang attribute', async () => {
+      await setLocale('de')
+      expect(document.documentElement.lang).toBe('de')
+    })
+  })
+
+  describe('loadLocaleMessages', () => {
+    it('loads messages asynchronously', async () => {
+      const messages = { goodbye: 'Farewell' }
+      await loadLocaleMessages('en', messages)
+
+      expect(t('goodbye')).toBe('Farewell')
+    })
+
+    it('merges with existing messages', async () => {
+      await loadLocaleMessages('en', { newKey: 'New Value' })
+
+      expect(t('hello')).toBe('Hello') // Still exists
+      expect(t('newKey')).toBe('New Value') // Added
+    })
+  })
+
+  describe('formatDate', () => {
+    it('formats date according to locale', () => {
+      const date = new Date('2024-01-15')
+      const result = formatDate(date, { dateStyle: 'short' })
+      expect(result).toContain('1')
+      expect(result).toContain('15')
+    })
+  })
+
+  describe('formatNumber', () => {
+    it('formats number according to locale', () => {
+      expect(formatNumber(1234.5)).toContain('1')
+      expect(formatNumber(1234.5)).toContain('5')
+    })
+  })
+
+  describe('formatCurrency', () => {
+    it('formats currency', () => {
+      const result = formatCurrency(1234.5, 'USD')
+      expect(result).toContain('$')
+    })
+
+    it('formats EUR', () => {
+      const result = formatCurrency(1234.5, 'EUR')
+      expect(result).toContain('€')
+    })
+  })
+
+  describe('formatRelativeTime', () => {
+    it('formats relative time', () => {
+      const future = new Date(Date.now() + 2 * 60 * 60 * 1000)
+      const result = formatRelativeTime(future)
+      expect(result).toContain('2')
+    })
+  })
+
+  describe('createNamespacedT', () => {
+    it('creates namespaced translator', () => {
+      configureI18n({
+        messages: {
+          en: {
+            forms: {
+              name: { label: 'Name' },
+              email: { label: 'Email' }
+            }
+          }
+        }
+      })
+
+      const tf = createNamespacedT('forms')
+      expect(tf('name.label')).toBe('Name')
+      expect(tf('email.label')).toBe('Email')
+    })
+  })
+
+  describe('i18n object', () => {
+    it('exposes locale getter', () => {
+      expect(i18n.locale).toBe('en')
+    })
+
+    it('exposes t function', () => {
+      expect(i18n.t('hello')).toBe('Hello')
+    })
+
+    it('exposes format functions', () => {
+      expect(typeof i18n.formatDate).toBe('function')
+      expect(typeof i18n.formatNumber).toBe('function')
+      expect(typeof i18n.formatCurrency).toBe('function')
+    })
+  })
+})