nuxt-i18n-micro 1.98.0 → 1.100.0

package/dist/module.mjs

@@ -149,26 +149,23 @@ function extractDefineI18nRouteData(content, filePath) {
       if (localesStrTrimmed.startsWith("[") && localesStrTrimmed.endsWith("]")) {
         const arrayMatch = localesStrTrimmed.match(/\[(.*?)\]/s);
         if (arrayMatch && arrayMatch[1]) {
-          const elements = arrayMatch[1].split(",").map((el) => el.trim().replace(/['"]/g, "")).filter((el) => el.length > 0);
-          locales = elements;
+          locales = arrayMatch[1].split(",").map((el) => el.trim().replace(/['"]/g, "")).filter((el) => el.length > 0);
         }
       }
       if (localesStrTrimmed.startsWith("{") && localesStrTrimmed.endsWith("}")) {
-        const topLevelKeyMatches = localesStrTrimmed.match(/^\s*(\w+)\s*:\s*\{/gm);
+        const topLevelKeyMatches = localesStrTrimmed.match(/^\s*(\[?['"]?([\w-]+)['"]?\]?)\s*:\s*\{/gm);
         if (topLevelKeyMatches) {
-          const keys = topLevelKeyMatches.map((match) => {
-            const keyMatch = match.match(/^\s*(\w+)\s*:/);
+          locales = topLevelKeyMatches.map((match) => {
+            const keyMatch = match.match(/^\s*\[?['"]?([\w-]+)['"]?\]?\s*:/);
             return keyMatch ? keyMatch[1] : "";
           }).filter((key) => key.length > 0);
-          locales = keys;
         } else {
-          const fallbackMatches = localesStrTrimmed.match(/(\w+)\s*:\s*\{/g);
+          const fallbackMatches = localesStrTrimmed.match(/(\[?['"]?([\w-]+)['"]?\]?)\s*:\s*\{/g);
           if (fallbackMatches) {
-            const keys = fallbackMatches.map((match) => {
-              const keyMatch = match.match(/(\w+)\s*:/);
+            locales = fallbackMatches.map((match) => {
+              const keyMatch = match.match(/(\[?['"]?([\w-]+)['"]?\]?)\s*:/);
               return keyMatch ? keyMatch[1] : "";
             }).filter((key) => key.length > 0);
-            locales = keys;
           }
         }
       }
@@ -240,9 +237,10 @@ class PageManager {
   activeLocaleCodes;
   globalLocaleRoutes;
   filesLocaleRoutes;
+  routeLocales;
   noPrefixRedirect;
   excludePatterns;
-  constructor(locales, defaultLocaleCode, strategy, globalLocaleRoutes, filesLocaleRoutes, noPrefixRedirect, excludePatterns) {
+  constructor(locales, defaultLocaleCode, strategy, globalLocaleRoutes, filesLocaleRoutes, routeLocales, noPrefixRedirect, excludePatterns) {
     this.locales = locales;
     this.defaultLocale = this.findLocaleByCode(defaultLocaleCode) || { code: defaultLocaleCode };
     this.strategy = strategy;
@@ -251,6 +249,7 @@ class PageManager {
     this.activeLocaleCodes = this.computeActiveLocaleCodes();
     this.globalLocaleRoutes = globalLocaleRoutes || {};
     this.filesLocaleRoutes = filesLocaleRoutes || {};
+    this.routeLocales = routeLocales || {};
   }
   findLocaleByCode(code) {
     return this.locales.find((locale) => locale.code === code);
@@ -258,10 +257,22 @@ class PageManager {
   computeActiveLocaleCodes() {
     return this.locales.filter((locale) => locale.code !== this.defaultLocale.code || isPrefixAndDefaultStrategy(this.strategy) || isPrefixStrategy(this.strategy)).map((locale) => locale.code);
   }
+  getAllowedLocalesForPage(pagePath, pageName) {
+    const allowedLocales = this.routeLocales[pagePath] || this.routeLocales[pageName];
+    if (allowedLocales && allowedLocales.length > 0) {
+      return allowedLocales.filter(
+        (locale) => this.locales.some((l) => l.code === locale)
+      );
+    }
+    return this.locales.map((locale) => locale.code);
+  }
+  hasLocaleRestrictions(pagePath, pageName) {
+    return !!(this.routeLocales[pagePath] || this.routeLocales[pageName]);
+  }
   // private isAlreadyLocalized(p: string) {
   //   const codes = this.locales.map(l => l.code).join('|') // en|de|ru…
-  //   return p.startsWith('/:locale(') // динамический префикс
-  //     || new RegExp(`^/(${codes})(/|$)`).test(p) // статический /de/…
+  //   return p.startsWith('/:locale(') // dynamic prefix
+  //     || new RegExp(`^/(${codes})(/|$)`).test(p) // static /de/…
   // }
   extendPages(pages, customRegex, isCloudflarePages) {
     this.localizedPaths = this.extractLocalizedPaths(pages);
@@ -302,15 +313,14 @@ class PageManager {
     const localizedPaths = {};
     pages.forEach((page) => {
       const pageName = buildRouteNameFromRoute(page.name, page.path);
-      const globalLocalePath = this.globalLocaleRoutes[pageName];
+      const normalizedFullPath = normalizePath(path.posix.join(parentPath, page.path));
+      const globalLocalePath = this.globalLocaleRoutes[normalizedFullPath] || this.globalLocaleRoutes[pageName];
       if (!globalLocalePath) {
         const filesLocalePath = this.filesLocaleRoutes[pageName];
         if (filesLocalePath && typeof filesLocalePath === "object") {
-          const normalizedFullPath = normalizePath(path.posix.join(parentPath, page.path));
           localizedPaths[normalizedFullPath] = filesLocalePath;
         }
       } else if (typeof globalLocalePath === "object") {
-        const normalizedFullPath = normalizePath(path.posix.join(parentPath, page.path));
         localizedPaths[normalizedFullPath] = globalLocalePath;
       }
       if (page.children?.length) {
@@ -321,7 +331,12 @@ class PageManager {
     return localizedPaths;
   }
   addCustomGlobalLocalizedRoutes(page, customRoutePaths, additionalRoutes, customRegex) {
-    this.locales.forEach((locale) => {
+    const normalizedFullPath = normalizePath(page.path);
+    const pageName = buildRouteNameFromRoute(page.name, page.path);
+    const allowedLocales = this.getAllowedLocalesForPage(normalizedFullPath, pageName);
+    const hasRestrictions = this.hasLocaleRestrictions(normalizedFullPath, pageName);
+    const localesToUse = hasRestrictions ? this.locales.filter((locale) => allowedLocales.includes(locale.code)) : this.locales;
+    localesToUse.forEach((locale) => {
       const customPath = customRoutePaths[locale.code];
       const isDefaultLocale = isLocaleDefault(locale, this.defaultLocale, isPrefixStrategy(this.strategy) || isPrefixAndDefaultStrategy(this.strategy));
       if (customPath) {
@@ -353,17 +368,44 @@ class PageManager {
     if (isPageRedirectOnly(page)) return;
     const originalChildren = cloneArray(page.children ?? []);
     const normalizedFullPath = normalizePath(page.path);
-    const localeCodesWithoutCustomPaths = this.filterLocaleCodesWithoutCustomPaths(normalizedFullPath);
+    const pageName = buildRouteNameFromRoute(page.name, page.path);
+    const allowedLocales = this.getAllowedLocalesForPage(normalizedFullPath, pageName);
+    const hasRestrictions = this.hasLocaleRestrictions(normalizedFullPath, pageName);
+    const localeCodesWithoutCustomPaths = this.filterLocaleCodesWithoutCustomPaths(normalizedFullPath).filter((locale) => hasRestrictions ? allowedLocales.includes(locale) : true);
     if (localeCodesWithoutCustomPaths.length) {
       const newRoute = this.createLocalizedRoute(page, localeCodesWithoutCustomPaths, originalChildren, false, "", customRegex, false, true);
       if (newRoute) additionalRoutes.push(newRoute);
     }
-    this.addCustomLocalizedRoutes(page, normalizedFullPath, originalChildren, additionalRoutes);
+    this.addCustomLocalizedRoutes(page, normalizedFullPath, originalChildren, additionalRoutes, hasRestrictions ? allowedLocales : void 0);
     this.adjustRouteForDefaultLocale(page, originalChildren);
+    this.handleAliasRoutes(page, additionalRoutes, customRegex, hasRestrictions ? allowedLocales : void 0);
   }
   filterLocaleCodesWithoutCustomPaths(fullPath) {
     return this.activeLocaleCodes.filter((code) => !this.localizedPaths[fullPath]?.[code]);
   }
+  handleAliasRoutes(page, additionalRoutes, customRegex, allowedLocales) {
+    const aliasRoutes = page.alias || page.meta?.alias;
+    if (!aliasRoutes || !Array.isArray(aliasRoutes)) {
+      return;
+    }
+    const localesToUse = allowedLocales || this.activeLocaleCodes;
+    aliasRoutes.forEach((aliasPath) => {
+      const localizedAliasPath = buildFullPath(localesToUse, aliasPath, customRegex);
+      const aliasRoute = {
+        ...page,
+        path: localizedAliasPath,
+        name: `localized-${page.name ?? ""}`,
+        meta: {
+          ...page.meta,
+          alias: void 0
+          // Remove alias to prevent infinite recursion
+        },
+        alias: void 0
+        // Remove alias from root to prevent infinite recursion
+      };
+      additionalRoutes.push(aliasRoute);
+    });
+  }
   adjustRouteForDefaultLocale(page, originalChildren) {
     if (isNoPrefixStrategy(this.strategy)) {
       return;
@@ -397,16 +439,20 @@ class PageManager {
       page.children = currentChildren;
     }
   }
-  addCustomLocalizedRoutes(page, fullPath, originalChildren, additionalRoutes, customRegex) {
-    this.locales.forEach((locale) => {
+  addCustomLocalizedRoutes(page, fullPath, originalChildren, additionalRoutes, allowedLocales, customRegex) {
+    const localesToUse = allowedLocales ? this.locales.filter((locale) => allowedLocales.includes(locale.code)) : this.locales;
+    localesToUse.forEach((locale) => {
       const customPath = this.localizedPaths[fullPath]?.[locale.code];
       if (!customPath) return;
       const isDefaultLocale = isLocaleDefault(locale, this.defaultLocale, isPrefixStrategy(this.strategy) || isNoPrefixStrategy(this.strategy));
-      if (isDefaultLocale) {
-        page.children = this.createLocalizedChildren(originalChildren, "", [locale.code], false);
+      if (isDefaultLocale && isPrefixExceptDefaultStrategy(this.strategy)) {
+        page.path = normalizePath(customPath);
+        page.children = this.createLocalizedChildren(originalChildren, "", [locale.code], false, false, false, { [locale.code]: customPath });
       } else {
         const newRoute = this.createLocalizedRoute(page, [locale.code], originalChildren, true, customPath, customRegex, false, locale.code);
-        if (newRoute) additionalRoutes.push(newRoute);
+        if (newRoute) {
+          additionalRoutes.push(newRoute);
+        }
       }
       if (isPrefixAndDefaultStrategy(this.strategy) && locale === this.defaultLocale) {
         const newRoute = this.createLocalizedRoute(page, [locale.code], originalChildren, true, customPath, customRegex, true, locale.code);
@@ -430,7 +476,14 @@ class PageManager {
   createLocalizedVariants(route, parentPath, localeCodes, modifyName, addLocalePrefix, parentLocale = false, localizedParentPaths) {
     const routePath = normalizePath(route.path);
     const fullPath = normalizePath(path.posix.join(parentPath, routePath));
-    const customLocalePaths = this.localizedPaths[fullPath] ?? this.localizedPaths[normalizePath(route.path)];
+    let customLocalePaths = this.localizedPaths[fullPath] ?? this.localizedPaths[normalizePath(route.path)];
+    if (!customLocalePaths && Object.keys(localizedParentPaths).length > 0) {
+      const hasLocalizedContext = Object.values(localizedParentPaths).some((path2) => path2 && path2 !== "");
+      if (hasLocalizedContext) {
+        const originalRoutePath = normalizePath(path.posix.join("/activity-locale", route.path));
+        customLocalePaths = this.localizedPaths[originalRoutePath];
+      }
+    }
     const isCustomLocalized = !!customLocalePaths;
     const result = [];
     if (!isCustomLocalized) {
@@ -457,15 +510,21 @@ class PageManager {
       const parentLocalizedPath = localizedParentPaths?.[locale];
       const hasParentLocalized = !!parentLocalizedPath;
       const customPath = customLocalePaths?.[locale];
-      const basePath = customPath ? normalizePath(customPath) : normalizePath(route.path);
+      let basePath = customPath ? normalizePath(customPath) : normalizePath(route.path);
+      if (hasParentLocalized && parentLocalizedPath) {
+        if (customPath) {
+          basePath = normalizePath(customPath);
+        } else {
+          basePath = normalizePath(path.posix.join(parentLocalizedPath, route.path));
+        }
+      }
       const finalRoutePath = shouldAddLocalePrefix(
         locale,
         this.defaultLocale,
         addLocalePrefix,
         isPrefixStrategy(this.strategy)
       ) ? buildFullPath(locale, basePath) : basePath;
-      const isChildRoute = parentPath !== "";
-      const finalPathForRoute = isChildRoute && hasParentLocalized ? normalizePath(route.path) : removeLeadingSlash(finalRoutePath);
+      const finalPathForRoute = removeLeadingSlash(finalRoutePath);
       const nextParentPath = customPath ? normalizePath(customPath) : hasParentLocalized ? parentLocalizedPath : normalizePath(path.posix.join(parentPath, routePath));
       const localizedChildren = this.createLocalizedChildren(
         cloneArray(route.children ?? []),
@@ -512,7 +571,7 @@ class PageManager {
     const routeName = buildRouteName(buildRouteNameFromRoute(page.name ?? "", page.path ?? ""), firstLocale, isCustom);
     return {
       ...page,
-      children: this.createLocalizedChildren(originalChildren, page.path, localeCodes, true, false, parentLocale),
+      children: this.createLocalizedChildren(originalChildren, page.path, localeCodes, true, false, parentLocale, { [firstLocale]: customPath }),
       path: routePath,
       name: routeName
     };
@@ -670,17 +729,17 @@ const module = defineNuxtModule({
         const fileContent = readFileSync(fullPath, "utf-8");
         const { locales: extractedLocales, localeRoutes } = extractDefineI18nRouteData(fileContent, fullPath);
         const routePath = pageFile.replace(/^pages\//, "/").replace(/\/index\.vue$/, "").replace(/\.vue$/, "").replace(/\/$/, "") || "/";
-        const pageName = routePath.replace(/[^a-z0-9]/gi, "-").replace(/^-+|-+$/g, "");
         if (extractedLocales) {
           routeLocales[routePath] = extractedLocales;
         }
         if (localeRoutes) {
-          globalLocaleRoutes[pageName] = localeRoutes;
+          globalLocaleRoutes[routePath] = localeRoutes;
         }
       } catch {
       }
     }
-    const pageManager = new PageManager(localeManager.locales, defaultLocale, options.strategy, options.globalLocaleRoutes, globalLocaleRoutes, options.noPrefixRedirect, options.excludePatterns);
+    const mergedGlobalLocaleRoutes = { ...options.globalLocaleRoutes, ...globalLocaleRoutes };
+    const pageManager = new PageManager(localeManager.locales, defaultLocale, options.strategy, mergedGlobalLocaleRoutes, globalLocaleRoutes, routeLocales, options.noPrefixRedirect, options.excludePatterns);
     addTemplate({
       filename: "i18n.plural.mjs",
       write: true,
@@ -708,7 +767,10 @@ const module = defineNuxtModule({
       excludePatterns: options.excludePatterns ?? [],
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
-      routeLocales
+      routeLocales,
+      experimental: {
+        i18nPreviousPageFallback: options.experimental?.i18nPreviousPageFallback ?? false
+      }
     };
     if (typeof options.customRegexMatcher !== "undefined") {
       const localeCodes = localeManager.locales.map((l) => l.code);

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

@@ -31,8 +31,13 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   );
   const translationService = new FormatService();
   const i18nRouteParams = useState("i18n-route-params", () => ({}));
-  nuxtApp.hook("page:start", () => {
-    i18nRouteParams.value = null;
+  const previousPageInfo = useState("i18n-previous-page", () => null);
+  const enablePreviousPageFallback = i18nConfig.experimental?.i18nPreviousPageFallback ?? false;
+  nuxtApp.hook("page:finish", () => {
+    if (import.meta.client) {
+      i18nRouteParams.value = null;
+      previousPageInfo.value = null;
+    }
   });
   const loadTranslationsIfNeeded = async (locale, routeName, path) => {
     try {
@@ -90,6 +95,12 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   }
   router.beforeEach(async (to, from, next) => {
     if (to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy)) {
+      if (import.meta.client && from.path !== to.path && enablePreviousPageFallback) {
+        const fromLocale = routeService.getCurrentLocale(from);
+        const fromRouteName = routeService.getRouteName(from, fromLocale);
+        previousPageInfo.value = { locale: fromLocale, routeName: fromRouteName };
+        console.log(`Saved previous page info for cleanup: ${fromRouteName}`);
+      }
       await loadGlobalTranslations(to);
     }
     if (next) {
@@ -115,9 +126,20 @@ export default defineNuxtPlugin(async (nuxtApp) => {
       const locale = routeService.getCurrentLocale();
       const routeName = routeService.getRouteName(route, locale);
       let value = i18nHelper.getTranslation(locale, routeName, key);
+      if (!value && previousPageInfo.value && enablePreviousPageFallback) {
+        const prev = previousPageInfo.value;
+        const prevValue = i18nHelper.getTranslation(prev.locale, prev.routeName, key);
+        if (prevValue) {
+          value = prevValue;
+          console.log(`Using fallback translation from previous route: ${prev.routeName} -> ${key}`);
+        }
+      }
+      if (!value) {
+        value = i18nHelper.getTranslation(locale, "", key);
+      }
       if (!value) {
         if (isDev && import.meta.client) {
-          console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
+          console.warn(`Not found '${key}' key in '${locale}' locale messages for route '${routeName}'.`);
         }
         value = defaultValue === void 0 ? key : defaultValue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-i18n-micro",
-  "version": "1.98.0",
+  "version": "1.100.0",
   "description": "Nuxt I18n Micro is a lightweight, high-performance internationalization module for Nuxt, designed to handle multi-language support with minimal overhead, fast build times, and efficient runtime performance.",
   "repository": "s00d/nuxt-i18n-micro",
   "license": "MIT",
@@ -62,8 +62,8 @@
     "sirv": "^2.0.4",
     "ufo": "^1.5.4",
     "nuxt-i18n-micro-core": "1.0.18",
-    "nuxt-i18n-micro-types": "1.0.8",
-    "nuxt-i18n-micro-test-utils": "1.0.6"
+    "nuxt-i18n-micro-test-utils": "1.0.6",
+    "nuxt-i18n-micro-types": "1.0.9"
   },
   "devDependencies": {
     "@nuxt/devtools": "^2.6.3",

package/dist/client/_nuxt/builds/meta/9bdb882b-a145-42be-bbc5-f7c9185266d5.json

@@ -1 +0,0 @@
-{"id":"9bdb882b-a145-42be-bbc5-f7c9185266d5","timestamp":1759229326396,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}