@i18n-micro/core 1.0.27 → 1.1.0

package/dist/route-service.d.ts

@@ -5,16 +5,18 @@ interface NavigateToInterface {
     redirectCode?: number;
     external?: boolean;
 }
+export type GetDefaultLocale = () => string | null | undefined;
 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);
+    /** Optional getter for current locale (used by hash/noPrefix when state changes). Plugin provides () => localeState.value */
+    private getDefaultLocale?;
+    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, 
+    /** Optional getter for current locale (used by hash/noPrefix when state changes). Plugin provides () => localeState.value */
+    getDefaultLocale?: GetDefaultLocale | undefined);
     /**
      * Extracts locale from URL path by checking the first path segment
      * @param path - URL path (e.g., '/ru/sdfsdf' or '/en/about')
@@ -31,7 +33,6 @@ export declare class RouteService {
     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>;

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.27",
+  "version": "1.1.0",
   "description": "",
   "repository": "s00d/nuxt-i18n-micro",
   "license": "MIT",
@@ -22,11 +22,11 @@
   },
   "keywords": [],
   "dependencies": {
-    "@i18n-micro/types": "1.0.15"
+    "@i18n-micro/types": "1.1.0"
   },
   "devDependencies": {
-    "vite": "^5.0.0",
-    "vite-plugin-dts": "^4.3.0"
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
   },
   "scripts": {
     "build": "vite build",

package/src/base.ts

@@ -0,0 +1,250 @@
+import { useTranslationHelper, type TranslationStorage } from './translation'
+import { FormatService } from './format-service'
+import { interpolate, defaultPlural } from './helpers'
+import type {
+  Translations,
+  Params,
+  PluralFunc,
+  Getter,
+  CleanTranslation,
+  TranslationKey,
+  MissingHandler,
+} from '@i18n-micro/types'
+
+export interface BaseI18nOptions {
+  storage?: TranslationStorage
+  plural?: PluralFunc
+  missingWarn?: boolean
+  missingHandler?: (locale: string, key: string, routeName: string) => void
+  // Optional hooks for Nuxt runtime specific features
+  getPreviousPageInfo?: () => { locale: string, routeName: string } | null
+  getCustomMissingHandler?: () => MissingHandler | null
+  enablePreviousPageFallback?: boolean
+}
+
+/**
+ * Abstract base class for i18n adapters
+ *
+ * Contains all common translation logic (t, ts, tc, tn, td, tdr, has).
+ * Adapters must implement abstract methods to provide current state (locale, fallbackLocale, route).
+ */
+export abstract class BaseI18n {
+  // Public fields (made public to allow type export in Nuxt plugins)
+  public helper: ReturnType<typeof useTranslationHelper>
+  public formatter = new FormatService()
+  public pluralFunc: PluralFunc
+  public missingWarn: boolean
+  public missingHandler?: (locale: string, key: string, routeName: string) => void
+  // Optional hooks for Nuxt runtime specific features
+  public getPreviousPageInfo?: () => { locale: string, routeName: string } | null
+  public getCustomMissingHandler?: () => MissingHandler | null
+  public enablePreviousPageFallback: boolean
+
+  constructor(options: BaseI18nOptions = {}) {
+    this.helper = useTranslationHelper(options.storage)
+    this.formatter = new FormatService()
+    this.pluralFunc = options.plural || defaultPlural
+    this.missingWarn = options.missingWarn ?? true
+    this.missingHandler = options.missingHandler
+    this.getPreviousPageInfo = options.getPreviousPageInfo
+    this.getCustomMissingHandler = options.getCustomMissingHandler
+    this.enablePreviousPageFallback = options.enablePreviousPageFallback ?? false
+  }
+
+  // --- Abstract methods (must be implemented by subclasses) ---
+
+  /**
+   * Get current locale
+   */
+  public abstract getLocale(): string
+
+  /**
+   * Get fallback locale
+   */
+  public abstract getFallbackLocale(): string
+
+  /**
+   * Get current route name
+   */
+  public abstract getRoute(): string
+
+  // --- Public methods (implemented in base class) ---
+
+  /**
+   * Get translation for a key
+   * Based on logic from src/runtime/plugins/01.plugin.ts
+   */
+  public t(
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string | null,
+    routeName?: string,
+  ): CleanTranslation {
+    if (!key) return ''
+
+    // Use abstract getters to get current state
+    const locale = this.getLocale()
+    const route = routeName || this.getRoute()
+
+    // 1. Try to find translation in current locale
+    // Note: In Nuxt runtime, server already merges global translations, so we don't need explicit fallback
+    let value = this.helper.getTranslation<string>(locale, route, key)
+
+    // 2. If translation not found and there are saved previous translations, use them (only if enabled)
+    if (!value && this.enablePreviousPageFallback && this.getPreviousPageInfo) {
+      const prev = this.getPreviousPageInfo()
+      if (prev) {
+        const prevValue = this.helper.getTranslation<string>(prev.locale, prev.routeName, key)
+        if (prevValue) {
+          value = prevValue
+          if (process.env.NODE_ENV !== 'production') {
+            console.log(`Using fallback translation from previous route: ${prev.routeName} -> ${key}`)
+          }
+        }
+      }
+    }
+
+    // 3. Fallback to fallbackLocale if not found and different (for non-Nuxt adapters)
+    if (!value) {
+      const fallbackLocale = this.getFallbackLocale()
+      if (locale !== fallbackLocale) {
+        value = this.helper.getTranslation<string>(fallbackLocale, route, key)
+      }
+    }
+
+    // 4. Handle missing
+    if (!value) {
+      // Call custom handler if set (Nuxt runtime), otherwise use instance handler
+      const customHandler = this.getCustomMissingHandler?.()
+      if (customHandler) {
+        customHandler(locale, key, route)
+      }
+      else if (this.missingHandler) {
+        this.missingHandler(locale, key as string, route)
+      }
+      else if (this.missingWarn) {
+        const isDev = process.env.NODE_ENV !== 'production'
+        const isClient = typeof window !== 'undefined'
+        if (isDev && isClient) {
+          console.warn(`Not found '${key}' key in '${locale}' locale messages for route '${route}'.`)
+        }
+      }
+      value = defaultValue === undefined ? key : (defaultValue || key)
+    }
+
+    // 5. Interpolate
+    return typeof value === 'string' && params ? interpolate(value, params) : value as CleanTranslation
+  }
+
+  /**
+   * Get translation as string
+   */
+  public ts(
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string,
+    routeName?: string,
+  ): string {
+    const value = this.t(key, params, defaultValue, routeName)
+    return value?.toString() ?? defaultValue ?? key
+  }
+
+  /**
+   * Plural translation
+   */
+  public tc(key: TranslationKey, count: number | Params, defaultValue?: string): string {
+    const { count: countValue, ...params } = typeof count === 'number' ? { count } : count
+
+    if (countValue === undefined) {
+      return defaultValue ?? key
+    }
+
+    // Getter passed to plural function
+    const getter: Getter = (k: TranslationKey, p?: Params, dv?: string) => {
+      return this.t(k, p, dv)
+    }
+
+    const result = this.pluralFunc(
+      key,
+      Number.parseInt(countValue.toString()),
+      params,
+      this.getLocale(),
+      getter,
+    )
+
+    return result ?? defaultValue ?? key
+  }
+
+  /**
+   * Format number
+   */
+  public tn(value: number, options?: Intl.NumberFormatOptions): string {
+    return this.formatter.formatNumber(value, this.getLocale(), options)
+  }
+
+  /**
+   * Format date
+   */
+  public td(value: Date | number | string, options?: Intl.DateTimeFormatOptions): string {
+    return this.formatter.formatDate(value, this.getLocale(), options)
+  }
+
+  /**
+   * Format relative time
+   */
+  public tdr(value: Date | number | string, options?: Intl.RelativeTimeFormatOptions): string {
+    return this.formatter.formatRelativeTime(value, this.getLocale(), options)
+  }
+
+  /**
+   * Check if translation exists
+   * Based on logic from src/runtime/plugins/01.plugin.ts
+   */
+  public has(key: TranslationKey, routeName?: string): boolean {
+    const route = routeName || this.getRoute()
+    const locale = this.getLocale()
+
+    // Check only through getTranslation (as in plugin)
+    return !!this.helper.getTranslation(locale, route, key)
+  }
+
+  /**
+   * Clear cache
+   */
+  public clearCache(): void {
+    this.helper.clearCache()
+  }
+
+  // --- Public methods (for subclasses to use) ---
+
+  /**
+   * Core translation loading logic (without reactivity)
+   * Subclasses can override addTranslations/addRouteTranslations to add reactivity
+   */
+  public loadTranslationsCore(locale: string, translations: Translations, merge: boolean): void {
+    if (merge) {
+      this.helper.mergeGlobalTranslation(locale, translations, true)
+    }
+    else {
+      this.helper.setTranslations(locale, translations)
+    }
+  }
+
+  /**
+   * Core route translation loading logic (without reactivity)
+   * Subclasses can override addRouteTranslations to add reactivity
+   */
+  public loadRouteTranslationsCore(
+    locale: string,
+    routeName: string,
+    translations: Translations,
+    merge: boolean,
+  ): void {
+    if (merge) {
+      this.helper.mergeTranslation(locale, routeName, translations, true)
+    }
+    else {
+      this.helper.loadPageTranslations(locale, routeName, 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,7 +1,8 @@
-import { useTranslationHelper, type TranslationCache } from './translation'
+import { useTranslationHelper, type TranslationStorage } from './translation'
 import { RouteService } from './route-service'
 import { FormatService } from './format-service'
 import { interpolate, withPrefixStrategy, isNoPrefixStrategy, isPrefixStrategy, isPrefixExceptDefaultStrategy, isPrefixAndDefaultStrategy, defaultPlural } from './helpers'
+import { BaseI18n, type BaseI18nOptions } from './base'
 
 export {
   useTranslationHelper,
@@ -14,5 +15,7 @@ export {
   defaultPlural,
   RouteService,
   FormatService,
-  type TranslationCache,
+  BaseI18n,
+  type TranslationStorage,
+  type BaseI18nOptions,
 }

package/src/route-service.ts

@@ -13,7 +13,7 @@ import type {
   Router,
 } from 'vue-router'
 import type { I18nRouteParams, Locale, ModuleOptionsExtend } from '@i18n-micro/types'
-import { isNoPrefixStrategy, withPrefixStrategy } from './helpers'
+import { isNoPrefixStrategy, withPrefixStrategy, isPrefixAndDefaultStrategy, isPrefixExceptDefaultStrategy } from './helpers'
 
 interface NavigateToInterface {
   replace?: boolean
@@ -21,6 +21,8 @@ interface NavigateToInterface {
   external?: boolean
 }
 
+export type GetDefaultLocale = () => string | null | undefined
+
 export class RouteService {
   constructor(
     private i18nConfig: ModuleOptionsExtend,
@@ -28,9 +30,8 @@ export class RouteService {
     private hashLocaleDefault: string | null | undefined,
     private noPrefixDefault: string | null | undefined,
     private navigateTo: (to: RouteLocationRaw | undefined | null, options?: NavigateToInterface) => Promise<void | NavigationFailure | false> | false | void | RouteLocationRaw,
-    private setCookie: (name: string, value: string) => void,
-    private cookieLocaleDefault: string | null | undefined = null,
-    private cookieLocaleName: string | null | undefined = null,
+    /** Optional getter for current locale (used by hash/noPrefix when state changes). Plugin provides () => localeState.value */
+    private getDefaultLocale?: GetDefaultLocale,
   ) {}
 
   /**
@@ -75,14 +76,25 @@ export class RouteService {
   getCurrentLocale(route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric): string {
     route = route ?? this.router.currentRoute.value
 
-    // 1. Check hashMode
-    if (this.i18nConfig.hashMode && this.hashLocaleDefault) {
-      return this.hashLocaleDefault
+    // 1. Check hashMode (getter overrides initial value when state changes)
+    if (this.i18nConfig.hashMode) {
+      const fromGetter = this.getDefaultLocale?.()
+      if (fromGetter) return fromGetter
+      if (this.hashLocaleDefault) return this.hashLocaleDefault
     }
 
     // 2. Check noPrefix strategy
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!) && this.noPrefixDefault) {
-      return this.noPrefixDefault
+    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
+      const fromGetter = this.getDefaultLocale?.()
+      if (fromGetter) return fromGetter
+      if (this.noPrefixDefault) return this.noPrefixDefault
+    }
+
+    const path = route.path || route.fullPath || ''
+    // 2b. prefix_and_default at /: useState/cookie can override — / is valid for any locale
+    if (isPrefixAndDefaultStrategy(this.i18nConfig.strategy!) && (path === '/' || path === '')) {
+      const fromGetter = this.getDefaultLocale?.()
+      if (fromGetter) return fromGetter
     }
 
     // 3. Check route.params.locale (for existing routes)
@@ -91,18 +103,21 @@ export class RouteService {
     }
 
     // 4. Extract locale from URL path (for non-existent routes)
-    const path = route.path || route.fullPath || ''
     const localeFromPath = this.extractLocaleFromPath(path)
     if (localeFromPath) {
       return localeFromPath
     }
 
-    // 5. Check cookie (if provided)
-    if (this.cookieLocaleDefault) {
-      return this.cookieLocaleDefault
+    // 5. For prefix_except_default: URL without locale prefix = defaultLocale
+    if (isPrefixExceptDefaultStrategy(this.i18nConfig.strategy!)) {
+      return (this.i18nConfig.defaultLocale || 'en').toString()
     }
 
-    // 6. Return defaultLocale as fallback
+    // 6. Check getter (for no_prefix and other strategies)
+    const fromGetter = this.getDefaultLocale?.()
+    if (fromGetter) return fromGetter
+
+    // 7. Return defaultLocale as fallback
     return (this.i18nConfig.defaultLocale || 'en').toString()
   }
 
@@ -373,24 +388,6 @@ export class RouteService {
     return this.createLocalizedRoute(processedTo, route, currentLocale)
   }
 
-  updateCookies(toLocale: string): void {
-    if (this.i18nConfig.hashMode) {
-      this.setCookie('hash-locale', toLocale)
-      // useCookie('hash-locale').value = toLocale
-      this.hashLocaleDefault = toLocale
-    }
-    if (isNoPrefixStrategy(this.i18nConfig.strategy!)) {
-      this.setCookie('no-prefix-locale', toLocale)
-      // useCookie('no-prefix-locale').value = toLocale
-      this.noPrefixDefault = toLocale
-    }
-    // Update cookie for regular strategy (prefix or prefix_except_default)
-    if (!this.i18nConfig.hashMode && !isNoPrefixStrategy(this.i18nConfig.strategy!) && this.cookieLocaleName) {
-      this.setCookie(this.cookieLocaleName, toLocale)
-      this.cookieLocaleDefault = toLocale
-    }
-  }
-
   getCurrentRoute(): RouteLocationNormalizedLoaded {
     return this.router.currentRoute.value
   }
@@ -422,7 +419,6 @@ export class RouteService {
       current = to ?? this.getCurrentRoute() as RouteLocationResolved
     }
 
-    this.updateCookies(toLocale)
     const switchedRoute = this.switchLocaleRoute(fromLocale, toLocale, current, i18nRouteParams)
 
     if (typeof switchedRoute === 'string' && switchedRoute.startsWith('http')) {