nuxt-i18n-micro 3.19.0 → 3.20.0

package/dist/runtime/plugins/01.plugin.d.ts

@@ -3,32 +3,32 @@ import type { CleanTranslation, I18nRouteParams, Locale, MissingHandler, ModuleO
 import type { RouteLocationNamedRaw, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteLocationResolved, RouteLocationResolvedGeneric } from 'vue-router';
 declare const _default: import("nuxt/app").Plugin<{
     getI18nConfig: () => ModuleOptionsExtend;
-    i18n: undefined;
-    __micro: boolean;
     helper: {
         mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): Promise<void>;
     };
-    i18nStrategy: import("~/packages/path-strategy/dist/prefix-except-default-strategy.mjs").PrefixExceptDefaultPathStrategy;
+    i18n: unknown;
+    __micro: boolean;
+    i18nStrategy: PathStrategy;
     getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
-    getLocaleName: () => any;
+    getLocaleName: () => string | null;
     defaultLocale: () => string | undefined;
     getLocales: () => Locale[];
-    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => any;
-    t: (key: string, params?: Params, defaultValue?: string | null, route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => CleanTranslation;
+    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
+    t: (key: import("@i18n-micro/types").TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
     ts: (key: string, params?: Params, defaultValue?: string, route?: RouteLocationNormalizedLoaded) => string;
     _t: (route: RouteLocationNormalizedLoaded) => (key: string, params?: Params, defaultValue?: string | null) => CleanTranslation;
     _ts: (route: RouteLocationNormalizedLoaded) => (key: string, params?: Params, defaultValue?: string) => string;
-    tc: (key: string, params: number | Params, defaultValue?: string) => string;
+    tc: (key: import("@i18n-micro/types").TranslationKey, count: number | Params, defaultValue?: string) => string;
     tn: (value: number, options?: Intl.NumberFormatOptions) => string;
     td: (value: Date | number | string, options?: Intl.DateTimeFormatOptions) => string;
     tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
-    has: (key: string) => boolean;
+    has: (key: import("@i18n-micro/types").TranslationKey, routeContext?: unknown) => boolean;
     mergeTranslations: (newTranslations: Translations) => void;
     switchLocaleRoute: (toLocale: string) => RouteLocationRaw;
     clearCache: () => void;
     switchLocalePath: (toLocale: string) => string;
-    switchLocale: (toLocale: string) => Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
-    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | Promise<false | void | import("vue-router").NavigationFailure>;
+    switchLocale: (toLocale: string) => Promise<unknown>;
+    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => unknown;
     localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
     localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
     setI18nRouteParams: (value: I18nRouteParams) => I18nRouteParams;
@@ -36,32 +36,32 @@ declare const _default: import("nuxt/app").Plugin<{
     setMissingHandler: (handler: MissingHandler | null) => void;
 }> & import("nuxt/app").ObjectPlugin<{
     getI18nConfig: () => ModuleOptionsExtend;
-    i18n: undefined;
-    __micro: boolean;
     helper: {
         mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): Promise<void>;
     };
-    i18nStrategy: import("~/packages/path-strategy/dist/prefix-except-default-strategy.mjs").PrefixExceptDefaultPathStrategy;
+    i18n: unknown;
+    __micro: boolean;
+    i18nStrategy: PathStrategy;
     getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
-    getLocaleName: () => any;
+    getLocaleName: () => string | null;
     defaultLocale: () => string | undefined;
     getLocales: () => Locale[];
-    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => any;
-    t: (key: string, params?: Params, defaultValue?: string | null, route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => CleanTranslation;
+    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
+    t: (key: import("@i18n-micro/types").TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
     ts: (key: string, params?: Params, defaultValue?: string, route?: RouteLocationNormalizedLoaded) => string;
     _t: (route: RouteLocationNormalizedLoaded) => (key: string, params?: Params, defaultValue?: string | null) => CleanTranslation;
     _ts: (route: RouteLocationNormalizedLoaded) => (key: string, params?: Params, defaultValue?: string) => string;
-    tc: (key: string, params: number | Params, defaultValue?: string) => string;
+    tc: (key: import("@i18n-micro/types").TranslationKey, count: number | Params, defaultValue?: string) => string;
     tn: (value: number, options?: Intl.NumberFormatOptions) => string;
     td: (value: Date | number | string, options?: Intl.DateTimeFormatOptions) => string;
     tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
-    has: (key: string) => boolean;
+    has: (key: import("@i18n-micro/types").TranslationKey, routeContext?: unknown) => boolean;
     mergeTranslations: (newTranslations: Translations) => void;
     switchLocaleRoute: (toLocale: string) => RouteLocationRaw;
     clearCache: () => void;
     switchLocalePath: (toLocale: string) => string;
-    switchLocale: (toLocale: string) => Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
-    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | Promise<false | void | import("vue-router").NavigationFailure>;
+    switchLocale: (toLocale: string) => Promise<unknown>;
+    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => unknown;
     localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
     localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
     setI18nRouteParams: (value: I18nRouteParams) => I18nRouteParams;
@@ -74,8 +74,8 @@ export interface PluginsInjections {
     $getI18nConfig: () => ModuleOptionsExtend;
     $getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
     $getLocaleName: () => string | null;
-    $getLocales: () => Locale[];
     $defaultLocale: () => string | undefined;
+    $getLocales: () => Locale[];
     $getRouteName: (route?: RouteLocationNamedRaw | RouteLocationResolvedGeneric, locale?: string) => string;
     $t: (key: string, params?: Params, defaultValue?: string | null) => CleanTranslation;
     $_t: (route: RouteLocationNormalizedLoaded) => (key: string, params?: Params, defaultValue?: string | null) => CleanTranslation;

package/dist/runtime/plugins/01.plugin.js

@@ -1,25 +1,13 @@
-import { FormatService, isNoPrefixStrategy } from "@i18n-micro/core";
-import { deepMergeTranslations } from "@i18n-micro/utils/deep-merge";
+import { isNoPrefixStrategy } from "@i18n-micro/core";
 import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { shallowRef, triggerRef, unref } from "vue";
 import { useState } from "#app";
 import { plural } from "#build/i18n.plural.mjs";
 import { createI18nStrategy, getI18nConfig } from "#build/i18n.strategy.mjs";
-import { createError, defineNuxtPlugin, navigateTo, useHead, useRouter, useRuntimeConfig } from "#imports";
+import { createError, defineNuxtPlugin, navigateTo, useRouter, useRuntimeConfig } from "#imports";
 import { useI18nLocale } from "../composables/useI18nLocale.js";
+import { createNuxtI18nPluginApi, NuxtI18n, NuxtTranslationLoader } from "../utils/nuxt-i18n.js";
 import { translationStorage } from "../utils/storage.js";
 const isDev = process.env.NODE_ENV !== "production";
-const RE_TOKEN = /\{(\w+)\}/g;
-function getByPath(obj, path) {
-  if (obj[path] !== void 0) return obj[path];
-  const parts = path.split(".");
-  let v = obj;
-  for (const p of parts) {
-    if (v == null || typeof v !== "object") return void 0;
-    v = v[p];
-  }
-  return v;
-}
 export default defineNuxtPlugin(async (nuxtApp) => {
   const router = useRouter();
   const i18nStrategy = createI18nStrategy(router);
@@ -32,14 +20,15 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     maxSize: i18nConfig.cacheMaxSize ?? 0,
     ttl: i18nConfig.cacheTtl ?? 0
   });
-  const loadedChunks = /* @__PURE__ */ new Map();
-  let currentLocale = "";
-  let currentRouteName = "";
-  let cachedTranslations = {};
-  let pendingCleanState = null;
-  const contextSignal = shallowRef(0);
   const { locale: localeState, setLocale, getLocale, getEffectiveLocale, resolveInitialLocale, isValidLocale } = useI18nLocale();
-  const translationService = new FormatService();
+  const i18nRouteParams = useState("i18n-route-params", () => ({}));
+  const customMissingHandler = useState("i18n-missing-handler", () => null);
+  const ssrChunks = useState("i18n-ssr-chunks", () => ({}));
+  const i18n = new NuxtI18n({
+    plural,
+    missingWarn: i18nConfig.missingWarn ?? true,
+    getCustomMissingHandler: () => customMissingHandler.value
+  });
   const getCurrentLocale = (route) => {
     const r = route ?? router.currentRoute.value;
     return i18nStrategy.getCurrentLocale(r, getLocale() ?? null);
@@ -47,103 +36,36 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   const getPluginRouteName = (route, locale) => {
     return i18nStrategy.getPluginRouteName(route, locale);
   };
-  const switchLocaleLogic = (toLocale, i18nParams, to) => {
-    const fromLocale = getCurrentLocale();
-    const currentRoute = router.currentRoute.value;
-    let resolvedTarget;
-    if (typeof to === "string") {
-      const formattedPath = i18nStrategy.formatPathForResolve(to, fromLocale, toLocale);
-      resolvedTarget = router.resolve(formattedPath);
-    } else {
-      resolvedTarget = to ?? currentRoute;
-    }
-    const switchedRoute = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, resolvedTarget, {
-      i18nRouteParams: i18nParams
-    });
-    if (typeof switchedRoute === "string" && (switchedRoute.startsWith("http://") || switchedRoute.startsWith("https://"))) {
-      return navigateTo(switchedRoute, { redirectCode: 200, external: true });
-    }
-    if (isNoPrefixStrategy(i18nConfig.strategy)) {
-      ;
-      switchedRoute.force = true;
-    }
-    return router.push(switchedRoute);
-  };
+  i18n.setRouteContextResolver((route) => {
+    const resolvedRoute = route ?? router.currentRoute.value;
+    const locale = getCurrentLocale(resolvedRoute);
+    return {
+      locale,
+      routeName: getPluginRouteName(resolvedRoute, locale)
+    };
+  });
   nuxtApp.hook("page:transition:finish", () => {
-    if (pendingCleanState) {
-      cachedTranslations = pendingCleanState;
-      pendingCleanState = null;
-    }
+    i18n.finishTransition();
   });
-  const i18nRouteParams = useState("i18n-route-params", () => ({}));
-  const customMissingHandler = useState("i18n-missing-handler", () => null);
-  const missingWarn = i18nConfig.missingWarn ?? true;
   const loadOptions = {
     apiBaseUrl: i18nConfig.apiBaseUrl ?? "_locales",
     baseURL: runtimeConfig.app.baseURL,
     apiBaseClientHost: i18nConfig.apiBaseClientHost,
-    apiBaseServerHost: i18nConfig.apiBaseServerHost,
     dateBuild: i18nConfig.dateBuild,
     routesLocaleLinks: i18nConfig.routesLocaleLinks
   };
-  const getCacheKey = (locale, routeName) => {
-    return `${locale}:${routeName || "index"}`;
-  };
-  const loadFromCacheSync = (locale, routeName) => {
-    const cacheKey = getCacheKey(locale, routeName);
-    if (loadedChunks.has(cacheKey)) {
-      return loadedChunks.get(cacheKey);
-    }
-    const cached = translationStorage.getFromCache(locale, routeName);
-    if (cached) {
-      loadedChunks.set(cacheKey, cached.data);
-      return cached.data;
-    }
-    return null;
-  };
-  const pendingLoads = /* @__PURE__ */ new Map();
-  const loadAsync = (locale, routeName) => {
-    const cacheKey = getCacheKey(locale, routeName);
-    const pending = pendingLoads.get(cacheKey);
-    if (pending) return pending;
-    const promise = (async () => {
-      try {
-        const result = await translationStorage.load(locale, routeName, loadOptions);
-        const existing = loadedChunks.get(cacheKey);
-        const mergedChunk = existing ? { ...result.data, ...existing } : result.data;
-        loadedChunks.set(cacheKey, mergedChunk);
-        if (import.meta.server && result.json) {
-          const ctx = nuxtApp.ssrContext.event.context;
-          if (!ctx._i18n) ctx._i18n = {};
-          ctx._i18n[cacheKey] = result.json;
-        }
-        return mergedChunk;
-      } catch (e) {
-        if (isDev) console.error("[i18n] Load error:", e);
-        return {};
-      } finally {
-        pendingLoads.delete(cacheKey);
-      }
-    })();
-    pendingLoads.set(cacheKey, promise);
-    return promise;
-  };
-  const switchContext = async (locale, routeName) => {
-    let data = loadFromCacheSync(locale, routeName);
-    if (data === null) {
-      data = await loadAsync(locale, routeName);
-    }
-    if (currentLocale === locale) {
-      cachedTranslations = deepMergeTranslations(cachedTranslations, data);
-      pendingCleanState = data;
-    } else {
-      cachedTranslations = deepMergeTranslations(cachedTranslations, data);
-      pendingCleanState = null;
-    }
-    currentLocale = locale;
-    currentRouteName = routeName || "";
-    triggerRef(contextSignal);
-  };
+  if (import.meta.client && Object.keys(ssrChunks.value).length > 0) {
+    translationStorage.seedFromSsrChunks(ssrChunks.value);
+  }
+  const loader = new NuxtTranslationLoader({
+    i18n,
+    loadOptions,
+    getSsrChunks: () => ssrChunks.value,
+    setSsrChunk: (cacheKey, data) => {
+      ssrChunks.value = { ...ssrChunks.value, [cacheKey]: data };
+    },
+    isDev
+  });
   const serverLocale = import.meta.server ? nuxtApp.ssrContext?.event?.context?.i18n?.locale : void 0;
   const initialLocale = resolveInitialLocale({
     route: router.currentRoute.value,
@@ -152,35 +74,50 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   });
   const initialRouteName = getPluginRouteName(router.currentRoute.value, initialLocale);
   try {
-    await switchContext(initialLocale, initialRouteName);
+    await loader.switchContext(initialLocale, initialRouteName);
   } catch (e) {
     if (isDev) console.error("[i18n] Initial load error:", e);
     throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
   }
-  if (import.meta.server) {
-    const ctx = nuxtApp.ssrContext?.event.context;
-    if (ctx?._i18n && Object.keys(ctx._i18n).length > 0) {
-      let script = "window.__I18N__={};";
-      for (const [key, value] of Object.entries(ctx._i18n)) {
-        const safeKey = JSON.stringify(key);
-        script += `window.__I18N__[${safeKey}]=${value};`;
-      }
-      useHead({
-        script: [{ innerHTML: script, type: "text/javascript", tagPosition: "bodyClose" }]
-      });
+  const getRouteName = (route, locale) => {
+    const selectedRoute = route ?? router.currentRoute.value;
+    const selectedLocale = locale ?? getCurrentLocale(selectedRoute);
+    return i18nStrategy.getRouteBaseName(selectedRoute, selectedLocale) ?? "";
+  };
+  const {
+    helper,
+    switchContext,
+    provide: provideApi
+  } = createNuxtI18nPluginApi({
+    i18n,
+    loader,
+    i18nStrategy,
+    i18nConfig,
+    router,
+    getCurrentLocale,
+    getEffectiveLocale,
+    getPluginRouteName,
+    getRouteName,
+    i18nRouteParams,
+    setLocale,
+    isValidLocale,
+    navigateTo,
+    setMissingHandler: (handler) => {
+      customMissingHandler.value = handler;
     }
-  }
+  });
   router.beforeEach(async (to, from) => {
     if (to.name !== from.name) {
       i18nRouteParams.value = {};
     }
-    if (to.path === from.path && !isNoPrefixStrategy(i18nConfig.strategy)) {
+    const shouldSwitchContext = to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy);
+    if (!shouldSwitchContext) {
       return;
     }
     try {
       const targetLocale = getEffectiveLocale(to, (r) => getCurrentLocale(r));
       const targetRouteName = getPluginRouteName(to, targetLocale);
-      if (targetLocale !== currentLocale || targetRouteName !== currentRouteName) {
+      if (targetLocale !== i18n.getCurrentLocale() || targetRouteName !== i18n.getCurrentRouteName()) {
         await switchContext(targetLocale, targetRouteName);
       }
       if (targetLocale && isValidLocale(targetLocale) && localeState.value !== targetLocale) {
@@ -191,195 +128,11 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     }
     return;
   });
-  const tFast = (key, params, defaultValue, route) => {
-    if (!key) return "";
-    contextSignal.value;
-    const translations = route ? loadedChunks.get(
-      getCacheKey(
-        getCurrentLocale(route),
-        getPluginRouteName(route, getCurrentLocale(route))
-      )
-    ) || {} : cachedTranslations;
-    let val = translations[key];
-    if (val === void 0 && key.includes(".")) {
-      val = getByPath(translations, key);
-    }
-    if (val === void 0) {
-      if (customMissingHandler.value) {
-        customMissingHandler.value(currentLocale, key, currentRouteName);
-      } else if (missingWarn && isDev && import.meta.client) {
-        console.warn(`[i18n] Missing key '${key}' in '${currentLocale}' for route '${currentRouteName}'`);
-      }
-      return defaultValue === void 0 ? key : defaultValue;
-    }
-    if (typeof val !== "string") return val;
-    if (!params) return val;
-    return val.replace(RE_TOKEN, (_, k) => {
-      return params[k] !== void 0 ? String(params[k]) : `{${k}}`;
-    });
-  };
-  const getRouteName = (route, locale) => {
-    const selectedRoute = route ?? router.currentRoute.value;
-    const selectedLocale = locale ?? getCurrentLocale(selectedRoute);
-    return i18nStrategy.getRouteBaseName(selectedRoute, selectedLocale) ?? "";
-  };
-  const hasTranslation = (key) => {
-    contextSignal.value;
-    if (cachedTranslations[key] !== void 0) return true;
-    if (key.includes(".") && getByPath(cachedTranslations, key) !== void 0) return true;
-    return false;
-  };
-  const mergeTranslations = (newTranslations) => {
-    const cacheKey = getCacheKey(currentLocale, currentRouteName);
-    const current = loadedChunks.get(cacheKey) || {};
-    const merged = { ...current, ...newTranslations };
-    loadedChunks.set(cacheKey, merged);
-    cachedTranslations = deepMergeTranslations(cachedTranslations, merged);
-    if (pendingCleanState) pendingCleanState = merged;
-    triggerRef(contextSignal);
-  };
-  const helper = {
-    async mergeTranslation(locale, routeName, newTranslations, _force = false) {
-      const cacheKey = getCacheKey(locale, routeName);
-      if (!loadedChunks.has(cacheKey)) {
-        await loadAsync(locale, routeName || void 0);
-      }
-      const existing = loadedChunks.get(cacheKey) || {};
-      const mergedChunk = { ...existing, ...newTranslations };
-      loadedChunks.set(cacheKey, mergedChunk);
-      if (locale === currentLocale && routeName === currentRouteName) {
-        cachedTranslations = deepMergeTranslations(cachedTranslations, mergedChunk);
-        if (pendingCleanState) pendingCleanState = mergedChunk;
-        triggerRef(contextSignal);
-      }
-    }
-  };
   const provideData = {
-    i18n: void 0,
-    __micro: true,
+    ...provideApi,
     helper,
-    i18nStrategy,
-    getLocale: (route) => getEffectiveLocale(route, (r) => getCurrentLocale(r)),
-    getLocaleName: () => i18nStrategy.getCurrentLocaleName(router.currentRoute.value, getLocale() ?? null),
-    defaultLocale: () => i18nConfig.defaultLocale,
-    getLocales: () => i18nConfig.locales || [],
-    getRouteName,
-    t: tFast,
-    ts: (key, params, defaultValue, route) => {
-      const value = tFast(key, params, defaultValue, route);
-      return value?.toString() ?? defaultValue ?? key;
-    },
-    _t: (route) => {
-      return (key, params, defaultValue) => {
-        return tFast(key, params, defaultValue, route);
-      };
-    },
-    _ts: (route) => {
-      return (key, params, defaultValue) => {
-        const value = tFast(key, params, defaultValue, route);
-        return value?.toString() ?? defaultValue ?? key;
-      };
-    },
-    tc: (key, params, defaultValue) => {
-      contextSignal.value;
-      const { count, ..._params } = typeof params === "number" ? { count: params } : params;
-      if (count === void 0) return defaultValue ?? key;
-      return plural(key, Number.parseInt(count.toString(), 10), _params, currentLocale, tFast) ?? defaultValue ?? key;
-    },
-    tn: (value, options) => {
-      contextSignal.value;
-      return translationService.formatNumber(value, currentLocale, options);
-    },
-    td: (value, options) => {
-      contextSignal.value;
-      return translationService.formatDate(value, currentLocale, options);
-    },
-    tdr: (value, options) => {
-      contextSignal.value;
-      return translationService.formatRelativeTime(value, currentLocale, options);
-    },
-    has: hasTranslation,
-    mergeTranslations,
-    switchLocaleRoute: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route);
-      return i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
-    },
-    clearCache: () => {
-      translationStorage.clear();
-      loadedChunks.clear();
-      cachedTranslations = {};
-      triggerRef(contextSignal);
-    },
-    switchLocalePath: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route);
-      const localeRoute = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
-      if (!localeRoute || typeof localeRoute !== "object") return String(localeRoute ?? "");
-      if ("fullPath" in localeRoute && localeRoute.fullPath) return localeRoute.fullPath;
-      if ("path" in localeRoute && localeRoute.path) return localeRoute.path;
-      if ("name" in localeRoute && localeRoute.name && router.hasRoute(String(localeRoute.name))) {
-        return router.resolve(localeRoute).fullPath;
-      }
-      return "";
-    },
-    switchLocale: async (toLocale) => {
-      if (!isValidLocale(toLocale)) {
-        if (isDev) {
-          console.warn(`[i18n] Invalid locale '${toLocale}'`);
-        }
-        return;
-      }
-      setLocale(toLocale);
-      if (isNoPrefixStrategy(i18nConfig.strategy) || i18nConfig.hashMode) {
-        const route = router.currentRoute.value;
-        const routeName = getPluginRouteName(route, toLocale);
-        await switchContext(toLocale, routeName);
-      }
-      return switchLocaleLogic(toLocale, unref(i18nRouteParams.value));
-    },
-    switchRoute: (route, toLocale) => {
-      return switchLocaleLogic(
-        toLocale ?? getCurrentLocale(),
-        unref(i18nRouteParams.value),
-        route
-      );
-    },
-    localeRoute(to, locale) {
-      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
-      const currentRoute = router.currentRoute.value;
-      const result = i18nStrategy.localeRoute(targetLocale, to, currentRoute);
-      const fullPath = result.fullPath ?? result.path ?? "";
-      const path = result.path ?? fullPath.split("?")[0]?.split("#")[0] ?? fullPath;
-      const out = { path, fullPath, href: fullPath };
-      if (result.query && Object.keys(result.query).length) out.query = result.query;
-      if (result.hash) out.hash = result.hash;
-      return out;
-    },
-    localePath(to, locale) {
-      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
-      const currentRoute = router.currentRoute.value;
-      const result = i18nStrategy.localeRoute(targetLocale, to, currentRoute);
-      return result.fullPath ?? result.path ?? "";
-    },
-    setI18nRouteParams: (value) => {
-      i18nRouteParams.value = value;
-      return i18nRouteParams.value;
-    },
-    loadPageTranslations: async (locale, routeName, translations) => {
-      const cacheKey = getCacheKey(locale, routeName);
-      const current = loadedChunks.get(cacheKey) || {};
-      const mergedChunk = { ...current, ...translations };
-      loadedChunks.set(cacheKey, mergedChunk);
-      if (locale === currentLocale && routeName === currentRouteName) {
-        cachedTranslations = deepMergeTranslations(cachedTranslations, mergedChunk);
-        if (pendingCleanState) pendingCleanState = mergedChunk;
-        triggerRef(contextSignal);
-      }
-    },
-    setMissingHandler: (handler) => {
-      customMissingHandler.value = handler;
-    }
+    i18n: void 0,
+    __micro: true
   };
   const $provideData = Object.fromEntries(Object.entries(provideData).map(([key, value]) => [`$${key}`, value]));
   provideData.i18n = { ...provideData, ...$provideData };

package/dist/runtime/plugins/05.hooks.js

@@ -3,43 +3,43 @@ import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime
 import { getI18nConfig } from "#build/i18n.strategy.mjs";
 import { defineNuxtPlugin, useNuxtApp, useRouter } from "#imports";
 const isDev = process.env.NODE_ENV !== "production";
-export default defineNuxtPlugin(async (nuxtApp) => {
-  const getRuntimeConfig = nuxtApp.$getI18nConfig;
-  const i18nConfig = resolveI18nConfigWithRuntimeOverrides(
-    typeof getRuntimeConfig === "function" ? getRuntimeConfig() : getI18nConfig()
-  );
-  const router = useRouter();
-  const { $getLocale, $getRouteName } = useNuxtApp();
-  const i18nHelper = nuxtApp.$i18n.helper;
-  if (!i18nHelper) {
-    if (isDev) {
-      console.warn("[i18n] Helper is not available. Skipping hooks plugin.");
+export default defineNuxtPlugin({
+  name: "i18n-plugin-hooks",
+  dependsOn: ["i18n-plugin-loader"],
+  async setup(nuxtApp) {
+    const getRuntimeConfig = nuxtApp.$getI18nConfig;
+    const i18nConfig = resolveI18nConfigWithRuntimeOverrides(
+      typeof getRuntimeConfig === "function" ? getRuntimeConfig() : getI18nConfig()
+    );
+    const router = useRouter();
+    const { $getLocale, $getRouteName } = useNuxtApp();
+    const i18nHelper = nuxtApp.$i18n?.helper;
+    if (!i18nHelper) {
+      if (isDev) {
+        console.warn("[i18n] Helper is not available. Skipping hooks plugin.");
+      }
+      return;
     }
-    return;
-  }
-  const locale = $getLocale();
-  const routeName = $getRouteName();
-  await nuxtApp.callHook(
-    // @ts-expect-error i18n:register is custom hook
-    "i18n:register",
-    (translations, selectedLocale) => {
-      i18nHelper.mergeTranslation(selectedLocale ?? locale, routeName, translations, true);
-    },
-    locale
-  );
-  router.beforeEach(async (to, from) => {
-    if (to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy)) {
-      const locale2 = $getLocale(to);
-      const routeName2 = $getRouteName(to);
+    const callRegister = async (route) => {
+      const locale = $getLocale(route);
+      const routeName = $getRouteName(route);
       await nuxtApp.callHook(
         // @ts-expect-error i18n:register is custom hook
         "i18n:register",
         (translations, selectedLocale) => {
-          i18nHelper.mergeTranslation(selectedLocale ?? locale2, routeName2, translations, true);
+          void i18nHelper.mergeTranslation(selectedLocale ?? locale, routeName, translations, true);
         },
-        locale2
+        locale
       );
+    };
+    if (i18nConfig.hooks !== false) {
+      await callRegister();
     }
-    return;
-  });
+    router.beforeEach(async (to, from) => {
+      if (i18nConfig.hooks === false) return;
+      if (to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy)) {
+        await callRegister(to);
+      }
+    });
+  }
 });

package/dist/runtime/plugins/06.redirect.d.ts

@@ -1,6 +1,7 @@
 /**
  * Universal redirect plugin for i18n routes (works on both server and client).
  * Handles locale detection, 404 checks, and redirects.
+ * Client SPA redirects are handled by i18n-redirect route middleware.
  */
 declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;