@i18n-micro/core 1.0.27

package/src/translation.ts

@@ -0,0 +1,216 @@
+import type { Translations } from '@i18n-micro/types'
+
+// Duck-typing для Ref, чтобы не тащить Vue зависимость
+export interface RefLike<T> {
+  value: T
+}
+
+export interface TranslationCache {
+  generalLocaleCache: RefLike<Record<string, Translations>> | Record<string, Translations>
+  routeLocaleCache: RefLike<Record<string, Translations>> | Record<string, Translations>
+  dynamicTranslationsCaches: RefLike<Record<string, Translations>[]> | Record<string, Translations>[]
+  serverTranslationCache: RefLike<Record<string, Map<string, Translations | unknown>>> | Record<string, Map<string, Translations | unknown>>
+}
+
+// Глобальные кэши для fallback (только для unit-тестов и обратной совместимости)
+// НЕ используются в SSR продакшене
+const globalGeneralLocaleCache: Record<string, Translations> = {}
+const globalRouteLocaleCache: Record<string, Translations> = {}
+const globalDynamicTranslationsCaches: Record<string, Translations>[] = []
+const globalServerTranslationCache: Record<string, Map<string, Translations | unknown>> = {}
+
+function deepClone<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+  else if (typeof value === 'object' && value !== null) {
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+  return value
+}
+
+function findTranslation<T = unknown>(translations: Translations | null, key: string): T | null {
+  let value: string | number | boolean | Translations | unknown | null = translations
+
+  if (translations === null || typeof key !== 'string') {
+    return null
+  }
+
+  if (translations[key]) {
+    value = translations[key]
+  }
+  else {
+    const parts = key.toString().split('.')
+    for (const part of parts) {
+      if (value && typeof value === 'object' && part in value) {
+        value = (value as Translations)[part]
+      }
+      else {
+        return null
+      }
+    }
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    return deepClone(value) as T
+  }
+
+  return (value as T) ?? null
+}
+
+// Вспомогательная функция для получения значения из Ref или обычного объекта
+function getValue<T>(refOrValue: RefLike<T> | T): T {
+  return typeof refOrValue === 'object' && refOrValue !== null && 'value' in refOrValue
+    ? (refOrValue as RefLike<T>).value
+    : refOrValue as T
+}
+
+// Вспомогательная функция для установки значения в Ref или обычный объект
+function setValue<T extends Record<string, unknown>>(
+  refOrValue: RefLike<T> | T,
+  key: string,
+  value: T[keyof T],
+): void {
+  const target = getValue(refOrValue)
+  ;(target as Record<string, unknown>)[key] = value
+}
+
+// Вспомогательная функция для получения значения из Ref или обычного объекта по ключу
+function getValueByKey<T extends Record<string, unknown>>(refOrValue: RefLike<T> | T, key: string): T[keyof T] | undefined {
+  const target = getValue(refOrValue)
+  return (target as Record<string, unknown>)[key] as T[keyof T] | undefined
+}
+
+export function useTranslationHelper(caches?: TranslationCache) {
+  // Используем переданные кэши или глобальные (fallback для тестов)
+  const generalLocaleCache = caches?.generalLocaleCache ?? globalGeneralLocaleCache
+  const routeLocaleCache = caches?.routeLocaleCache ?? globalRouteLocaleCache
+  const dynamicTranslationsCaches = caches?.dynamicTranslationsCaches ?? globalDynamicTranslationsCaches
+  const serverTranslationCache = caches?.serverTranslationCache ?? globalServerTranslationCache
+
+  return {
+    hasCache(locale: string, page: string) {
+      const cacheKey = `${locale}:${page}`
+      const cache = getValueByKey(serverTranslationCache, cacheKey)
+      return (cache ?? new Map<string, Translations | unknown>()).size > 0
+    },
+    getCache(locale: string, routeName: string) {
+      const cacheKey = `${locale}:${routeName}`
+      return getValueByKey(serverTranslationCache, cacheKey)
+    },
+    setCache(locale: string, routeName: string, cache: Map<string, Translations | unknown>) {
+      const cacheKey = `${locale}:${routeName}`
+      setValue(serverTranslationCache, cacheKey, cache)
+    },
+    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, force = false) {
+      const cacheKey = `${locale}:${routeName}`
+      const currentCache = getValueByKey(routeLocaleCache, cacheKey)
+
+      if (currentCache || force) {
+        const existing = currentCache ?? {}
+        setValue(routeLocaleCache, cacheKey, {
+          ...existing,
+          ...newTranslations,
+        })
+      }
+
+      const isDev = process.env.NODE_ENV !== 'production'
+      if (!currentCache && isDev) {
+        // Если кэша нет, выводим предупреждение в dev-режиме и ничего не делаем.
+        console.warn(`[i18n] mergeTranslation called for '${cacheKey}' which was not pre-loaded. Skipping merge. Use force: true if this is intentional.`)
+      }
+    },
+    mergeGlobalTranslation(locale: string, newTranslations: Translations, force = false) {
+      const currentCache = getValueByKey(generalLocaleCache, locale)
+      if (!force && !currentCache) {
+        console.error(`marge: route ${locale} not loaded`)
+      }
+      const existing = currentCache ?? {}
+      setValue(generalLocaleCache, locale, {
+        ...existing,
+        ...newTranslations,
+      })
+    },
+    hasGeneralTranslation(locale: string) {
+      return !!getValueByKey(generalLocaleCache, locale)
+    },
+    hasPageTranslation(locale: string, routeName: string) {
+      const cacheKey = `${locale}:${routeName}`
+
+      return !!getValueByKey(routeLocaleCache, cacheKey)
+    },
+    hasTranslation: (locale: string, key: import('@i18n-micro/types').TranslationKey): boolean => {
+      const dynamicCaches = getValue(dynamicTranslationsCaches)
+      for (const dynamicCache of dynamicCaches) {
+        if (findTranslation(dynamicCache[locale] || null, key) !== null) {
+          return true
+        }
+      }
+
+      const generalCache = getValueByKey(generalLocaleCache, locale)
+      return findTranslation(generalCache || null, key) !== null
+    },
+    getTranslation: <T = unknown>(locale: string, routeName: string, key: import('@i18n-micro/types').TranslationKey): T | null => {
+      const cacheKey = `${locale}:${routeName}`
+      const serverCache = getValueByKey(serverTranslationCache, cacheKey)
+      const cached = serverCache?.get(key)
+      if (cached) {
+        return cached as T
+      }
+
+      let result: T | null = null
+
+      const dynamicCaches = getValue(dynamicTranslationsCaches)
+      for (const dynamicCache of dynamicCaches) {
+        result = findTranslation<T>(dynamicCache[locale] || null, key)
+        if (result !== null) break
+      }
+
+      if (!result) {
+        const routeCache = getValueByKey(routeLocaleCache, cacheKey)
+        const generalCache = getValueByKey(generalLocaleCache, locale)
+        result = findTranslation<T>(routeCache || null, key)
+          ?? findTranslation<T>(generalCache || null, key)
+      }
+
+      if (result) {
+        const currentServerCache = serverCache ?? new Map<string, Translations | unknown>()
+        currentServerCache.set(key, result)
+        setValue(serverTranslationCache, cacheKey, currentServerCache)
+      }
+
+      return result
+    },
+    async loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void> {
+      const cacheKey = `${locale}:${routeName}`
+      setValue(routeLocaleCache, cacheKey, { ...translations })
+    },
+    async loadTranslations(locale: string, translations: Translations): Promise<void> {
+      setValue(generalLocaleCache, locale, { ...translations })
+    },
+    clearCache() {
+      // Clear general cache
+      const generalCache = getValue(generalLocaleCache)
+      Object.keys(generalCache).forEach((key) => {
+        setValue(generalLocaleCache, key, {})
+      })
+
+      // Clear route-specific cache
+      const routeCache = getValue(routeLocaleCache)
+      Object.keys(routeCache).forEach((key) => {
+        setValue(routeLocaleCache, key, {})
+      })
+
+      // Clear dynamic caches
+      const dynamicCaches = getValue(dynamicTranslationsCaches)
+      dynamicCaches.length = 0
+
+      // Clear server translation cache
+      const serverCache = getValue(serverTranslationCache)
+      Object.keys(serverCache).forEach((key) => {
+        const cacheMap = getValueByKey(serverTranslationCache, key)
+        cacheMap?.clear()
+      })
+    },
+  }
+}

package/tests/core.test.ts

@@ -0,0 +1,81 @@
+import { useTranslationHelper, interpolate } 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('mergeGlobalTranslation updates general translations', () => {
+    const helper = useTranslationHelper()
+    helper.loadTranslations('en', translations.en)
+
+    helper.mergeGlobalTranslation('en', { newGlobalKey: 'Global value' })
+    expect(helper.getTranslation('en', 'index', 'newGlobalKey')).toBe('Global 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

@@ -0,0 +1,101 @@
+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')
+    })
+  })
+})

package/tests/helpers.test.ts

@@ -0,0 +1,103 @@
+import {
+  interpolate,
+  withPrefixStrategy,
+  isNoPrefixStrategy,
+  isPrefixStrategy,
+  isPrefixExceptDefaultStrategy,
+  isPrefixAndDefaultStrategy,
+} from '../src/helpers'
+
+describe('Helpers', () => {
+  describe('interpolate', () => {
+    test('should replace placeholders with params', () => {
+      const template = 'Hello, {name}! Your age is {age}.'
+      const params = { name: 'John', age: 30 }
+      const result = interpolate(template, params)
+      expect(result).toBe('Hello, John! Your age is 30.')
+    })
+
+    test('should handle missing params by leaving placeholders', () => {
+      const template = 'Hello, {name}! Your age is {age}.'
+      const params = { name: 'John' } // age is missing
+      const result = interpolate(template, params)
+      expect(result).toBe('Hello, John! Your age is {age}.')
+    })
+
+    test('should handle empty params', () => {
+      const template = 'Hello, {name}!'
+      const params = {}
+      const result = interpolate(template, params)
+      expect(result).toBe('Hello, {name}!')
+    })
+
+    test('should handle empty template', () => {
+      const template = ''
+      const params = { name: 'John' }
+      const result = interpolate(template, params)
+      expect(result).toBe('')
+    })
+  })
+
+  describe('withPrefixStrategy', () => {
+    test('should return true for "prefix" strategy', () => {
+      expect(withPrefixStrategy('prefix')).toBe(true)
+    })
+
+    test('should return true for "prefix_and_default" strategy', () => {
+      expect(withPrefixStrategy('prefix_and_default')).toBe(true)
+    })
+
+    test('should return false for other strategies', () => {
+      expect(withPrefixStrategy('no_prefix')).toBe(false)
+      expect(withPrefixStrategy('prefix_except_default')).toBe(false)
+    })
+  })
+
+  describe('isNoPrefixStrategy', () => {
+    test('should return true for "no_prefix" strategy', () => {
+      expect(isNoPrefixStrategy('no_prefix')).toBe(true)
+    })
+
+    test('should return false for other strategies', () => {
+      expect(isNoPrefixStrategy('prefix')).toBe(false)
+      expect(isNoPrefixStrategy('prefix_and_default')).toBe(false)
+      expect(isNoPrefixStrategy('prefix_except_default')).toBe(false)
+    })
+  })
+
+  describe('isPrefixStrategy', () => {
+    test('should return true for "prefix" strategy', () => {
+      expect(isPrefixStrategy('prefix')).toBe(true)
+    })
+
+    test('should return false for other strategies', () => {
+      expect(isPrefixStrategy('no_prefix')).toBe(false)
+      expect(isPrefixStrategy('prefix_and_default')).toBe(false)
+      expect(isPrefixStrategy('prefix_except_default')).toBe(false)
+    })
+  })
+
+  describe('isPrefixExceptDefaultStrategy', () => {
+    test('should return true for "prefix_except_default" strategy', () => {
+      expect(isPrefixExceptDefaultStrategy('prefix_except_default')).toBe(true)
+    })
+
+    test('should return false for other strategies', () => {
+      expect(isPrefixExceptDefaultStrategy('no_prefix')).toBe(false)
+      expect(isPrefixExceptDefaultStrategy('prefix')).toBe(false)
+      expect(isPrefixExceptDefaultStrategy('prefix_and_default')).toBe(false)
+    })
+  })
+
+  describe('isPrefixAndDefaultStrategy', () => {
+    test('should return true for "prefix_and_default" strategy', () => {
+      expect(isPrefixAndDefaultStrategy('prefix_and_default')).toBe(true)
+    })
+
+    test('should return false for other strategies', () => {
+      expect(isPrefixAndDefaultStrategy('no_prefix')).toBe(false)
+      expect(isPrefixAndDefaultStrategy('prefix')).toBe(false)
+      expect(isPrefixAndDefaultStrategy('prefix_except_default')).toBe(false)
+    })
+  })
+})