nuxt-i18n-micro 3.30.2 → 4.0.0

package/dist/runtime/composables/useLocaleHead.js

@@ -1,10 +1,11 @@
 import { isNoPrefixStrategy } from "@i18n-micro/core";
-import { resolveHreflangAlternates } from "@i18n-micro/utils/resolve-hreflang";
-import { findAllowedLocalesForRoute, isMetaDisabledForRoute } from "@i18n-micro/utils/route";
-import { resolveOgLocale, warnUnresolvedOgLocale } from "@i18n-micro/utils/resolve-og-locale";
-import { joinURL, parseURL, withQuery } from "ufo";
+import { buildLocaleHead, filterQuery } from "@i18n-micro/utils/locale-head";
+import { joinURL } from "ufo";
 import { ref, unref, watch } from "vue";
-import { useNuxtApp, useRoute, useState } from "#app";
+import { useError } from "#app/composables/error";
+import { useRoute } from "#app/composables/router";
+import { useState } from "#app/composables/state";
+import { useNuxtApp } from "#app/nuxt";
 import { applyTrailingSlash } from "../utils/trailing-slash.js";
 export const useLocaleHead = ({
   addDirAttribute = true,
@@ -15,181 +16,60 @@ export const useLocaleHead = ({
 } = {}) => {
   const nuxtApp = useNuxtApp();
   const route = useRoute();
-  const metaObject = ref({
-    htmlAttrs: {},
-    link: [],
-    meta: []
-  });
-  function filterQuery(fullPath, whitelist) {
-    const { pathname, search } = parseURL(fullPath);
-    const params = new URLSearchParams(search);
-    const filtered = {};
-    for (const key of whitelist) {
-      if (params.has(key)) {
-        filtered[key] = params.get(key);
-      }
-    }
-    return withQuery(pathname, filtered);
-  }
-  function filterLocalizedHref(pathOrUrl, whitelist) {
-    if (!pathOrUrl) return "";
-    const parsed = parseURL(pathOrUrl);
-    const filteredPath = filterQuery(pathOrUrl, whitelist);
-    if (parsed.protocol && parsed.host) {
-      return `${parsed.protocol}//${parsed.host}${filteredPath}`;
-    }
-    return filteredPath;
-  }
-  function clearMeta() {
-    metaObject.value = { htmlAttrs: {}, link: [], meta: [] };
-  }
-  function updateMeta() {
-    if (route.matched.length === 0 || route.matched.some((record) => record.name === "custom-fallback-route")) {
-      clearMeta();
-      return;
-    }
+  const error = useError();
+  const empty = () => ({ htmlAttrs: {}, link: [], meta: [] });
+  const metaObject = ref(empty());
+  function build() {
     const i18nConfig = nuxtApp.$getI18nConfig();
-    const { canonicalQueryWhitelist, routeLocales, localizedRouteNamePrefix } = i18nConfig;
-    const strategy = i18nConfig.strategy;
-    const localizedRouteNamePrefixResolved = localizedRouteNamePrefix || "localized-";
-    const { $getLocales, $getLocale, $switchLocalePath } = nuxtApp;
-    const allLocales = ($getLocales ? unref($getLocales()) : i18nConfig.locales) ?? [];
-    const firstSegment = route.path.replace(/^\//, "").split("/").filter(Boolean)[0];
-    const fallbackLocale = allLocales.find((loc) => loc.code === firstSegment)?.code || i18nConfig.defaultLocale || "en";
-    const locale = ($getLocale ? unref($getLocale()) : fallbackLocale) || fallbackLocale;
+    const { canonicalQueryWhitelist, strategy, trailingSlash } = i18nConfig;
+    const { $getLocale, $switchLocalePath } = nuxtApp;
+    const i18nStrategy = nuxtApp.$i18nStrategy;
+    const allLocales = nuxtApp.$getLocales();
+    const locale = $getLocale() || i18nConfig.defaultLocale;
     const currentLocale = allLocales.find((loc) => loc.code === locale);
-    if (!currentLocale || isMetaDisabledForRoute(route, i18nConfig.routeDisableMeta, locale, localizedRouteNamePrefixResolved)) {
-      clearMeta();
-      return;
-    }
-    const switchLocalePath = $switchLocalePath || (() => "");
-    const routeName = (route.name ?? "").toString();
-    const currentRouteLocales = findAllowedLocalesForRoute(route, routeLocales, localizedRouteNamePrefixResolved);
+    if (!currentLocale) return empty();
+    const metaDisabled = i18nStrategy.isMetaDisabled(route, locale);
+    const pageLocales = i18nStrategy.pageLocales(route);
     const enabledLocales = allLocales.filter((loc) => !loc.disabled);
-    const locales = currentRouteLocales ? enabledLocales.filter((loc) => currentRouteLocales.includes(loc.code)) : enabledLocales;
-    const currentIso = currentLocale.iso || locale;
-    const currentOg = resolveOgLocale(currentLocale);
-    const missingWarn = i18nConfig.missingWarn ?? true;
-    const currentDir = currentLocale.dir || "auto";
-    let fullPath = unref(route.fullPath);
-    if (!fullPath.startsWith("/")) {
-      fullPath = `/${fullPath}`;
-    }
-    const whitelist = canonicalQueryWhitelist ?? [];
-    const trailingSlash = i18nConfig.trailingSlash;
+    const locales = pageLocales ? enabledLocales.filter((loc) => pageLocales.includes(loc.code)) : [];
     const toSeoHref = (pathOrUrl) => {
       if (!pathOrUrl) return "";
-      let href;
-      if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-        href = filterLocalizedHref(pathOrUrl, whitelist);
-      } else {
-        const filteredPath = filterLocalizedHref(pathOrUrl, whitelist);
-        href = joinURL(unref(baseUrl), filteredPath.startsWith("/") ? filteredPath : `/${filteredPath}`);
-      }
-      return applyTrailingSlash(href, trailingSlash);
-    };
-    const currentSwitchedPath = switchLocalePath(locale);
-    let ogUrl;
-    if (currentSwitchedPath) {
-      ogUrl = toSeoHref(currentSwitchedPath);
-    } else {
-      const matchedLocale = [...locales].sort((a, b) => b.code.length - a.code.length).find((localeItem) => fullPath.startsWith(`/${localeItem.code}`));
-      let localizedPath = fullPath;
-      if (routeName.startsWith(localizedRouteNamePrefixResolved) && matchedLocale) {
-        localizedPath = fullPath.slice(matchedLocale.code.length + 1);
-        ogUrl = applyTrailingSlash(joinURL(unref(baseUrl), locale, filterQuery(localizedPath, whitelist)), trailingSlash);
-      } else {
-        ogUrl = applyTrailingSlash(joinURL(unref(baseUrl), filterQuery(fullPath, whitelist)), trailingSlash);
-      }
-    }
-    const htmlAttrs = {
-      lang: currentIso,
-      ...addDirAttribute ? { dir: currentDir } : {}
+      const filtered = filterQuery(pathOrUrl, canonicalQueryWhitelist);
+      const absolute = filtered.startsWith("http://") || filtered.startsWith("https://");
+      return applyTrailingSlash(absolute ? filtered : joinURL(unref(baseUrl), filtered.startsWith("/") ? filtered : `/${filtered}`), trailingSlash);
     };
-    if (!addSeoAttributes) {
-      metaObject.value = { htmlAttrs, link: [], meta: [] };
-      return;
-    }
-    const localesForSeo = locales.filter((loc) => loc.seo !== false);
-    if (!currentOg) {
-      warnUnresolvedOgLocale(currentLocale, { missingWarn, tag: "og:locale" });
-    }
-    const ogLocaleMeta = currentOg ? {
-      [identifierAttribute]: "i18n-og",
-      property: "og:locale",
-      content: currentOg
-    } : null;
-    const ogUrlMeta = {
-      [identifierAttribute]: "i18n-og-url",
-      property: "og:url",
-      content: ogUrl
-    };
-    const alternateOgLocalesMeta = localesForSeo.filter((loc) => loc.code !== locale).map((loc) => {
-      const ogAlt = resolveOgLocale(loc);
-      if (!ogAlt) {
-        warnUnresolvedOgLocale(loc, { missingWarn, tag: "og:locale:alternate" });
-        return null;
-      }
-      return {
-        [identifierAttribute]: `i18n-og-alt-${ogAlt}`,
-        property: "og:locale:alternate",
-        content: ogAlt
-      };
-    }).filter((meta) => meta !== null);
-    const canonicalLink = {
-      [identifierAttribute]: "i18n-can",
-      rel: "canonical",
-      href: ogUrl
-    };
-    const defaultLocale = i18nConfig.defaultLocale || "en";
+    const hrefOf = (code) => toSeoHref($switchLocalePath(code));
+    const defaultLocale = i18nConfig.linkDefaultLocale ?? i18nConfig.defaultLocale;
     const defaultLocaleObj = allLocales.find((loc) => loc.code === defaultLocale);
-    const alternateLinks = isNoPrefixStrategy(strategy) ? [] : (() => {
-      const hrefByCode = /* @__PURE__ */ new Map();
-      for (const loc of localesForSeo) {
-        const switchedPath = switchLocalePath(loc.code);
-        if (!switchedPath) continue;
-        hrefByCode.set(String(loc.code), toSeoHref(switchedPath));
-      }
-      return resolveHreflangAlternates(localesForSeo, {
-        hreflangBaseLanguage: i18nConfig.hreflangBaseLanguage ?? false
-      }).flatMap(({ hreflang, localeCode }) => {
-        const href = hrefByCode.get(localeCode);
-        if (!href) return [];
-        return [
-          {
-            [identifierAttribute]: `i18n-alternate-${hreflang}`,
-            rel: "alternate",
-            href,
-            hreflang
-          }
-        ];
-      });
-    })();
-    let xDefaultLink = null;
-    if (!isNoPrefixStrategy(strategy) && defaultLocaleObj?.seo !== false) {
-      const defaultSwitchedPath = switchLocalePath(defaultLocale);
-      if (defaultSwitchedPath) {
-        xDefaultLink = {
-          [identifierAttribute]: "i18n-xd",
-          rel: "alternate",
-          href: toSeoHref(defaultSwitchedPath),
-          hreflang: "x-default"
-        };
-      }
-    }
-    metaObject.value = {
-      htmlAttrs,
-      meta: [...ogLocaleMeta ? [ogLocaleMeta] : [], ogUrlMeta, ...alternateOgLocalesMeta],
-      link: [canonicalLink, ...alternateLinks, ...xDefaultLink ? [xDefaultLink] : []]
-    };
+    const noPrefix = isNoPrefixStrategy(strategy);
+    const hasXDefault = !noPrefix && defaultLocaleObj?.seo !== false && pageLocales?.includes(defaultLocale);
+    return buildLocaleHead({
+      locale: currentLocale,
+      // omit `seo: false`
+      seoLocales: locales.filter((loc) => loc.seo !== false),
+      hrefOf,
+      // canonical / og:url share `$switchLocalePath` with hreflang (incl. NuxtLink trailingSlash)
+      canonical: toSeoHref($switchLocalePath(locale) || route.fullPath),
+      xDefault: hasXDefault ? hrefOf(defaultLocale) : void 0,
+      alternates: !noPrefix,
+      addDirAttribute,
+      // 404 routes and disableMeta keep the language, but must not emit SEO tags: a 404 the module answers has a matched record
+      addSeoAttributes: addSeoAttributes && !metaDisabled && route.matched.length > 0 && !error.value,
+      identifierAttribute,
+      hreflangBaseLanguage: i18nConfig.hreflangBaseLanguage,
+      missingWarn: i18nConfig.missingWarn
+    });
+  }
+  function updateMeta() {
+    metaObject.value = build();
   }
   if (autoUpdate) {
     const localeState = useState("i18n-locale", () => null);
     watch(
-      () => [route.fullPath, route.name, route.matched.length, localeState.value],
+      () => [route.fullPath, route.name, route.matched.length, localeState.value, error.value],
       () => updateMeta(),
       { immediate: true }
     );
   }
-  return { metaObject, updateMeta };
+  return { metaObject, updateMeta, build };
 };

package/dist/runtime/devtools/bridge.d.ts

@@ -1,10 +1,10 @@
-import type { ModuleOptionsExtend } from '@i18n-micro/types';
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
 import type { Ref } from 'vue';
 import type { NuxtI18n } from '../utils/nuxt-i18n.js';
 export declare const I18N_DEVTOOLS_BRIDGE_KEY = "i18n-micro-devtools-bridge";
 export interface I18nDevtoolsBridge {
     i18n: NuxtI18n;
-    i18nConfig: ModuleOptionsExtend;
+    i18nConfig: ResolvedI18nConfig;
     localeState: Ref<string | null>;
 }
 export declare function setI18nDevtoolsBridge(value: I18nDevtoolsBridge | null): void;

package/dist/runtime/devtools/vue-devtools.d.ts

@@ -1,10 +1,10 @@
-import type { ModuleOptionsExtend } from '@i18n-micro/types';
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
 import type { App } from 'vue';
 import type { I18nContextChangeReason, NuxtI18n } from '../utils/nuxt-i18n.js';
 export interface VueI18nDevtoolsContext {
     app: App;
     i18n: NuxtI18n;
-    i18nConfig: ModuleOptionsExtend;
+    i18nConfig: ResolvedI18nConfig;
     onContextChange: (listener: (reason: I18nContextChangeReason) => void) => () => void;
     onMissingKey: (listener: (locale: string, key: string, routeName: string) => void) => () => void;
 }

package/dist/runtime/devtools/vue-devtools.js

@@ -22,7 +22,7 @@ function toInspectorState(snapshot) {
 }
 function createSnapshot(i18n, i18nConfig) {
   return {
-    locale: i18n.getCurrentLocale(),
+    locale: i18n.getLocale(),
     routeName: i18n.getCurrentRouteName() || "index",
     strategy: i18nConfig.strategy,
     defaultLocale: i18nConfig.defaultLocale,
@@ -61,7 +61,7 @@ function buildNodeState(i18n, i18nConfig, nodeId) {
         { key: "code", value: locale },
         { key: "displayName", value: configured?.displayName ?? locale },
         { key: "disabled", value: Boolean(configured?.disabled) },
-        { key: "isActive", value: i18n.getCurrentLocale() === locale },
+        { key: "isActive", value: i18n.getLocale() === locale },
         { key: "loadedChunks", value: chunks.length }
       ],
       Chunks: chunks.length ? chunks : [{ key: "\u2014", value: "No translation chunks loaded for this locale yet" }]
@@ -86,7 +86,7 @@ function buildNodeState(i18n, i18nConfig, nodeId) {
         { key: "keys", value: countTranslationKeys(chunk) },
         {
           key: "isActive",
-          value: i18n.getCurrentLocale() === parsed.locale && (i18n.getCurrentRouteName() || "index") === routeName
+          value: i18n.getLocale() === parsed.locale && (i18n.getCurrentRouteName() || "index") === routeName
         }
       ],
       Translations: entries.length ? entries : [{ key: "\u2014", value: "Chunk is loaded but empty" }]
@@ -96,7 +96,7 @@ function buildNodeState(i18n, i18nConfig, nodeId) {
     const routeName = parsed.routeName || "index";
     const segments = parsed.segments ?? [];
     const chunk = i18n.storage.translations.get(`${parsed.locale}:${routeName}`);
-    const isActive = i18n.getCurrentLocale() === parsed.locale && (i18n.getCurrentRouteName() || "index") === routeName;
+    const isActive = i18n.getLocale() === parsed.locale && (i18n.getCurrentRouteName() || "index") === routeName;
     const source = isActive ? i18n.resolveTranslations() : chunk ?? {};
     const value = segments.length ? getByInspectorPath(source, segments) : source;
     if (isPlainObject(value)) {
@@ -186,7 +186,7 @@ export async function setupVueI18nDevtools(ctx) {
             nodeId: "root",
             storage: ctx.i18n.storage,
             configuredLocales: ctx.i18nConfig.locales ?? [],
-            activeLocale: ctx.i18n.getCurrentLocale(),
+            activeLocale: ctx.i18n.getLocale(),
             activeRouteName: ctx.i18n.getCurrentRouteName() || "index",
             activeTranslations: ctx.i18n.resolveTranslations()
           });

package/dist/runtime/middleware/i18n-redirect.global.d.ts

@@ -1,6 +1,7 @@
 /**
- * Client-side locale redirect middleware.
- * Replaces setTimeout-based afterEach redirects from the legacy redirect plugin.
+ * Client-side locale redirects (SPA navigations). The decision is the strategy's
+ * (`getClientRedirect`); preferences are read from the locale state and the cookie the main
+ * plugin keeps, without creating cookie refs per navigation.
  */
 declare const _default: import("nuxt/app").RouteMiddleware;
 export default _default;

package/dist/runtime/middleware/i18n-redirect.global.js

@@ -1,50 +1,39 @@
 import { getEnabledLocaleCodes } from "@i18n-micro/utils/active-locales";
 import { isInternalPath } from "@i18n-micro/utils/app-path";
-import { shouldAttemptLocaleRedirect } from "@i18n-micro/utils/auto-detect-path";
-import { defineNuxtRouteMiddleware, navigateTo, useNuxtApp } from "#imports";
-import { useI18nLocale } from "../composables/useI18nLocale.js";
-function redirectTo(path, to) {
-  return navigateTo({ path, query: to.query, hash: to.hash }, { replace: true, redirectCode: 302 });
+import { decodeCookieValue, getPreferenceCookieName } from "@i18n-micro/utils/cookie";
+import { redirectLocale } from "@i18n-micro/utils/resolve-locale";
+import { applyTrailingSlash } from "../utils/trailing-slash.js";
+import { defineNuxtRouteMiddleware, navigateTo, useNuxtApp, useState } from "#imports";
+function readCookie(name) {
+  if (!name) return null;
+  const prefix = `${encodeURIComponent(name)}=`;
+  const entry = document.cookie.split("; ").find((part) => part.startsWith(prefix));
+  return entry ? decodeCookieValue(entry.slice(prefix.length)) : null;
 }
 export default defineNuxtRouteMiddleware((to, from) => {
   if (import.meta.server) return;
   const nuxtApp = useNuxtApp();
-  const getRuntimeConfig = nuxtApp.$getI18nConfig;
-  const i18nStrategy = nuxtApp.$i18nStrategy;
-  if (typeof getRuntimeConfig !== "function" || !i18nStrategy) return;
+  const { $getI18nConfig: getRuntimeConfig, $i18nStrategy: i18nStrategy } = nuxtApp;
   const i18nConfig = getRuntimeConfig();
-  if (i18nConfig.redirects === false) return;
-  if (to.path === from.path) return;
-  if (isInternalPath(to.path, i18nConfig.excludePatterns)) return;
-  const validLocales = getEnabledLocaleCodes(i18nConfig.locales);
-  const defaultLocale = i18nConfig.defaultLocale || "en";
-  const autoDetectPath = i18nConfig.autoDetectPath || "/";
-  const { getPreferredLocale } = useI18nLocale();
-  const routeLocale = i18nStrategy.getCurrentLocale(to, getPreferredLocale());
-  let preferredLocale = routeLocale || getPreferredLocale() || defaultLocale;
+  const samePage = to.path === from.path && nuxtApp.payload.serverRendered;
+  if (i18nConfig.redirects === false || samePage || isInternalPath(to.path, i18nConfig.excludePatterns, i18nConfig.apiBaseUrl)) return;
+  const defaultLocale = i18nConfig.defaultLocale;
+  const autoDetectPath = i18nConfig.autoDetectPath;
+  const anyPath = autoDetectPath === "*";
   const path = to.path || "/";
-  const pathSegments = path.replace(/^\//, "").split("/").filter(Boolean);
-  const firstSegment = pathSegments[0];
-  const hasLocalePrefix = Boolean(firstSegment && validLocales.includes(firstSegment));
-  const allowPreferenceRedirect = shouldAttemptLocaleRedirect(path, { autoDetectPath, hasLocalePrefix });
-  if (!hasLocalePrefix && !allowPreferenceRedirect) {
-    preferredLocale = defaultLocale;
-  }
-  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}`;
-    }
-    return redirectTo(targetPath, to);
-  }
-  const redirectPath = i18nStrategy.getClientRedirect(path, preferredLocale);
-  if (redirectPath) {
-    return redirectTo(redirectPath, to);
-  }
+  const urlLocale = i18nStrategy.getLocaleFromPath(path);
+  if (urlLocale && !anyPath) return;
+  const preference = redirectLocale({
+    path,
+    urlLocale,
+    autoDetectPath,
+    alwaysPrefixed: i18nConfig.strategy === "prefix",
+    defaultLocale,
+    validLocales: getEnabledLocaleCodes(i18nConfig.locales),
+    state: useState("i18n-locale", () => null).value,
+    cookie: readCookie(getPreferenceCookieName(i18nConfig))
+  });
+  const preferred = i18nStrategy.getCurrentLocale(to, preference);
+  const target = i18nStrategy.getClientRedirect(path, preferred, { switchPrefixed: anyPath });
+  if (target) return navigateTo({ path: applyTrailingSlash(target, i18nConfig.trailingSlash), query: to.query, hash: to.hash }, { redirectCode: 302 });
 });