nuxt-i18n-micro 1.99.0 → 1.100.1

package/dist/module.mjs

@@ -110,95 +110,119 @@ function setupDevToolsUI(options, resolve2) {
   });
 }
 
-function extractDefineI18nRouteData(content, filePath) {
-  const defineMatch = content.match(/\$?\bdefineI18nRoute\s*\(\s*\{[\s\S]*?\}\s*\)/);
-  if (!defineMatch) {
-    return { locales: null, localeRoutes: null };
-  }
-  const defineContent = defineMatch[0];
-  let locales = null;
-  let localeRoutes = null;
-  let localesStr = "";
-  const localesStart = defineContent.indexOf("locales:");
-  if (localesStart !== -1) {
-    const afterLocales = defineContent.substring(localesStart + 8);
-    const trimmed = afterLocales.trim();
-    if (trimmed.startsWith("[")) {
-      let bracketCount = 0;
-      let i = 0;
-      for (; i < trimmed.length; i++) {
-        if (trimmed[i] === "[") bracketCount++;
-        if (trimmed[i] === "]") bracketCount--;
-        if (bracketCount === 0) break;
-      }
-      localesStr = trimmed.substring(0, i + 1);
-    } else if (trimmed.startsWith("{")) {
-      let braceCount = 0;
-      let i = 0;
-      for (; i < trimmed.length; i++) {
-        if (trimmed[i] === "{") braceCount++;
-        if (trimmed[i] === "}") braceCount--;
-        if (braceCount === 0) break;
-      }
-      localesStr = trimmed.substring(0, i + 1);
+function extractScriptContent(content) {
+  const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  return scriptMatch ? scriptMatch[1] : null;
+}
+function removeTypeScriptTypes(scriptContent) {
+  return scriptContent.replace(/\((\w+):[^)]*\)/g, "($1)");
+}
+function findDefineI18nRouteConfig(scriptContent) {
+  try {
+    const defineStart = scriptContent.indexOf("$defineI18nRoute(");
+    if (defineStart === -1) {
+      return null;
     }
-  }
-  if (localesStr) {
-    try {
-      const localesStrTrimmed = localesStr.trim();
-      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;
-        }
-      }
-      if (localesStrTrimmed.startsWith("{") && localesStrTrimmed.endsWith("}")) {
-        const topLevelKeyMatches = localesStrTrimmed.match(/^\s*(\w+)\s*:\s*\{/gm);
-        if (topLevelKeyMatches) {
-          const keys = 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);
-          if (fallbackMatches) {
-            const keys = fallbackMatches.map((match) => {
-              const keyMatch = match.match(/(\w+)\s*:/);
-              return keyMatch ? keyMatch[1] : "";
-            }).filter((key) => key.length > 0);
-            locales = keys;
-          }
-        }
+    const openParen = scriptContent.indexOf("(", defineStart);
+    if (openParen === -1) {
+      return null;
+    }
+    let braceCount = 0;
+    let parenCount = 1;
+    let i = openParen + 1;
+    for (; i < scriptContent.length; i++) {
+      if (scriptContent[i] === "{") braceCount++;
+      if (scriptContent[i] === "}") braceCount--;
+      if (scriptContent[i] === "(") parenCount++;
+      if (scriptContent[i] === ")") {
+        parenCount--;
+        if (parenCount === 0 && braceCount === 0) break;
       }
-    } catch (error) {
-      console.error("Failed to parse locales:", error, "in file:", filePath);
     }
-  }
-  const localeRoutesMatch = defineContent.match(/localeRoutes:\s*(\{[\s\S]*?\})/);
-  if (localeRoutesMatch && localeRoutesMatch[1]) {
+    if (i >= scriptContent.length) {
+      return null;
+    }
+    const configStr = scriptContent.substring(openParen + 1, i);
     try {
-      const parsedLocaleRoutes = Function('"use strict";return (' + localeRoutesMatch[1] + ")")();
-      if (typeof parsedLocaleRoutes === "object" && parsedLocaleRoutes !== null) {
-        if (validateDefineI18nRouteConfig(parsedLocaleRoutes)) {
-          localeRoutes = parsedLocaleRoutes;
+      const cleanConfigStr = removeTypeScriptTypes(configStr);
+      try {
+        const configObject = Function('"use strict";return (' + cleanConfigStr + ")")();
+        try {
+          const serialized = JSON.stringify(configObject);
+          return JSON.parse(serialized);
+        } catch {
+          return configObject;
+        }
+      } catch {
+        const scriptWithoutImports = scriptContent.split("\n").filter((line) => !line.trim().startsWith("import ")).join("\n");
+        const cleanScript = removeTypeScriptTypes(scriptWithoutImports);
+        const safeScript = `
+          // Mock $defineI18nRoute to prevent errors
+          const $defineI18nRoute = () => {}
+          const defineI18nRoute = () => {}
+
+          // Mock process.env for conditional logic
+          const process = { env: { NODE_ENV: 'development' } }
+
+          // Execute the script content without imports and TypeScript types
+          ${cleanScript}
+
+          // Return the config object
+          return (${cleanConfigStr})
+        `;
+        const configObject = Function('"use strict";' + safeScript)();
+        try {
+          const serialized = JSON.stringify(configObject);
+          return JSON.parse(serialized);
+        } catch {
+          return configObject;
         }
-      } else {
-        console.error("localeRoutes found but it is not a valid object in file:", filePath);
       }
-    } catch (error) {
-      console.error("Failed to parse localeRoutes:", error, "in file:", filePath);
+    } catch {
+      return null;
     }
+  } catch {
+    return null;
   }
-  return { locales, localeRoutes };
 }
-function validateDefineI18nRouteConfig(obj) {
-  if (typeof obj !== "object") return false;
-  for (const routeKey in obj.localeRoutes) {
-    if (typeof obj.localeRoutes[routeKey] !== "string") return false;
+function extractDefineI18nRouteData(content, _filePath) {
+  try {
+    const scriptContent = extractScriptContent(content);
+    if (!scriptContent) {
+      return { locales: null, localeRoutes: null };
+    }
+    const configObject = findDefineI18nRouteConfig(scriptContent);
+    if (!configObject) {
+      return { locales: null, localeRoutes: null };
+    }
+    let locales = null;
+    if (configObject.locales) {
+      if (Array.isArray(configObject.locales)) {
+        locales = configObject.locales.map((item) => {
+          if (typeof item === "string") {
+            return item;
+          } else if (typeof item === "object" && item !== null && item.code) {
+            return item.code;
+          }
+          return null;
+        }).filter((item) => item !== null);
+      } else if (typeof configObject.locales === "object") {
+        locales = Object.keys(configObject.locales).filter(
+          (key) => key !== "meta" && key !== "path" && key !== "title" && key !== "description"
+        );
+      }
+    }
+    let localeRoutes = null;
+    if (configObject.localeRoutes && typeof configObject.localeRoutes === "object") {
+      const isValid = Object.values(configObject.localeRoutes).every((value) => typeof value === "string");
+      if (isValid) {
+        localeRoutes = configObject.localeRoutes;
+      }
+    }
+    return { locales, localeRoutes };
+  } catch {
+    return { locales: null, localeRoutes: null };
   }
-  return true;
 }
 const normalizePath = (routePath) => {
   if (!routePath) {
@@ -240,9 +264,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 +276,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 +284,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 +340,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 +358,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 +395,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 +466,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 +503,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 +537,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 +598,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 +756,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-i18n-micro",
-  "version": "1.99.0",
+  "version": "1.100.1",
   "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.9",
-    "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/ca54293c-61c3-4dc3-92ac-0c137374a55e.json

@@ -1 +0,0 @@
-{"id":"ca54293c-61c3-4dc3-92ac-0c137374a55e","timestamp":1759737253768,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}