@i18n-micro/core 1.0.28 → 1.1.1

package/dist/translation.d.ts

@@ -1,24 +1,23 @@
 import { Translations } from '@i18n-micro/types';
-export interface RefLike<T> {
-    value: T;
+/**
+ * Bare Metal: Простое хранилище переводов без Ref, useState, devalue.
+ * Ключ Map: locale (general) или locale:routeName (page-specific).
+ */
+export interface TranslationStorage {
+    translations: Map<string, Translations>;
 }
-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>>;
-}
-export declare function useTranslationHelper(caches?: TranslationCache): {
+export declare function useTranslationHelper(storage?: TranslationStorage): {
     hasCache(locale: string, page: string): boolean;
-    getCache(locale: string, routeName: string): Map<string, unknown> | undefined;
-    setCache(locale: string, routeName: string, cache: Map<string, Translations | unknown>): void;
-    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, force?: boolean): void;
-    mergeGlobalTranslation(locale: string, newTranslations: Translations, force?: boolean): void;
+    getCache(locale: string, routeName: string): Translations | undefined;
+    setCache(_locale: string, _routeName: string, _cache: Map<string, unknown>): void;
+    hasTranslation(locale: string, key: string): boolean;
     hasGeneralTranslation(locale: string): boolean;
     hasPageTranslation(locale: string, routeName: string): boolean;
-    hasTranslation: (locale: string, key: import('@i18n-micro/types').TranslationKey) => boolean;
-    getTranslation: <T = unknown>(locale: string, routeName: string, key: import('@i18n-micro/types').TranslationKey) => T | null;
-    loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void>;
-    loadTranslations(locale: string, translations: Translations): Promise<void>;
+    getTranslation<T = unknown>(locale: string, routeName: string, key: string): T | null;
+    loadTranslations(locale: string, data: Translations): void;
+    setTranslations(locale: string, data: Translations): void;
+    loadPageTranslations(locale: string, routeName: string, data: Translations): void;
+    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): void;
+    mergeGlobalTranslation(locale: string, newTranslations: Translations, _force?: boolean): void;
     clearCache(): void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@i18n-micro/core",
-  "version": "1.0.28",
+  "version": "1.1.1",
   "description": "",
   "repository": "s00d/nuxt-i18n-micro",
   "license": "MIT",
@@ -22,10 +22,10 @@
   },
   "keywords": [],
   "dependencies": {
-    "@i18n-micro/types": "1.0.16"
+    "@i18n-micro/types": "1.1.0"
   },
   "devDependencies": {
-    "vite": "^7.2.7",
+    "vite": "^7.3.1",
     "vite-plugin-dts": "^4.5.4"
   },
   "scripts": {

package/src/base.ts

@@ -1,4 +1,4 @@
-import { useTranslationHelper, type TranslationCache } from './translation'
+import { useTranslationHelper, type TranslationStorage } from './translation'
 import { FormatService } from './format-service'
 import { interpolate, defaultPlural } from './helpers'
 import type {
@@ -12,7 +12,7 @@ import type {
 } from '@i18n-micro/types'
 
 export interface BaseI18nOptions {
-  cache?: TranslationCache
+  storage?: TranslationStorage
   plural?: PluralFunc
   missingWarn?: boolean
   missingHandler?: (locale: string, key: string, routeName: string) => void
@@ -41,7 +41,7 @@ export abstract class BaseI18n {
   public enablePreviousPageFallback: boolean
 
   constructor(options: BaseI18nOptions = {}) {
-    this.helper = useTranslationHelper(options.cache)
+    this.helper = useTranslationHelper(options.storage)
     this.formatter = new FormatService()
     this.pluralFunc = options.plural || defaultPlural
     this.missingWarn = options.missingWarn ?? true
@@ -226,7 +226,7 @@ export abstract class BaseI18n {
       this.helper.mergeGlobalTranslation(locale, translations, true)
     }
     else {
-      this.helper.loadTranslations(locale, translations)
+      this.helper.setTranslations(locale, translations)
     }
   }
 

package/src/helpers.ts

@@ -1,13 +1,14 @@
 import type { Params, Strategies, PluralFunc, Getter, TranslationKey } from '@i18n-micro/types'
 
-export function interpolate(template: string, params: Params): string {
-  let result = template
+const RE_TOKEN = /\{(\w+)\}/g
 
-  for (const key in params) {
-    result = result.split(`{${key}}`).join(String(params[key]))
-  }
+export function interpolate(template: string, params: Params): string {
+  if (!params) return template
 
-  return result
+  return template.replace(RE_TOKEN, (_, key) => {
+    const value = params[key]
+    return value !== undefined ? String(value) : `{${key}}`
+  })
 }
 
 export function withPrefixStrategy(strategy: Strategies) {

package/src/index.ts

@@ -1,5 +1,4 @@
-import { useTranslationHelper, type TranslationCache } from './translation'
-import { RouteService } from './route-service'
+import { useTranslationHelper, type TranslationStorage } from './translation'
 import { FormatService } from './format-service'
 import { interpolate, withPrefixStrategy, isNoPrefixStrategy, isPrefixStrategy, isPrefixExceptDefaultStrategy, isPrefixAndDefaultStrategy, defaultPlural } from './helpers'
 import { BaseI18n, type BaseI18nOptions } from './base'
@@ -13,9 +12,8 @@ export {
   isPrefixExceptDefaultStrategy,
   isPrefixAndDefaultStrategy,
   defaultPlural,
-  RouteService,
   FormatService,
   BaseI18n,
-  type TranslationCache,
+  type TranslationStorage,
   type BaseI18nOptions,
 }

package/src/translation.ts

@@ -1,216 +1,106 @@
 import type { Translations } from '@i18n-micro/types'
 
-// Duck-typing для Ref, чтобы не тащить Vue зависимость
-export interface RefLike<T> {
-  value: T
+/**
+ * Bare Metal: Простое хранилище переводов без Ref, useState, devalue.
+ * Ключ Map: locale (general) или locale:routeName (page-specific).
+ */
+export interface TranslationStorage {
+  translations: Map<string, Translations>
 }
 
-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
+function findValue<T = unknown>(data: Translations | null | undefined, key: string): T | null {
+  if (!data || typeof key !== 'string') return null
 
-  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 (key in data) {
+    const value = data[key]
+    if (typeof value === 'object' && value !== null) {
+      return value as T
     }
+    return value as T
   }
 
-  if (typeof value === 'object' && value !== null) {
-    return deepClone(value) as T
+  const parts = key.split('.')
+  let value: unknown = data
+  for (const part of parts) {
+    if (value && typeof value === 'object' && part in (value as object)) {
+      value = (value as Translations)[part]
+    }
+    else {
+      return null
+    }
   }
-
   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
+export function useTranslationHelper(storage?: TranslationStorage) {
+  const translations = storage?.translations ?? new Map<string, Translations>()
 
   return {
     hasCache(locale: string, page: string) {
       const cacheKey = `${locale}:${page}`
-      const cache = getValueByKey(serverTranslationCache, cacheKey)
-      return (cache ?? new Map<string, Translations | unknown>()).size > 0
+      return translations.has(cacheKey) || translations.has(locale)
     },
     getCache(locale: string, routeName: string) {
       const cacheKey = `${locale}:${routeName}`
-      return getValueByKey(serverTranslationCache, cacheKey)
+      return translations.get(cacheKey)
     },
-    setCache(locale: string, routeName: string, cache: Map<string, Translations | unknown>) {
-      const cacheKey = `${locale}:${routeName}`
-      setValue(serverTranslationCache, cacheKey, cache)
+    setCache(_locale: string, _routeName: string, _cache: Map<string, unknown>) {
+      // No-op for bare metal
     },
-    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.`)
+    hasTranslation(locale: string, key: string): boolean {
+      for (const [k, v] of translations) {
+        if ((k === locale || k.startsWith(`${locale}:`)) && findValue(v, key) !== null) {
+          return true
+        }
       }
+      return false
     },
-    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): boolean {
+      return translations.has(locale)
     },
-    hasGeneralTranslation(locale: string) {
-      return !!getValueByKey(generalLocaleCache, locale)
+    hasPageTranslation(locale: string, routeName: string): boolean {
+      return translations.has(`${locale}:${routeName}`)
     },
-    hasPageTranslation(locale: string, routeName: string) {
-      const cacheKey = `${locale}:${routeName}`
-
-      return !!getValueByKey(routeLocaleCache, cacheKey)
+    getTranslation<T = unknown>(locale: string, routeName: string, key: string): T | null {
+      const routeKey = `${locale}:${routeName}`
+      const routeData = translations.get(routeKey)
+      const val = findValue<T>(routeData, key)
+      if (val !== null) return val
+
+      const generalData = translations.get(locale)
+      return findValue<T>(generalData, key)
     },
-    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
+    loadTranslations(locale: string, data: Translations): void {
+      // Merge with existing, replacing duplicate keys
+      const existing = translations.get(locale) ?? {}
+      translations.set(locale, { ...existing, ...data })
     },
-    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)
+    setTranslations(locale: string, data: Translations): void {
+      // Replace all translations for locale (no merge)
+      translations.set(locale, data)
+    },
+    loadPageTranslations(locale: string, routeName: string, data: Translations): void {
+      const key = `${locale}:${routeName}`
+      const existing = translations.get(key)
+      // Perf: при пустом existing — сохраняем ссылку, избегаем O(n) копирования больших объектов
+      if (!existing || Object.keys(existing).length === 0) {
+        translations.set(key, data)
       }
-
-      if (result) {
-        const currentServerCache = serverCache ?? new Map<string, Translations | unknown>()
-        currentServerCache.set(key, result)
-        setValue(serverTranslationCache, cacheKey, currentServerCache)
+      else {
+        translations.set(key, { ...existing, ...data })
       }
-
-      return result
     },
-    async loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void> {
-      const cacheKey = `${locale}:${routeName}`
-      setValue(routeLocaleCache, cacheKey, { ...translations })
+    mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force = false): void {
+      const key = `${locale}:${routeName}`
+      const existing = translations.get(key) ?? {}
+      translations.set(key, { ...existing, ...newTranslations })
     },
-    async loadTranslations(locale: string, translations: Translations): Promise<void> {
-      setValue(generalLocaleCache, locale, { ...translations })
+    mergeGlobalTranslation(locale: string, newTranslations: Translations, _force = false): void {
+      const existing = translations.get(locale) ?? {}
+      translations.set(locale, { ...existing, ...newTranslations })
     },
-    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()
-      })
+    clearCache(): void {
+      translations.clear()
     },
   }
 }

package/tests/base.test.ts

@@ -49,14 +49,9 @@ describe('BaseI18n', () => {
       expect(i18n.getRoute()).toBe('general')
     })
 
-    test('should initialize with custom cache', () => {
-      const cache = {
-        generalLocaleCache: {},
-        routeLocaleCache: {},
-        dynamicTranslationsCaches: [],
-        serverTranslationCache: {},
-      }
-      const i18n = new TestI18n('en', 'en', 'general', { cache })
+    test('should initialize with custom storage', () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
       expect(i18n).toBeDefined()
     })
 
@@ -93,13 +88,8 @@ describe('BaseI18n', () => {
     })
 
     test('should interpolate params in translation', async () => {
-      const cache = {
-        generalLocaleCache: {},
-        routeLocaleCache: {},
-        dynamicTranslationsCaches: [],
-        serverTranslationCache: {},
-      }
-      const i18n = new TestI18n('en', 'en', 'general', { cache })
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
       const translations: Translations = { greeting: 'Hello, {name}!' }
       await i18n['helper'].loadTranslations('en', translations)
 
@@ -117,13 +107,8 @@ describe('BaseI18n', () => {
     })
 
     test('should fallback to fallbackLocale when translation is missing', async () => {
-      const cache = {
-        generalLocaleCache: {},
-        routeLocaleCache: {},
-        dynamicTranslationsCaches: [],
-        serverTranslationCache: {},
-      }
-      const i18n = new TestI18n('en', 'fr', 'general', { cache })
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'fr', 'general', { storage })
       const translations: Translations = { greeting: 'Bonjour' }
       await i18n['helper'].loadTranslations('fr', translations)
 
@@ -139,15 +124,10 @@ describe('BaseI18n', () => {
     })
 
     test('should use previousPageInfo fallback when enabled', async () => {
-      const cache = {
-        generalLocaleCache: {},
-        routeLocaleCache: {},
-        dynamicTranslationsCaches: [],
-        serverTranslationCache: {},
-      }
+      const storage = { translations: new Map<string, Translations>() }
       const prevInfo = { locale: 'fr', routeName: 'previous' }
       const i18n = new TestI18n('en', 'en', 'general', {
-        cache,
+        storage,
         getPreviousPageInfo: () => prevInfo,
         enablePreviousPageFallback: true,
       })
@@ -479,13 +459,8 @@ describe('BaseI18n', () => {
     })
 
     test('should handle route change', async () => {
-      const cache = {
-        generalLocaleCache: {},
-        routeLocaleCache: {},
-        dynamicTranslationsCaches: [],
-        serverTranslationCache: {},
-      }
-      const i18n = new TestI18n('en', 'en', 'general', { cache })
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
       const generalTranslations: Translations = { greeting: 'Hello' }
       const routeTranslations: Translations = { title: 'About Page' }
 

package/dist/route-service.d.ts

@@ -1,40 +0,0 @@
-import { NavigationFailure, RouteLocationAsPathGeneric, RouteLocationNamedRaw, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteLocationResolved, RouteLocationResolvedGeneric, Router } from 'vue-router';
-import { I18nRouteParams, Locale, ModuleOptionsExtend } from '@i18n-micro/types';
-interface NavigateToInterface {
-    replace?: boolean;
-    redirectCode?: number;
-    external?: boolean;
-}
-export declare class RouteService {
-    private i18nConfig;
-    private router;
-    private hashLocaleDefault;
-    private noPrefixDefault;
-    private navigateTo;
-    private setCookie;
-    private cookieLocaleDefault;
-    private cookieLocaleName;
-    constructor(i18nConfig: ModuleOptionsExtend, router: Router, hashLocaleDefault: string | null | undefined, noPrefixDefault: string | null | undefined, navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToInterface) => Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw, setCookie: (name: string, value: string) => void, cookieLocaleDefault?: string | null | undefined, cookieLocaleName?: string | null | undefined);
-    /**
-     * Extracts locale from URL path by checking the first path segment
-     * @param path - URL path (e.g., '/ru/sdfsdf' or '/en/about')
-     * @returns Locale code or null if not found
-     */
-    private extractLocaleFromPath;
-    getCurrentLocale(route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string;
-    getCurrentName(route: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string | null;
-    getRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string;
-    getPluginRouteName(route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, locale: string): string;
-    getFullPathWithBaseUrl(currentLocale: Locale, route: RouteLocationRaw): string;
-    switchLocaleRoute(fromLocale: string, toLocale: string, route: RouteLocationResolvedGeneric | RouteLocationNamedRaw, i18nRouteParams: I18nRouteParams): RouteLocationRaw;
-    private resolveParams;
-    private handlePrefixStrategy;
-    private createLocalizedRoute;
-    getLocalizedRoute(to: RouteLocationResolvedGeneric | RouteLocationAsPathGeneric | RouteLocationNamedRaw | string, route: RouteLocationNormalizedLoaded, locale?: string): RouteLocationResolved;
-    updateCookies(toLocale: string): void;
-    getCurrentRoute(): RouteLocationNormalizedLoaded;
-    private resolveRouteWithStrategy;
-    switchLocaleLogic(toLocale: string, i18nRouteParams: I18nRouteParams, to?: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string): string | false | void | import('vue-router').RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric | Promise<false | void | NavigationFailure>;
-    resolveLocalizedRoute(to: RouteLocationNamedRaw | RouteLocationAsPathGeneric | string, locale?: string): RouteLocationResolved;
-}
-export {};