@i18n-micro/core 1.3.0 → 1.3.2

package/tests/base.test.ts

@@ -1,464 +0,0 @@
-import type { PluralFunc, Translations } from '@i18n-micro/types'
-import { BaseI18n, type BaseI18nOptions } from '../src/base'
-
-// Test implementation of BaseI18n
-class TestI18n extends BaseI18n {
-  private _locale: string
-  private _fallbackLocale: string
-  private _route: string
-
-  constructor(locale: string, fallbackLocale: string, route: string, options?: BaseI18nOptions) {
-    super(options)
-    this._locale = locale
-    this._fallbackLocale = fallbackLocale
-    this._route = route
-  }
-
-  public getLocale(): string {
-    return this._locale
-  }
-
-  public getFallbackLocale(): string {
-    return this._fallbackLocale
-  }
-
-  public getRoute(): string {
-    return this._route
-  }
-
-  public setLocale(locale: string): void {
-    this._locale = locale
-  }
-
-  public setRoute(route: string): void {
-    this._route = route
-  }
-}
-
-describe('BaseI18n', () => {
-  describe('Constructor', () => {
-    test('should initialize with default options', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.getLocale()).toBe('en')
-      expect(i18n.getFallbackLocale()).toBe('en')
-      expect(i18n.getRoute()).toBe('index')
-    })
-
-    test('should initialize with custom storage', () => {
-      const storage = { translations: new Map<string, Translations>() }
-      const i18n = new TestI18n('en', 'en', 'index', { storage })
-      expect(i18n).toBeDefined()
-    })
-
-    test('should initialize with custom plural function', () => {
-      const customPlural: PluralFunc = () => 'custom'
-      const i18n = new TestI18n('en', 'en', 'index', { plural: customPlural })
-      expect(i18n).toBeDefined()
-    })
-
-    test('should initialize with missingWarn option', () => {
-      const i18n = new TestI18n('en', 'en', 'index', { missingWarn: false })
-      expect(i18n).toBeDefined()
-    })
-
-    test('should initialize with missingHandler', () => {
-      const handler = jest.fn()
-      const i18n = new TestI18n('en', 'en', 'index', { missingHandler: handler })
-      expect(i18n).toBeDefined()
-    })
-  })
-
-  describe('t() method', () => {
-    test('should return empty string for empty key', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.t('')).toBe('')
-    })
-
-    test('should return translation for existing key', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { greeting: 'Hello' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.t('greeting')).toBe('Hello')
-    })
-
-    test('should interpolate params in translation', async () => {
-      const storage = { translations: new Map<string, Translations>() }
-      const i18n = new TestI18n('en', 'en', 'index', { storage })
-      const translations: Translations = { greeting: 'Hello, {name}!' }
-      await i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.t('greeting', { name: 'John' })).toBe('Hello, John!')
-    })
-
-    test('should use defaultValue when translation is missing', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.t('missing.key', undefined, 'Default value')).toBe('Default value')
-    })
-
-    test('should return key when translation is missing and no defaultValue', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.t('missing.key')).toBe('missing.key')
-    })
-
-    test('should fallback to fallbackLocale when translation is missing', async () => {
-      const storage = { translations: new Map<string, Translations>() }
-      const i18n = new TestI18n('en', 'fr', 'index', { storage })
-      const translations: Translations = { greeting: 'Bonjour' }
-      await i18n['helper'].loadTranslations('fr', translations)
-
-      expect(i18n.t('greeting')).toBe('Bonjour')
-    })
-
-    test('should use route-specific translation when routeName is provided', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const routeTranslations: Translations = { title: 'Route Title' }
-      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
-
-      expect(i18n.t('title', undefined, undefined, 'about')).toBe('Route Title')
-    })
-
-    test('should call missingHandler when translation is missing', () => {
-      const handler = jest.fn()
-      const i18n = new TestI18n('en', 'en', 'index', { missingHandler: handler })
-
-      i18n.t('missing.key')
-
-      expect(handler).toHaveBeenCalledWith('en', 'missing.key', 'index')
-    })
-
-    test('should call customMissingHandler when set (Nuxt runtime)', () => {
-      const customHandler = jest.fn()
-      const i18n = new TestI18n('en', 'en', 'index', {
-        getCustomMissingHandler: () => customHandler,
-      })
-
-      i18n.t('missing.key')
-
-      expect(customHandler).toHaveBeenCalledWith('en', 'missing.key', 'index')
-    })
-
-    test('should not warn when missingWarn is false', () => {
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
-      const i18n = new TestI18n('en', 'en', 'index', { missingWarn: false })
-
-      i18n.t('missing.key')
-
-      expect(consoleSpy).not.toHaveBeenCalled()
-      consoleSpy.mockRestore()
-    })
-  })
-
-  describe('ts() method', () => {
-    test('should return translation as string', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { greeting: 'Hello' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.ts('greeting')).toBe('Hello')
-    })
-
-    test('should return defaultValue when translation is missing', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.ts('missing.key', undefined, 'Default')).toBe('Default')
-    })
-
-    test('should return key when translation is missing and no defaultValue', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.ts('missing.key')).toBe('missing.key')
-    })
-
-    test('should convert non-string values to string', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { count: 42 }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.ts('count')).toBe('42')
-    })
-  })
-
-  describe('tc() method', () => {
-    test('should return defaultValue when count is undefined', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.tc('apples', { other: 'params' }, 'No count')).toBe('No count')
-    })
-
-    test('should use plural function with count', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { apples: 'apple|apples' }
-      await i18n['helper'].loadTranslations('en', translations)
-
-      // defaultPlural selects form by index: forms[count] or last form if count >= forms.length
-      // For 'apple|apples': forms[0]='apple', forms[1]='apples'
-      expect(i18n.tc('apples', 0)).toBe('apple')
-      expect(i18n.tc('apples', 1)).toBe('apples') // forms[1]
-      expect(i18n.tc('apples', 5)).toBe('apples') // last form
-    })
-
-    test('should handle count as number', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { apples: 'apple|apples' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.tc('apples', 2)).toBe('apples')
-    })
-
-    test('should handle count as Params object', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { apples: 'apple|apples' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.tc('apples', { count: 2, name: 'John' })).toBe('apples')
-    })
-
-    test('should return defaultValue when plural function returns null', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      // When translation is missing, t() returns key, which is passed to pluralFunc
-      // pluralFunc tries to process 'missing.key' as translation, but since it doesn't contain '|',
-      // it returns the key itself. So tc returns the key, not defaultValue.
-      // To test defaultValue, we need a case where pluralFunc actually returns null.
-      // This happens when translation exists but is empty or invalid.
-      expect(i18n.tc('missing.key', 1, 'Default')).toBe('missing.key')
-    })
-  })
-
-  describe('tn() method', () => {
-    test('should format number with default locale', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const result = i18n.tn(1234.56)
-      expect(result).toMatch(/1[,.]234[.,]56/)
-    })
-
-    test('should format number with custom options', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const result = i18n.tn(1234.56, { style: 'currency', currency: 'USD' })
-      expect(result).toContain('1,234.56')
-    })
-
-    test('should use current locale for formatting', () => {
-      const i18n = new TestI18n('ru', 'en', 'index')
-      const result = i18n.tn(1234.56)
-      // Russian locale uses different number formatting
-      expect(result).toBeDefined()
-    })
-  })
-
-  describe('td() method', () => {
-    test('should format date with default locale', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const date = new Date('2024-01-15')
-      const result = i18n.td(date)
-      expect(result).toBeDefined()
-      expect(result).not.toBe('Invalid Date')
-    })
-
-    test('should format date with custom options', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const date = new Date('2024-01-15')
-      const result = i18n.td(date, { year: 'numeric', month: 'long', day: 'numeric' })
-      expect(result).toContain('2024')
-      expect(result).toContain('January')
-    })
-
-    test('should handle date as number (timestamp)', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const timestamp = new Date('2024-01-15').getTime()
-      const result = i18n.td(timestamp)
-      expect(result).toBeDefined()
-      expect(result).not.toBe('Invalid Date')
-    })
-
-    test('should handle date as string', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const result = i18n.td('2024-01-15')
-      expect(result).toBeDefined()
-      expect(result).not.toBe('Invalid Date')
-    })
-  })
-
-  describe('tdr() method', () => {
-    test('should format relative time', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const yesterday = new Date(Date.now() - 86400000)
-      const result = i18n.tdr(yesterday)
-      expect(result).toBeDefined()
-      expect(result).toMatch(/day|ago/i)
-    })
-
-    test('should format relative time with custom options', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const yesterday = new Date(Date.now() - 86400000)
-      const result = i18n.tdr(yesterday, { numeric: 'always' })
-      expect(result).toBeDefined()
-    })
-
-    test('should handle invalid date gracefully', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const invalidDate = new Date('invalid')
-      const result = i18n.tdr(invalidDate)
-      expect(result).toBeDefined()
-    })
-  })
-
-  describe('has() method', () => {
-    test('should return true when translation exists', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { greeting: 'Hello' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.has('greeting')).toBe(true)
-    })
-
-    test('should return false when translation does not exist', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.has('missing.key')).toBe(false)
-    })
-
-    test('should check route-specific translation when routeName is provided', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const routeTranslations: Translations = { title: 'Route Title' }
-      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
-
-      expect(i18n.has('title', 'about')).toBe(true)
-      expect(i18n.has('title', 'index')).toBe(false)
-    })
-
-    test('should use current route when routeName is not provided', async () => {
-      const i18n = new TestI18n('en', 'en', 'about')
-      const routeTranslations: Translations = { title: 'Route Title' }
-      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
-
-      expect(i18n.has('title')).toBe(true)
-    })
-  })
-
-  describe('clearCache() method', () => {
-    test('should clear all translations from cache', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { greeting: 'Hello' }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.has('greeting')).toBe(true)
-
-      i18n.clearCache()
-
-      expect(i18n.has('greeting')).toBe(false)
-    })
-  })
-
-  describe('loadTranslationsCore() method', () => {
-    test('should load translations when merge is false', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { greeting: 'Hello' }
-
-      i18n['loadTranslationsCore']('en', translations, false)
-      // Wait for async operation to complete
-      await new Promise((resolve) => setTimeout(resolve, 0))
-
-      expect(i18n.has('greeting')).toBe(true)
-    })
-
-    test('should merge translations when merge is true', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const initial: Translations = { greeting: 'Hello' }
-      const additional: Translations = { farewell: 'Goodbye' }
-
-      await i18n['helper'].loadTranslations('en', initial)
-      i18n['loadTranslationsCore']('en', additional, true)
-      // Wait for async operation to complete
-      await new Promise((resolve) => setTimeout(resolve, 0))
-
-      expect(i18n.has('greeting')).toBe(true)
-      expect(i18n.has('farewell')).toBe(true)
-    })
-  })
-
-  describe('loadRouteTranslationsCore() method', () => {
-    test('should load route translations when merge is false', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = { title: 'Page Title' }
-
-      i18n['loadRouteTranslationsCore']('en', 'about', translations, false)
-      // Wait for async operation to complete
-      await new Promise((resolve) => setTimeout(resolve, 0))
-
-      expect(i18n.has('title', 'about')).toBe(true)
-    })
-
-    test('should merge route translations when merge is true', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const initial: Translations = { title: 'Page Title' }
-      const additional: Translations = { description: 'Page Description' }
-
-      await i18n['helper'].loadPageTranslations('en', 'about', initial)
-      i18n['loadRouteTranslationsCore']('en', 'about', additional, true)
-      // Wait for async operation to complete
-      await new Promise((resolve) => setTimeout(resolve, 0))
-
-      expect(i18n.has('title', 'about')).toBe(true)
-      expect(i18n.has('description', 'about')).toBe(true)
-    })
-  })
-
-  describe('Edge cases', () => {
-    test('should handle nested translation keys', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = {
-        nested: {
-          deep: {
-            key: 'Nested value',
-          },
-        },
-      }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.t('nested.deep.key')).toBe('Nested value')
-    })
-
-    test('should handle multiple params in interpolation', async () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      const translations: Translations = {
-        message: 'Hello, {name}! You are {age} years old.',
-      }
-      i18n['helper'].loadTranslations('en', translations)
-
-      expect(i18n.t('message', { name: 'John', age: 30 })).toBe('Hello, John! You are 30 years old.')
-    })
-
-    test('should handle null defaultValue', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      expect(i18n.t('missing.key', undefined, null)).toBe('missing.key')
-    })
-
-    test('should handle empty string defaultValue', () => {
-      const i18n = new TestI18n('en', 'en', 'index')
-      // Empty string is falsy, so it will fall back to key (as per defaultValue || key logic)
-      expect(i18n.t('missing.key', undefined, '')).toBe('missing.key')
-    })
-
-    test('should handle route change', async () => {
-      const storage = { translations: new Map<string, Translations>() }
-      const i18n = new TestI18n('en', 'en', 'index', { storage })
-      const rootTranslations: Translations = { greeting: 'Hello' }
-      // Packages (vue, node, etc.) merge root into pages automatically.
-      // Core does not — so we simulate pre-merged data here.
-      const routeTranslations: Translations = { greeting: 'Hello', title: 'About Page' }
-
-      await i18n['helper'].loadTranslations('en', rootTranslations)
-      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
-
-      // Verify translations are loaded
-      expect(i18n.has('greeting')).toBe(true)
-      expect(i18n.has('title', 'about')).toBe(true)
-
-      // Check route-specific translation with explicit routeName
-      const titleValue = i18n.t('title', undefined, undefined, 'about')
-      expect(titleValue).toBe('About Page')
-
-      // Change route and check
-      i18n.setRoute('about')
-      expect(i18n.t('title')).toBe('About Page')
-      expect(i18n.t('greeting')).toBe('Hello')
-    })
-  })
-})

package/tests/core.test.ts

@@ -1,81 +0,0 @@
-import { interpolate, useTranslationHelper } from '../src'
-
-describe('Translation Helper', () => {
-  const translations = {
-    en: {
-      greeting: 'Hello, {name}!',
-      nested: {
-        message: 'This is a nested message.',
-      },
-    },
-    fr: {
-      greeting: 'Bonjour, {name}!',
-    },
-  }
-
-  test('interpolate function replaces placeholders correctly', () => {
-    const result = interpolate('Hello, {name}!', { name: 'John' })
-    expect(result).toBe('Hello, John!')
-  })
-
-  test('interpolate function handles missing placeholders gracefully', () => {
-    const result = interpolate('Hello, {name}!', { age: 30 })
-    expect(result).toBe('Hello, {name}!')
-  })
-
-  test('getTranslation fetches correct translation', () => {
-    const helper = useTranslationHelper()
-    helper.loadTranslations('en', translations.en)
-
-    const translation = helper.getTranslation('en', 'index', 'greeting')
-    expect(translation).toBe('Hello, {name}!')
-  })
-
-  test('getTranslation supports nested keys', () => {
-    const helper = useTranslationHelper()
-    helper.loadTranslations('en', translations.en)
-
-    const translation = helper.getTranslation('en', 'index', 'nested.message')
-    expect(translation).toBe('This is a nested message.')
-  })
-
-  test('getTranslation falls back when translation is missing', () => {
-    const helper = useTranslationHelper()
-    helper.loadTranslations('en', translations.en)
-
-    const translation = helper.getTranslation('en', 'index', 'nonexistent.key')
-    expect(translation).toBeNull()
-  })
-
-  test('loadPageTranslations correctly caches translations', async () => {
-    const helper = useTranslationHelper()
-    await helper.loadPageTranslations('fr', 'home', translations.fr)
-
-    expect(helper.hasPageTranslation('fr', 'home')).toBe(true)
-    expect(helper.getTranslation('fr', 'home', 'greeting')).toBe('Bonjour, {name}!')
-  })
-
-  test('mergeTranslation updates route translations', () => {
-    const helper = useTranslationHelper()
-    helper.loadPageTranslations('en', 'home', translations.en)
-
-    helper.mergeTranslation('en', 'home', { newKey: 'New value' })
-    expect(helper.getTranslation('en', 'home', 'newKey')).toBe('New value')
-  })
-
-  test('mergeTranslation with index routeName updates index translations', () => {
-    const helper = useTranslationHelper()
-    helper.loadTranslations('en', translations.en)
-
-    helper.mergeTranslation('en', 'index', { newKey: 'New value' })
-    expect(helper.getTranslation('en', 'index', 'newKey')).toBe('New value')
-  })
-
-  test('deepClone creates a deep copy of objects', () => {
-    const original = { nested: { key: 'value' } }
-    const cloned = JSON.parse(JSON.stringify(original))
-
-    expect(cloned).toEqual(original)
-    expect(cloned).not.toBe(original)
-  })
-})

package/tests/format-service.test.ts

@@ -1,101 +0,0 @@
-import { FormatService } from '../src'
-
-describe('FormatService', () => {
-  let formatService: FormatService
-
-  beforeEach(() => {
-    formatService = new FormatService()
-  })
-
-  describe('formatNumber', () => {
-    test('should format number with default options', () => {
-      const result = formatService.formatNumber(123456.789, 'en-US')
-      expect(result).toBe('123,456.789')
-    })
-
-    test('should format number with custom options', () => {
-      const result = formatService.formatNumber(123456.789, 'de-DE', {
-        style: 'currency',
-        currency: 'EUR',
-      })
-      expect(result).toBe('123.456,79 €')
-    })
-
-    test('should handle invalid locale by falling back to default formatting', () => {
-      const result = formatService.formatNumber(123456.789, 'invalid-locale')
-      expect(result).toBe('123,456.789') // Fallback to default formatting
-    })
-  })
-
-  describe('formatDate', () => {
-    test('should format date with default options', () => {
-      const date = new Date('2023-10-05T12:34:56Z')
-      const result = formatService.formatDate(date, 'en-US')
-      expect(result).toBe('10/5/2023')
-    })
-
-    test('should format date with custom options', () => {
-      const date = new Date('2023-10-05T12:34:56Z')
-      const result = formatService.formatDate(date, 'de-DE', {
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-      })
-      expect(result).toBe('5. Oktober 2023')
-    })
-
-    test('should handle invalid date by returning "Invalid Date"', () => {
-      const result = formatService.formatDate('invalid-date', 'en-US')
-      expect(result).toBe('Invalid Date')
-    })
-  })
-
-  describe('formatRelativeTime', () => {
-    test('should format relative time for seconds', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 30 * 1000) // 30 seconds ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('30 seconds ago')
-    })
-
-    test('should format relative time for minutes', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 5 * 60 * 1000) // 5 minutes ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('5 minutes ago')
-    })
-
-    test('should format relative time for hours', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 2 * 60 * 60 * 1000) // 2 hours ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('2 hours ago')
-    })
-
-    test('should format relative time for days', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000) // 3 days ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('3 days ago')
-    })
-
-    test('should format relative time for months', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 60 * 24 * 60 * 60 * 1000) // ~2 months ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('2 months ago')
-    })
-
-    test('should format relative time for years', () => {
-      const now = new Date()
-      const past = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000) // 1 year ago
-      const result = formatService.formatRelativeTime(past, 'en-US')
-      expect(result).toBe('1 year ago')
-    })
-
-    test('should handle invalid date by returning "0 seconds ago"', () => {
-      const result = formatService.formatRelativeTime('invalid-date', 'en-US')
-      expect(result).toBe('in 0 seconds')
-    })
-  })
-})