nuxt-i18n-micro 1.63.2 → 1.65.0

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

@@ -1,233 +1,40 @@
-import { useTranslationHelper, interpolate } from "nuxt-i18n-micro-core";
-import { isNoPrefixStrategy, withPrefixStrategy } from "../helpers.js";
+import { useTranslationHelper, interpolate, isNoPrefixStrategy, RouteService, FormatService } from "nuxt-i18n-micro-core";
 import { defineNuxtPlugin, useRuntimeConfig } from "#app";
-import { useRouter, useCookie, useState, navigateTo } from "#imports";
+import { useRouter, useCookie, useState, unref, navigateTo } from "#imports";
 import { plural } from "#build/i18n.plural.mjs";
 const i18nHelper = useTranslationHelper();
 const isDev = process.env.NODE_ENV !== "production";
-function getCurrentLocale(route, i18nConfig, hashLocale, noPrefixStrategy) {
-  if (i18nConfig.hashMode && hashLocale) {
-    return hashLocale;
-  }
-  if (isNoPrefixStrategy(i18nConfig.strategy) && noPrefixStrategy) {
-    return noPrefixStrategy;
-  }
-  return (route.params?.locale ?? i18nConfig.defaultLocale).toString();
-}
-function getCurrentName(route, i18nConfig, hashLocale, noPrefixStrategy) {
-  const currentLocaleCode = getCurrentLocale(route, i18nConfig, hashLocale, noPrefixStrategy);
-  const checkLocale = i18nConfig.locales?.find((l) => l.code === currentLocaleCode);
-  if (!checkLocale) {
-    return null;
-  }
-  return checkLocale?.displayName ?? null;
-}
-function getRouteName(route, locale) {
-  const name = (route.name ?? "").toString();
-  return name.toString().replace("localized-", "").replace(new RegExp(`-${locale}$`), "");
-}
-function switchLocaleRoute(fromLocale, toLocale, route, router, i18nConfig, i18nRouteParams) {
-  const currentLocale = i18nConfig.locales?.find((l) => l.code === toLocale);
-  function getFullPathWithBaseUrl(route2) {
-    const resolvedRoute = router.resolve(route2);
-    let fullPath = resolvedRoute.fullPath;
-    if (currentLocale?.baseDefault) {
-      fullPath = fullPath.replace(new RegExp(`^/${currentLocale.code}`), "");
-    }
-    let baseUrl = currentLocale.baseUrl;
-    if (baseUrl?.endsWith("/")) {
-      baseUrl = baseUrl.slice(0, -1);
-    }
-    return baseUrl + fullPath;
-  }
-  const routeName = getRouteName(route, fromLocale);
-  if (router.hasRoute(`localized-${routeName}-${toLocale}`)) {
-    const newParams2 = { ...route.params, ...i18nRouteParams?.[toLocale] };
-    newParams2.locale = toLocale;
-    const newRoute2 = {
-      name: `localized-${routeName}-${toLocale}`,
-      params: newParams2
-    };
-    if (currentLocale?.baseUrl) {
-      return getFullPathWithBaseUrl(newRoute2);
-    }
-    return newRoute2;
-  }
-  let newRouteName = routeName;
-  const newParams = { ...route.params, ...i18nRouteParams?.[toLocale] };
-  delete newParams.locale;
-  if (!isNoPrefixStrategy(i18nConfig.strategy)) {
-    if (routeName === "custom-fallback-route") {
-      newRouteName = routeName;
-    } else {
-      newRouteName = toLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy) ? `localized-${routeName}` : routeName;
-    }
-    if (toLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy)) {
-      newParams.locale = toLocale;
-    }
-  }
-  const newRoute = {
-    name: newRouteName,
-    params: newParams
-  };
-  if (currentLocale?.baseUrl) {
-    return getFullPathWithBaseUrl(newRoute);
-  }
-  return newRoute;
-}
-function switchLocale(fromLocale, toLocale, route, router, i18nConfig, i18nRouteParams) {
-  const checkLocale = i18nConfig.locales?.find((l) => l.code === toLocale);
-  if (!checkLocale) {
-    console.warn(`Locale ${toLocale} is not available`);
-    return Promise.reject(`Locale ${toLocale} is not available`);
-  }
-  const switchedRoute = switchLocaleRoute(
-    fromLocale,
-    toLocale,
-    route,
-    router,
-    i18nConfig,
-    i18nRouteParams
-  );
-  if (typeof switchedRoute === "string" && switchedRoute.startsWith("http")) {
-    return navigateTo(switchedRoute, { redirectCode: 200, external: true });
-  }
-  if (isNoPrefixStrategy(i18nConfig.strategy)) {
-    switchedRoute.force = true;
-  }
-  return router.push(switchedRoute);
-}
-function getLocalizedRoute(to, router, route, i18nConfig, locale, hashLocale, noPrefixStrategy) {
-  const resolveParams = (to2) => {
-    const params = typeof to2 === "object" && "params" in to2 && typeof to2.params === "object" ? { ...to2.params } : {};
-    if (typeof to2 === "string") {
-      const resolved = router.resolve(to2);
-      if (resolved && resolved.params) {
-        Object.assign(params, resolved.params);
-      }
-    }
-    return params;
-  };
-  if (withPrefixStrategy(i18nConfig.strategy)) {
-    const defaultLocale = i18nConfig.defaultLocale;
-    let resolvedTo = to;
-    if (typeof to === "string") {
-      resolvedTo = router.resolve("/" + defaultLocale + to);
-    }
-    const defaultRouteName = getRouteName(resolvedTo, defaultLocale);
-    const newParams2 = resolveParams(resolvedTo);
-    newParams2.locale = defaultLocale;
-    if (router.hasRoute(`localized-${defaultRouteName}`)) {
-      to = router.resolve({
-        name: `localized-${defaultRouteName}`,
-        query: resolvedTo.query,
-        params: newParams2
-      });
-    } else if (router.hasRoute(`localized-${defaultRouteName}-${defaultLocale}`)) {
-      to = router.resolve({
-        name: `localized-${defaultRouteName}-${defaultLocale}`,
-        query: resolvedTo.query,
-        params: newParams2
-      });
-    }
-  }
-  const currentLocale = locale || getCurrentLocale(route, i18nConfig, hashLocale, noPrefixStrategy);
-  const selectRoute = router.resolve(to);
-  const routeName = getRouteName(selectRoute, currentLocale).replace(new RegExp(`-${i18nConfig.defaultLocale}$`), "");
-  if (!routeName || routeName === "") {
-    const resolved = router.resolve(to);
-    let url = resolved.path.replace(new RegExp(`^/${currentLocale}/`), "/");
-    if (currentLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy)) {
-      url = "/" + currentLocale + url;
-    }
-    return router.resolve({
-      path: url,
-      query: selectRoute.query,
-      hash: selectRoute.hash
-    });
-  }
-  if (router.hasRoute(`localized-${routeName}-${currentLocale}`)) {
-    const newParams2 = resolveParams(selectRoute);
-    newParams2.locale = currentLocale;
-    return router.resolve({
-      name: `localized-${routeName}-${currentLocale}`,
-      params: newParams2,
-      query: selectRoute.query,
-      hash: selectRoute.hash
-    });
-  }
-  const newRouteName = currentLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy) ? `localized-${routeName}` : routeName;
-  if (!router.hasRoute(newRouteName)) {
-    const newParams2 = resolveParams(to);
-    delete newParams2.locale;
-    if (!router.hasRoute(routeName)) {
-      return router.resolve("/");
-    }
-    return router.resolve({
-      name: routeName,
-      params: newParams2,
-      query: selectRoute.query,
-      hash: selectRoute.hash
-    });
-  }
-  const newParams = resolveParams(to);
-  delete newParams.locale;
-  if (currentLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy)) {
-    newParams.locale = currentLocale;
-  }
-  return router.resolve({
-    name: newRouteName,
-    params: newParams,
-    query: selectRoute.query,
-    hash: selectRoute.hash
-  });
-}
-function formatNumber(value, locale, options) {
-  return new Intl.NumberFormat(locale, options).format(value);
-}
-function formatDate(value, locale, options) {
-  return new Intl.DateTimeFormat(locale, options).format(new Date(value));
-}
-function formatRelativeTime(value, locale, options) {
-  const date = new Date(value);
-  const now = /* @__PURE__ */ new Date();
-  const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1e3);
-  const units = [
-    { unit: "year", seconds: 31536e3 },
-    { unit: "month", seconds: 2592e3 },
-    { unit: "day", seconds: 86400 },
-    { unit: "hour", seconds: 3600 },
-    { unit: "minute", seconds: 60 },
-    { unit: "second", seconds: 1 }
-  ];
-  for (const { unit, seconds } of units) {
-    const diff = Math.floor(diffInSeconds / seconds);
-    if (diff >= 1) {
-      return new Intl.RelativeTimeFormat(locale, options).format(-diff, unit);
-    }
-  }
-  return new Intl.RelativeTimeFormat(locale, options).format(0, "second");
-}
 export default defineNuxtPlugin(async (nuxtApp) => {
-  if (!nuxtApp.payload.data.translations) {
-    nuxtApp.payload.data.translations = {};
-  }
   const config = useRuntimeConfig();
   const i18nConfig = config.public.i18nConfig;
   const apiBaseUrl = i18nConfig.apiBaseUrl ?? "_locales";
+  const router = useRouter();
   const runtimeConfig = useRuntimeConfig();
   let hashLocaleDefault = null;
   let noPrefixDefault = null;
   if (i18nConfig.hashMode) {
-    hashLocaleDefault = await nuxtApp.runWithContext(() => {
-      return useCookie("hash-locale").value;
-    });
+    hashLocaleDefault = await nuxtApp.runWithContext(() => useCookie("hash-locale").value);
   }
   if (isNoPrefixStrategy(i18nConfig.strategy)) {
-    noPrefixDefault = await nuxtApp.runWithContext(() => {
-      return useCookie("no-prefix-locale").value;
-    });
+    noPrefixDefault = await nuxtApp.runWithContext(() => useCookie("no-prefix-locale").value);
   }
+  const routeService = new RouteService(
+    i18nConfig,
+    router,
+    hashLocaleDefault,
+    noPrefixDefault,
+    (to, options) => navigateTo(to, options),
+    (name, value) => {
+      nuxtApp.runWithContext(() => {
+        return useCookie(name).value = value;
+      });
+    }
+  );
+  const translationService = new FormatService();
+  const i18nRouteParams = useState("i18n-route-params", () => ({}));
+  nuxtApp.hook("page:start", () => {
+    i18nRouteParams.value = null;
+  });
   const loadTranslationsIfNeeded = async (locale, routeName, path) => {
     try {
       if (!i18nHelper.hasPageTranslation(locale, routeName)) {
@@ -252,19 +59,17 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     }
   };
   async function loadGlobalTranslations(to) {
-    let hashLocale = null;
-    let noPrefixLocale = null;
+    let locale = routeService.getCurrentLocale(to);
     if (i18nConfig.hashMode) {
-      hashLocale = await nuxtApp.runWithContext(() => {
-        return useCookie("hash-locale").value;
+      locale = await nuxtApp.runWithContext(() => {
+        return useCookie("hash-locale", { default: () => locale }).value;
       });
     }
     if (isNoPrefixStrategy(i18nConfig.strategy)) {
-      noPrefixLocale = await nuxtApp.runWithContext(() => {
-        return useCookie("no-prefix-locale").value;
+      locale = await nuxtApp.runWithContext(() => {
+        return useCookie("no-prefix-locale", { default: () => locale }).value;
       });
     }
-    const locale = getCurrentLocale(to, i18nConfig, hashLocale, noPrefixLocale);
     if (!i18nHelper.hasGeneralTranslation(locale)) {
       const url = `/${apiBaseUrl}/general/${locale}/data.json`.replace(/\/{2,}/g, "/");
       const data = await $fetch(url, {
@@ -276,15 +81,16 @@ export default defineNuxtPlugin(async (nuxtApp) => {
       await i18nHelper.loadTranslations(locale, data ?? {});
     }
     if (!i18nConfig.disablePageLocales) {
-      const routeName = getRouteName(to, locale);
-      await loadTranslationsIfNeeded(locale, routeName, to.fullPath);
+      const locale2 = routeService.getCurrentLocale(to);
+      const routeName = routeService.getRouteName(to, locale2);
+      await loadTranslationsIfNeeded(locale2, routeName, to.fullPath);
     }
     await nuxtApp.callHook("i18n:register", (translations, selectedLocale) => {
-      const routeName = getRouteName(to, locale);
-      i18nHelper.mergeTranslation(selectedLocale ?? locale, routeName, translations, true);
+      const locale2 = routeService.getCurrentLocale(to);
+      const routeName = routeService.getRouteName(to, locale2);
+      i18nHelper.mergeTranslation(selectedLocale ?? locale2, routeName, translations, true);
     }, locale);
   }
-  const router = useRouter();
   router.beforeEach(async (to, from, next) => {
     if (to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy)) {
       await loadGlobalTranslations(to);
@@ -294,85 +100,75 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     }
   });
   await loadGlobalTranslations(router.currentRoute.value);
-  const getTranslation = (key, params, defaultValue) => {
-    if (!key) return "";
-    const route = router.currentRoute.value;
-    const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-    const routeName = getRouteName(route, locale);
-    let value = i18nHelper.getTranslation(locale, routeName, key);
-    if (!value) {
-      if (isDev && import.meta.client) {
-        console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
-      }
-      value = defaultValue || key;
-    }
-    return typeof value === "string" && params ? interpolate(value, params) : value;
-  };
-  const i18nRouteParams = useState("i18n-route-params");
-  nuxtApp.hook("page:start", () => {
-    i18nRouteParams.value = null;
-  });
   const provideData = {
     i18n: void 0,
     __micro: true,
-    getLocale: () => getCurrentLocale(router.currentRoute.value, i18nConfig, hashLocaleDefault, noPrefixDefault),
-    getLocaleName: () => getCurrentName(router.currentRoute.value, i18nConfig, hashLocaleDefault, noPrefixDefault),
+    getLocale: () => routeService.getCurrentLocale(),
+    getLocaleName: () => routeService.getCurrentName(routeService.getCurrentRoute()),
     defaultLocale: () => i18nConfig.defaultLocale,
     getLocales: () => i18nConfig.locales || [],
     getRouteName: (route, locale) => {
-      const selectedLocale = locale ?? getCurrentLocale(router.currentRoute.value, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      const selectedRoute = route ?? router.currentRoute.value;
-      return getRouteName(selectedRoute, selectedLocale);
+      const selectedLocale = locale ?? routeService.getCurrentLocale();
+      const selectedRoute = route ?? routeService.getCurrentRoute();
+      return routeService.getRouteName(selectedRoute, selectedLocale);
+    },
+    t: (key, params, defaultValue) => {
+      if (!key) return "";
+      const route = routeService.getCurrentRoute();
+      const locale = routeService.getCurrentLocale();
+      const routeName = routeService.getRouteName(route, locale);
+      let value = i18nHelper.getTranslation(locale, routeName, key);
+      if (!value) {
+        if (isDev && import.meta.client) {
+          console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
+        }
+        value = defaultValue || key;
+      }
+      return typeof value === "string" && params ? interpolate(value, params) : value;
     },
-    t: getTranslation,
     ts: (key, params, defaultValue) => {
-      const value = getTranslation(key, params, defaultValue);
+      const value = provideData.t(key, params, defaultValue);
       return value?.toString() ?? defaultValue ?? key;
     },
     tc: (key, params, defaultValue) => {
-      const route = router.currentRoute.value;
-      const currentLocale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
+      const currentLocale = routeService.getCurrentLocale();
       const { count, ..._params } = typeof params === "number" ? { count: params } : params;
-      return plural(key, Number.parseInt(count.toString()), _params, currentLocale, getTranslation) ?? defaultValue ?? key;
+      return plural(key, Number.parseInt(count.toString()), _params, currentLocale, provideData.t) ?? defaultValue ?? key;
     },
     tn: (value, options) => {
-      const route = router.currentRoute.value;
-      const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      return formatNumber(value, locale, options);
+      const currentLocale = routeService.getCurrentLocale();
+      return translationService.formatNumber(value, currentLocale, options);
     },
     td: (value, options) => {
-      const route = router.currentRoute.value;
-      const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      return formatDate(value, locale, options);
+      const currentLocale = routeService.getCurrentLocale();
+      return translationService.formatDate(value, currentLocale, options);
     },
-    tdr(value, options) {
-      const route = router.currentRoute.value;
-      const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      return formatRelativeTime(value, locale, options);
+    tdr: (value, options) => {
+      const currentLocale = routeService.getCurrentLocale();
+      return translationService.formatRelativeTime(value, currentLocale, options);
     },
     has: (key) => {
-      return !!getTranslation(key);
+      return !!provideData.t(key);
     },
     mergeTranslations: (newTranslations) => {
-      const route = router.currentRoute.value;
-      const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      const routeName = getRouteName(route, locale);
+      const route = routeService.getCurrentRoute();
+      const locale = routeService.getCurrentLocale(route);
+      const routeName = routeService.getRouteName(route, locale);
       i18nHelper.mergeTranslation(locale, routeName, newTranslations);
     },
     mergeGlobalTranslations: (newTranslations) => {
-      const route = router.currentRoute.value;
-      const locale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
+      const locale = routeService.getCurrentLocale();
       i18nHelper.mergeGlobalTranslation(locale, newTranslations, true);
     },
     switchLocaleRoute: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      return switchLocaleRoute(fromLocale, toLocale, route, router, i18nConfig, i18nRouteParams.value);
+      const route = routeService.getCurrentRoute();
+      const fromLocale = routeService.getCurrentLocale(route);
+      return routeService.switchLocaleRoute(fromLocale, toLocale, route, unref(i18nRouteParams.value));
     },
     switchLocalePath: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      const localeRoute = switchLocaleRoute(fromLocale, toLocale, route, router, i18nConfig, i18nRouteParams.value);
+      const route = routeService.getCurrentRoute();
+      const fromLocale = routeService.getCurrentLocale(route);
+      const localeRoute = routeService.switchLocaleRoute(fromLocale, toLocale, route, unref(i18nRouteParams.value));
       if (typeof localeRoute === "string") {
         return localeRoute;
       }
@@ -382,60 +178,16 @@ export default defineNuxtPlugin(async (nuxtApp) => {
       return "";
     },
     switchLocale: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      if (i18nConfig.hashMode) {
-        hashLocaleDefault = toLocale;
-        useCookie("hash-locale").value = toLocale;
-      }
-      if (isNoPrefixStrategy(i18nConfig.strategy)) {
-        noPrefixDefault = toLocale;
-        useCookie("no-prefix-locale").value = toLocale;
-      }
-      switchLocale(fromLocale, toLocale, route, router, i18nConfig, i18nRouteParams.value);
+      return routeService.switchLocaleLogic(toLocale, unref(i18nRouteParams.value));
     },
     switchRoute: (route, toLocale) => {
-      const currentRoute = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(currentRoute, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      const currentLocale = toLocale ?? fromLocale;
-      if (typeof route === "string") {
-        if (currentLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy)) {
-          const currentRoute2 = router.currentRoute.value;
-          const fromLocale2 = getCurrentLocale(currentRoute2, i18nConfig, hashLocaleDefault, noPrefixDefault);
-          route = router.resolve("/" + fromLocale2 + route);
-        } else {
-          route = router.resolve(route);
-        }
-      }
-      if (i18nConfig.hashMode && toLocale && toLocale !== fromLocale) {
-        hashLocaleDefault = toLocale ?? fromLocale;
-        useCookie("hash-locale").value = hashLocaleDefault;
-      }
-      if (isNoPrefixStrategy(i18nConfig.strategy) && toLocale && toLocale !== fromLocale) {
-        noPrefixDefault = toLocale ?? fromLocale;
-        useCookie("no-prefix-locale").value = noPrefixDefault;
-      }
-      switchLocale(fromLocale, toLocale ?? fromLocale, route, router, i18nConfig, i18nRouteParams.value);
+      return routeService.switchLocaleLogic(toLocale ?? routeService.getCurrentLocale(), unref(i18nRouteParams.value), route);
     },
     localeRoute: (to, locale) => {
-      const currentRoute = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(currentRoute, i18nConfig, hashLocaleDefault, noPrefixDefault);
-      const currentLocale = locale ?? fromLocale;
-      if (typeof to === "string") {
-        if (currentLocale !== i18nConfig.defaultLocale || withPrefixStrategy(i18nConfig.strategy)) {
-          const currentRoute2 = router.currentRoute.value;
-          const fromLocale2 = getCurrentLocale(currentRoute2, i18nConfig, hashLocaleDefault, noPrefixDefault);
-          to = router.resolve("/" + fromLocale2 + to);
-        } else {
-          to = router.resolve(to);
-        }
-      }
-      const route = router.currentRoute.value;
-      return getLocalizedRoute(to, router, route, i18nConfig, currentLocale, hashLocaleDefault, noPrefixDefault);
+      return routeService.resolveLocalizedRoute(to, locale);
     },
     localePath: (to, locale) => {
-      const route = router.currentRoute.value;
-      const localeRoute = getLocalizedRoute(to, router, route, i18nConfig, locale, hashLocaleDefault, noPrefixDefault);
+      const localeRoute = routeService.resolveLocalizedRoute(to, locale);
       if (typeof localeRoute === "string") {
         return localeRoute;
       }
@@ -453,6 +205,14 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     Object.entries(provideData).map(([key, value]) => [`$${key}`, value])
   );
   provideData.i18n = { ...provideData, ...$provideData };
+  nuxtApp.vueApp.config.globalProperties.$t = provideData.t;
+  nuxtApp.vueApp.config.globalProperties.$ts = provideData.ts;
+  nuxtApp.vueApp.config.globalProperties.$tc = provideData.tc;
+  nuxtApp.vueApp.config.globalProperties.$tn = provideData.tn;
+  nuxtApp.vueApp.config.globalProperties.$td = provideData.td;
+  nuxtApp.vueApp.config.globalProperties.$tdr = provideData.tdr;
+  nuxtApp.vueApp.config.globalProperties.$switchLocale = provideData.switchLocale;
+  nuxtApp.vueApp.config.globalProperties.$switchLocaleRoute = provideData.switchLocaleRoute;
   return {
     provide: provideData
   };

package/dist/runtime/plugins/03.define.d.ts

@@ -2,11 +2,11 @@ declare const _default: import("nuxt/app").Plugin<{
     defineI18nRoute: (routeDefinition: {
         locales?: string[] | Record<string, Record<string, string>>;
         localeRoutes?: Record<string, string>;
-    }) => Promise<void | import("vue-router").NavigationFailure>;
+    }) => Promise<void>;
 }> & import("nuxt/app").ObjectPlugin<{
     defineI18nRoute: (routeDefinition: {
         locales?: string[] | Record<string, Record<string, string>>;
         localeRoutes?: Record<string, string>;
-    }) => Promise<void | import("vue-router").NavigationFailure>;
+    }) => Promise<void>;
 }>;
 export default _default;

package/dist/runtime/plugins/03.define.js

@@ -1,7 +1,7 @@
-import { isPrefixStrategy } from "../helpers.js";
-import { defineNuxtPlugin, navigateTo, useNuxtApp, useRuntimeConfig } from "#app";
-import { useRoute, useRouter } from "#imports";
-export default defineNuxtPlugin(async (_nuxtApp) => {
+import { isNoPrefixStrategy, isPrefixStrategy } from "nuxt-i18n-micro-core";
+import { defineNuxtPlugin, navigateTo, useRuntimeConfig } from "#app";
+import { unref, useRoute, useRouter, useNuxtApp, watch, computed, onUnmounted } from "#imports";
+export default defineNuxtPlugin(async (nuxtApp) => {
   const config = useRuntimeConfig();
   const route = useRoute();
   const router = useRouter();
@@ -18,7 +18,7 @@ export default defineNuxtPlugin(async (_nuxtApp) => {
     return {};
   };
   const handleRedirect = async (to) => {
-    const currentLocale = (to.params.locale || i18nConfig.defaultLocale).toString();
+    const currentLocale = nuxtApp.$getLocale().toString();
     const { name } = to;
     let defaultRouteName = name?.toString().replace("localized-", "").replace(new RegExp(`-${currentLocale}$`), "");
     if (!to.params.locale) {
@@ -31,7 +31,9 @@ export default defineNuxtPlugin(async (_nuxtApp) => {
         return;
       }
       const newParams = { ...to.params };
-      newParams.locale = i18nConfig.defaultLocale;
+      if (!isNoPrefixStrategy(i18nConfig.strategy)) {
+        newParams.locale = i18nConfig.defaultLocale;
+      }
       return navigateTo({ name: defaultRouteName, params: newParams }, { redirectCode: 301, external: true });
     }
   };
@@ -49,33 +51,31 @@ export default defineNuxtPlugin(async (_nuxtApp) => {
     }
   });
   const defineI18nRoute = async (routeDefinition) => {
-    const currentLocale = (route.params.locale || i18nConfig.defaultLocale).toString();
+    const { $getLocale } = useNuxtApp();
+    let currentLocale = computed(() => $getLocale());
     const normalizedLocales = normalizeLocales(routeDefinition.locales);
-    if (Object.values(normalizedLocales).length) {
-      if (normalizedLocales[currentLocale]) {
-        const translation = normalizedLocales[currentLocale];
-        const { $mergeGlobalTranslations } = useNuxtApp();
-        $mergeGlobalTranslations(translation);
-      }
-      if (!normalizedLocales[currentLocale]) {
-        let defaultRouteName = route.name?.toString().replace("localized-", "").replace(new RegExp(`-${currentLocale}$`), "");
-        const resolvedRoute = router.resolve({ name: defaultRouteName });
-        const newParams = { ...route.params };
-        delete newParams.locale;
-        if (isPrefixStrategy(i18nConfig.strategy)) {
-          if (router.hasRoute(`localized-${defaultRouteName}-${currentLocale}`)) {
-            defaultRouteName = `localized-${defaultRouteName}-${currentLocale}`;
-          } else {
-            defaultRouteName = `localized-${defaultRouteName}`;
+    const updateTranslations = () => {
+      const currentLocaleValue = unref(currentLocale);
+      if (currentLocaleValue && Object.values(normalizedLocales).length) {
+        if (normalizedLocales[currentLocaleValue]) {
+          const translation = normalizedLocales[currentLocaleValue];
+          const { $mergeGlobalTranslations } = useNuxtApp();
+          if ($mergeGlobalTranslations) {
+            $mergeGlobalTranslations(translation);
           }
-          if (!router.hasRoute(defaultRouteName)) {
-            return;
-          }
-          newParams.locale = i18nConfig.defaultLocale;
-          newParams.name = defaultRouteName;
         }
-        return router.push(resolvedRoute);
       }
+    };
+    updateTranslations();
+    if (import.meta.client) {
+      let stopWatcher = watch(currentLocale, updateTranslations);
+      onUnmounted(() => {
+        if (stopWatcher) {
+          stopWatcher();
+          currentLocale = null;
+          stopWatcher = null;
+        }
+      });
     }
   };
   return {

package/dist/runtime/plugins/04.auto-detect.js

@@ -1,4 +1,4 @@
-import { isPrefixStrategy, isNoPrefixStrategy } from "../helpers.js";
+import { isPrefixStrategy, isNoPrefixStrategy } from "nuxt-i18n-micro-core";
 import { defineNuxtPlugin, useCookie, useRequestHeaders, navigateTo } from "#app";
 import { useRoute, useRouter } from "#imports";
 const parseAcceptLanguage = (acceptLanguage) => acceptLanguage.split(",").map((entry) => entry.split(";")[0].trim());
@@ -42,8 +42,10 @@ export default defineNuxtPlugin(async (nuxtApp) => {
     const newRouteName = isPrefixStrategy(i18nConfig.strategy) || newLocale !== defaultLocale ? `localized-${routeName}` : routeName;
     const newParams = { ...route.params };
     delete newParams.locale;
-    if (isPrefixStrategy(i18nConfig.strategy) || newLocale !== defaultLocale) {
-      newParams.locale = newLocale;
+    if (!isNoPrefixStrategy(i18nConfig.strategy)) {
+      if (isPrefixStrategy(i18nConfig.strategy) || newLocale !== defaultLocale) {
+        newParams.locale = newLocale;
+      }
     }
     const newRoute = router.resolve({
       name: newRouteName,

package/dist/runtime/translation-server-middleware.d.ts

@@ -1,3 +1,3 @@
 import type { H3Event } from 'h3';
-import type { Params } from '../types.js';
+import type { Params } from 'nuxt-i18n-micro-types';
 export declare const useTranslationServerMiddleware: (event: H3Event, defaultLocale?: string, currentLocale?: string) => Promise<(key: string, params?: Params, defaultValue?: string) => string>;

package/dist/types.d.mts

@@ -4,4 +4,4 @@ declare module '@nuxt/schema' {
   interface NuxtHooks extends ModuleHooks {}
 }
 
-export { type Getter, type GlobalLocaleRoutes, type Locale, type LocaleCode, type PluralFunc } from './module.js'
+export { type Getter, type GlobalLocaleRoutes, type Locale, type LocaleCode, type ModuleOptions, type PluralFunc, type Strategies } from './module.js'

package/dist/types.d.ts

@@ -4,4 +4,4 @@ declare module '@nuxt/schema' {
   interface NuxtHooks extends ModuleHooks {}
 }
 
-export { type Getter, type GlobalLocaleRoutes, type Locale, type LocaleCode, type PluralFunc } from './module'
+export { type Getter, type GlobalLocaleRoutes, type Locale, type LocaleCode, type ModuleOptions, type PluralFunc, type Strategies } from './module'

package/dist/utils.d.mts

@@ -1,5 +1,5 @@
 import { NuxtPage } from '@nuxt/schema';
-import { L as LocaleCode, a as Locale } from './shared/nuxt-i18n-micro.4b19b717.mjs';
+import { LocaleCode, Locale } from 'nuxt-i18n-micro-types';
 
 declare function extractLocaleRoutes(content: string, filePath: string): Record<string, string> | null;
 declare function validateDefineI18nRouteConfig(obj: Record<LocaleCode, Record<string, string>>): boolean;
@@ -11,5 +11,6 @@ declare const buildRouteName: (baseName: string, localeCode: string, isCustom: b
 declare const shouldAddLocalePrefix: (locale: string, defaultLocale: Locale, addLocalePrefix: boolean, includeDefaultLocaleRoute: boolean) => boolean;
 declare const isLocaleDefault: (locale: string | Locale, defaultLocale: Locale, includeDefaultLocaleRoute: boolean) => boolean;
 declare const buildFullPath: (locale: string | string[], basePath: string, customRegex?: string | RegExp) => string;
+declare const buildFullPathNoPrefix: (basePath: string) => string;
 
-export { buildFullPath, buildRouteName, cloneArray, extractLocaleRoutes, isLocaleDefault, isPageRedirectOnly, normalizePath, removeLeadingSlash, shouldAddLocalePrefix, validateDefineI18nRouteConfig };
+export { buildFullPath, buildFullPathNoPrefix, buildRouteName, cloneArray, extractLocaleRoutes, isLocaleDefault, isPageRedirectOnly, normalizePath, removeLeadingSlash, shouldAddLocalePrefix, validateDefineI18nRouteConfig };