nuxt-i18n-micro 3.18.3 → 3.20.0

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

@@ -1,25 +1,13 @@
-import { FormatService, isNoPrefixStrategy } from "@i18n-micro/core";
-import { shallowRef, triggerRef, unref } from "vue";
+import { isNoPrefixStrategy } from "@i18n-micro/core";
+import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
 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 { deepMergeTranslations } from "../utils/deep-merge.js";
-import { resolveI18nConfigWithRuntimeOverrides } from "../utils/runtime-i18n-config.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,100 +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,
-    dateBuild: i18nConfig.dateBuild
-  };
-  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);
+    apiBaseClientHost: i18nConfig.apiBaseClientHost,
+    dateBuild: i18nConfig.dateBuild,
+    routesLocaleLinks: i18nConfig.routesLocaleLinks
   };
+  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,
@@ -149,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) {
@@ -188,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/02.meta.js

@@ -1,9 +1,9 @@
+import { isMetaDisabledForRoute } from "@i18n-micro/utils/route";
+import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
 import { watch } from "vue";
 import { getI18nConfig } from "#build/i18n.strategy.mjs";
 import { defineNuxtPlugin, useHead, useRequestURL, useRoute } from "#imports";
 import { useLocaleHead } from "../composables/useLocaleHead.js";
-import { isMetaDisabledForRoute } from "../utils/route-utils.js";
-import { resolveI18nConfigWithRuntimeOverrides } from "../utils/runtime-i18n-config.js";
 export default defineNuxtPlugin((nuxtApp) => {
   const route = useRoute();
   const getRuntimeConfig = nuxtApp.$getI18nConfig;

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

@@ -1,45 +1,45 @@
 import { isNoPrefixStrategy } from "@i18n-micro/core";
+import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
 import { getI18nConfig } from "#build/i18n.strategy.mjs";
 import { defineNuxtPlugin, useNuxtApp, useRouter } from "#imports";
-import { resolveI18nConfigWithRuntimeOverrides } from "../utils/runtime-i18n-config.js";
 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;

package/dist/runtime/plugins/06.redirect.js

@@ -1,58 +1,26 @@
+import { isInternalPath } from "@i18n-micro/route-strategy";
+import { getEnabledLocaleCodes } from "@i18n-micro/utils/active-locales";
+import { getLocaleCookieName, getLocaleCookieOptions } from "@i18n-micro/utils/cookie";
+import { resolvePreferredLocale } from "@i18n-micro/utils/resolve-locale";
 import { getCookie, getHeader, getRequestURL, setCookie } from "h3";
-import { createI18nStrategy, getI18nConfig } from "#build/i18n.strategy.mjs";
-import { createError, defineNuxtPlugin, navigateTo, useRequestEvent, useRoute, useRouter, useState } from "#imports";
-import { useI18nLocale } from "../composables/useI18nLocale.js";
-import { getEnabledLocaleCodes } from "../utils/active-locales.js";
-import { getLocaleCookieName, getLocaleCookieOptions } from "../utils/cookie.js";
-import { resolvePreferredLocale } from "../utils/resolve-server-locale.js";
-import { resolveI18nConfigWithRuntimeOverrides } from "../utils/runtime-i18n-config.js";
+import { createError, defineNuxtPlugin, navigateTo, useRequestEvent, useState } from "#imports";
 const DEBUG = process.env.NUXT_I18N_DEBUG_REDIRECT === "1";
-const DEFAULT_STATIC_PATTERNS = [
-  /^\/sitemap.*\.xml$/,
-  /^\/sitemap\.xml$/,
-  /^\/robots\.txt$/,
-  /^\/favicon\.ico$/,
-  /^\/apple-touch-icon.*\.png$/,
-  /^\/manifest\.json$/,
-  /^\/sw\.js$/,
-  /^\/workbox-.*\.js$/,
-  /\.(xml|txt|ico|json|js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/
-];
-function isInternalPath(path, excludePatterns) {
-  if (/(?:^|\/)__[^/]+/.test(path)) {
-    return true;
+function resolveI18nStrategy(nuxtApp) {
+  if (nuxtApp.$i18nStrategy) {
+    return nuxtApp.$i18nStrategy;
   }
-  for (const pattern of DEFAULT_STATIC_PATTERNS) {
-    if (pattern.test(path)) {
-      return true;
-    }
-  }
-  if (excludePatterns) {
-    for (const pattern of excludePatterns) {
-      if (typeof pattern === "string") {
-        if (pattern.includes("*") || pattern.includes("?")) {
-          const regex = new RegExp(pattern.replace(/\*/g, ".*").replace(/\?/g, "."));
-          if (regex.test(path)) return true;
-        } else if (path === pattern || path.startsWith(pattern)) {
-          return true;
-        }
-      } else if (pattern instanceof RegExp) {
-        if (pattern.test(path)) return true;
-      }
-    }
-  }
-  return false;
+  throw new Error("[nuxt-i18n-micro] i18n redirect plugin requires the main i18n plugin ($i18nStrategy).");
 }
 export default defineNuxtPlugin({
   name: "i18n-redirect",
-  enforce: "pre",
+  dependsOn: ["i18n-plugin-loader"],
   setup(nuxtApp) {
-    const router = useRouter();
-    const i18nStrategy = createI18nStrategy(router);
+    const i18nStrategy = resolveI18nStrategy(nuxtApp);
     const getRuntimeConfig = nuxtApp.$getI18nConfig;
-    const i18nConfig = resolveI18nConfigWithRuntimeOverrides(
-      typeof getRuntimeConfig === "function" ? getRuntimeConfig() : getI18nConfig()
-    );
+    if (typeof getRuntimeConfig !== "function") {
+      throw new Error("[nuxt-i18n-micro] i18n redirect plugin requires $getI18nConfig from the main i18n plugin.");
+    }
+    const i18nConfig = getRuntimeConfig();
     const validLocales = getEnabledLocaleCodes(i18nConfig.locales);
     const defaultLocale = i18nConfig.defaultLocale || "en";
     const autoDetectPath = i18nConfig.autoDetectPath || "/";
@@ -137,44 +105,5 @@ export default defineNuxtPlugin({
         }
       }
     }
-    if (import.meta.client && i18nConfig.redirects !== false) {
-      const runRedirect = () => {
-        const { getPreferredLocale } = useI18nLocale();
-        let preferredLocale = getPreferredLocale();
-        if (!preferredLocale) return;
-        const route = useRoute();
-        const path = route.path || "/";
-        const pathSegments = path.replace(/^\//, "").split("/").filter(Boolean);
-        const firstSegment = pathSegments[0];
-        const hasLocalePrefix = Boolean(firstSegment && validLocales.includes(firstSegment));
-        if (autoDetectPath === "*" && !hasLocalePrefix) {
-          preferredLocale = defaultLocale;
-        }
-        if (autoDetectPath === "*" && hasLocalePrefix && firstSegment !== preferredLocale) {
-          const rest = pathSegments.slice(1).join("/");
-          let targetPath;
-          if (preferredLocale === defaultLocale && i18nConfig.strategy === "prefix_except_default") {
-            targetPath = rest ? `/${rest}` : "/";
-          } else {
-            targetPath = rest ? `/${preferredLocale}/${rest}` : `/${preferredLocale}`;
-          }
-          navigateTo(targetPath, { replace: true, redirectCode: 302 });
-          return;
-        }
-        const redirectPath = i18nStrategy.getClientRedirect(path, preferredLocale);
-        if (redirectPath) {
-          navigateTo(redirectPath, { replace: true, redirectCode: 302 });
-        }
-      };
-      nuxtApp.hook("app:mounted", () => {
-        runRedirect();
-      });
-      router.afterEach((to, from) => {
-        if (to.path === from.path) return;
-        setTimeout(() => {
-          runRedirect();
-        }, 0);
-      });
-    }
   }
 });