nuxt-i18n-micro 1.92.0 → 1.94.0

package/dist/module.mjs

@@ -7,7 +7,6 @@ import { isPrefixAndDefaultStrategy, isPrefixStrategy, isNoPrefixStrategy, isPre
 import { fileURLToPath } from 'node:url';
 import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 import sirv from 'sirv';
-import { isInternalPath, extractLocaleRoutes, normalizePath, isLocaleDefault, cloneArray, isPageRedirectOnly, removeLeadingSlash, shouldAddLocalePrefix, buildFullPath, buildRouteName, buildFullPathNoPrefix } from './utils.mjs';
 
 const DEVTOOLS_UI_PORT = 3030;
 const DEVTOOLS_UI_ROUTE = "/__nuxt-i18n-micro";
@@ -74,8 +73,7 @@ function setupDevToolsUI(options, resolve2) {
           const localesDir = path.join(rootDir, options.translationDir || "locales");
           const pagesDir = path.join(localesDir, "pages");
           const processDirectory = (dir) => {
-            if (!fs.existsSync(dir))
-              return;
+            if (!fs.existsSync(dir)) return;
             fs.readdirSync(dir).forEach((file) => {
               const filePath = path.join(dir, file);
               const stat = fs.lstatSync(filePath);
@@ -110,6 +108,64 @@ function setupDevToolsUI(options, resolve2) {
   });
 }
 
+const isInternalPath = (p) => /(?:^|\/)__[^/]+/.test(p);
+function extractLocaleRoutes(content, filePath) {
+  const defineMatch = content.match(/\$?\bdefineI18nRoute\s*\(\s*\{[\s\S]*?\}\s*\)/);
+  if (defineMatch) {
+    const localeRoutesMatch = defineMatch[0].match(/localeRoutes:\s*(\{[\s\S]*?\})/);
+    if (localeRoutesMatch && localeRoutesMatch[1]) {
+      try {
+        const parsedLocaleRoutes = Function('"use strict";return (' + localeRoutesMatch[1] + ")")();
+        if (typeof parsedLocaleRoutes === "object" && parsedLocaleRoutes !== null) {
+          if (validateDefineI18nRouteConfig(parsedLocaleRoutes)) {
+            return parsedLocaleRoutes;
+          }
+        } 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);
+      }
+    }
+  }
+  return null;
+}
+function validateDefineI18nRouteConfig(obj) {
+  if (typeof obj !== "object") return false;
+  for (const routeKey in obj.localeRoutes) {
+    if (typeof obj.localeRoutes[routeKey] !== "string") return false;
+  }
+  return true;
+}
+const normalizePath = (routePath) => {
+  if (!routePath) {
+    return "";
+  }
+  const normalized = path.posix.normalize(routePath).replace(/\/+$/, "");
+  return normalized === "." ? "" : normalized;
+};
+const cloneArray = (array) => array.map((item) => ({ ...item }));
+const isPageRedirectOnly = (page) => !!(page.redirect && !page.file);
+const removeLeadingSlash = (routePath) => routePath.startsWith("/") ? routePath.slice(1) : routePath;
+const buildRouteName = (baseName, localeCode, isCustom) => isCustom ? `localized-${baseName}-${localeCode}` : `localized-${baseName}`;
+const shouldAddLocalePrefix = (locale, defaultLocale, addLocalePrefix, includeDefaultLocaleRoute) => addLocalePrefix && !(locale === defaultLocale.code && !includeDefaultLocaleRoute);
+const isLocaleDefault = (locale, defaultLocale, includeDefaultLocaleRoute) => {
+  const localeCode = typeof locale === "string" ? locale : locale.code;
+  return localeCode === defaultLocale.code && !includeDefaultLocaleRoute;
+};
+const buildFullPath = (locale, basePath, customRegex) => {
+  const regexString = normalizeRegex(customRegex?.toString());
+  const localeParam = regexString ? regexString : Array.isArray(locale) ? locale.join("|") : locale;
+  return normalizePath(path.posix.join("/", `:locale(${localeParam})`, basePath));
+};
+const buildFullPathNoPrefix = (basePath) => {
+  return normalizePath(basePath);
+};
+const normalizeRegex = (toNorm) => {
+  if (typeof toNorm === "undefined") return void 0;
+  return toNorm.startsWith("/") && toNorm.endsWith("/") ? toNorm?.slice(1, -1) : toNorm;
+};
+
 const buildRouteNameFromRoute = (name, path2) => {
   return name ?? (path2 ?? "").replace(/[^a-z0-9]/gi, "-").replace(/^-+|-+$/g, "");
 };
@@ -163,12 +219,11 @@ class PageManager {
     if (isPrefixStrategy(this.strategy) && !isCloudflarePages) {
       for (let i = pages.length - 1; i >= 0; i--) {
         const page = pages[i];
+        if (!page) continue;
         const pagePath = page.path ?? "";
         const pageName = page.name ?? "";
-        if (isInternalPath(pagePath))
-          continue;
-        if (this.globalLocaleRoutes[pageName] === false)
-          continue;
+        if (isInternalPath(pagePath)) continue;
+        if (this.globalLocaleRoutes[pageName] === false) continue;
         if (!/^\/:locale/.test(pagePath) && pagePath !== "/") {
           pages.splice(i, 1);
         }
@@ -210,16 +265,14 @@ class PageManager {
           const newRoute = this.createLocalizedRoute(page, [locale.code], page.children ?? [], true, customPath, customRegex, false, locale.code);
           if (newRoute) {
             additionalRoutes.push(newRoute);
-            if (this.noPrefixRedirect)
-              page.redirect = newRoute.path;
+            if (this.noPrefixRedirect) page.redirect = newRoute.path;
           }
         } else {
           if (isDefaultLocale) {
             page.path = normalizePath(customPath);
           } else {
             const newRoute = this.createLocalizedRoute(page, [locale.code], page.children ?? [], true, customPath, customRegex, false, locale.code);
-            if (newRoute)
-              additionalRoutes.push(newRoute);
+            if (newRoute) additionalRoutes.push(newRoute);
           }
         }
       } else {
@@ -233,15 +286,13 @@ class PageManager {
     });
   }
   localizePage(page, additionalRoutes, customRegex) {
-    if (isPageRedirectOnly(page))
-      return;
+    if (isPageRedirectOnly(page)) return;
     const originalChildren = cloneArray(page.children ?? []);
     const normalizedFullPath = normalizePath(page.path);
     const localeCodesWithoutCustomPaths = this.filterLocaleCodesWithoutCustomPaths(normalizedFullPath);
     if (localeCodesWithoutCustomPaths.length) {
       const newRoute = this.createLocalizedRoute(page, localeCodesWithoutCustomPaths, originalChildren, false, "", customRegex, false, true);
-      if (newRoute)
-        additionalRoutes.push(newRoute);
+      if (newRoute) additionalRoutes.push(newRoute);
     }
     this.addCustomLocalizedRoutes(page, normalizedFullPath, originalChildren, additionalRoutes);
     this.adjustRouteForDefaultLocale(page, originalChildren);
@@ -285,20 +336,17 @@ class PageManager {
   addCustomLocalizedRoutes(page, fullPath, originalChildren, additionalRoutes, customRegex) {
     this.locales.forEach((locale) => {
       const customPath = this.localizedPaths[fullPath]?.[locale.code];
-      if (!customPath)
-        return;
+      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);
       } 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);
-        if (newRoute)
-          additionalRoutes.push(newRoute);
+        if (newRoute) additionalRoutes.push(newRoute);
       }
     });
   }
@@ -393,9 +441,11 @@ class PageManager {
   }
   createLocalizedRoute(page, localeCodes, originalChildren, isCustom, customPath = "", customRegex, force = false, parentLocale = false) {
     const routePath = this.buildRoutePath(localeCodes, page.path, encodeURI(customPath), isCustom, customRegex, force);
-    if (!routePath || routePath == page.path)
-      return null;
-    const routeName = buildRouteName(buildRouteNameFromRoute(page.name, page.path), localeCodes[0], isCustom);
+    if (!routePath || routePath == page.path) return null;
+    if (localeCodes.length === 0) return null;
+    const firstLocale = localeCodes[0];
+    if (!firstLocale) return null;
+    const routeName = buildRouteName(buildRouteNameFromRoute(page.name ?? "", page.path ?? ""), firstLocale, isCustom);
     return {
       ...page,
       children: this.createLocalizedChildren(originalChildren, page.path, localeCodes, true, false, parentLocale),
@@ -404,8 +454,7 @@ class PageManager {
     };
   }
   buildLocalizedRouteName(baseName, locale, modifyName, forceLocaleSuffixOrCustom = false) {
-    if (!modifyName)
-      return baseName;
+    if (!modifyName) return baseName;
     if (forceLocaleSuffixOrCustom) {
       return `localized-${baseName}-${locale}`;
     }
@@ -524,7 +573,10 @@ const module = defineNuxtModule({
         return null;
       }
       const forms = translation.toString().split("|");
-      return (count < forms.length ? forms[count].trim() : forms[forms.length - 1].trim()).replace("{count}", count.toString());
+      if (forms.length === 0) return null;
+      const selectedForm = count < forms.length ? forms[count] : forms[forms.length - 1];
+      if (!selectedForm) return null;
+      return selectedForm.trim().replace("{count}", count.toString());
     },
     customRegexMatcher: void 0
   },
@@ -652,6 +704,7 @@ const module = defineNuxtModule({
     }
     nuxt.hook("pages:resolved", (pages) => {
       const prerenderRoutes = [];
+      const routeRules = nuxt.options.routeRules || {};
       const pagesNames = pages.map((page) => page.name).filter((name) => name !== void 0 && (!options.routesLocaleLinks || !options.routesLocaleLinks[name]));
       localeManager.locales.forEach((locale) => {
         if (!options.disablePageLocales) {
@@ -677,23 +730,32 @@ const module = defineNuxtModule({
         pages.push(fallbackRoute);
       }
       if (!isNoPrefixStrategy(options.strategy)) {
-        nuxt.options.generate.routes = Array.isArray(nuxt.options.generate.routes) ? nuxt.options.generate.routes : [];
+        const nuxtOptions = nuxt.options;
+        nuxtOptions.generate = nuxtOptions.generate || {};
+        nuxtOptions.generate.routes = Array.isArray(nuxtOptions.generate.routes) ? nuxtOptions.generate.routes : [];
         if (isCloudflarePages) {
           const processPageWithChildren = (page, parentPath = "") => {
-            if (!page.path)
-              return;
+            if (!page.path) return;
             const fullPath = path.posix.normalize(`${parentPath}/${page.path}`);
             if (isInternalPath(fullPath)) {
               return;
             }
+            const routeRule = routeRules[fullPath];
+            if (routeRule && routeRule.prerender === false) {
+              return;
+            }
             const localeSegmentMatch = fullPath.match(/:locale\(([^)]+)\)/);
-            if (localeSegmentMatch) {
+            if (localeSegmentMatch && localeSegmentMatch[1]) {
               const availableLocales = localeSegmentMatch[1].split("|");
               localeManager.locales.forEach((locale) => {
                 const localeCode = locale.code;
                 if (availableLocales.includes(localeCode)) {
                   let localizedPath = fullPath;
                   localizedPath = localizedPath.replace(/:locale\([^)]+\)/, localeCode);
+                  const localizedRouteRule = routeRules[localizedPath];
+                  if (localizedRouteRule && localizedRouteRule.prerender === false) {
+                    return;
+                  }
                   if (!isInternalPath(localizedPath)) {
                     prerenderRoutes.push(localizedPath);
                   }
@@ -761,14 +823,25 @@ const module = defineNuxtModule({
         return;
       }
       const routes = nitroConfig.prerender?.routes || [];
-      nuxt.options.generate.routes = Array.isArray(nuxt.options.generate.routes) ? nuxt.options.generate.routes : [];
-      const pages = nuxt.options.generate.routes || [];
+      const nuxtOptions = nuxt.options;
+      nuxtOptions.generate = nuxtOptions.generate || {};
+      nuxtOptions.generate.routes = Array.isArray(nuxtOptions.generate.routes) ? nuxtOptions.generate.routes : [];
+      const pages = nuxtOptions.generate.routes || [];
       localeManager.locales.forEach((locale) => {
         const shouldGenerate = locale.code !== defaultLocale || withPrefixStrategy(options.strategy);
         if (shouldGenerate) {
           pages.forEach((page) => {
             if (!/\.[a-z0-9]+$/i.test(page) && !isInternalPath(page)) {
-              routes.push(`/${locale.code}${page}`);
+              const localizedPage = `/${locale.code}${page}`;
+              const routeRule = routeRules[page];
+              if (routeRule && routeRule.prerender === false) {
+                return;
+              }
+              const localizedRouteRule = routeRules[localizedPage];
+              if (localizedRouteRule && localizedRouteRule.prerender === false) {
+                return;
+              }
+              routes.push(localizedPage);
             }
           });
         }
@@ -820,16 +893,27 @@ const module = defineNuxtModule({
       });
       routesToRemove.forEach((route) => routesSet.delete(route));
       const additionalRoutes = /* @__PURE__ */ new Set();
+      const routeRules = nuxt.options.routeRules || {};
       routesSet.forEach((route) => {
         if (!/\.[a-z0-9]+$/i.test(route) && !isInternalPath(route)) {
           localeManager.locales.forEach((locale) => {
             const shouldGenerate = locale.code !== defaultLocale || withPrefixStrategy(options.strategy);
             if (shouldGenerate) {
+              let localizedRoute;
               if (route === "/") {
-                additionalRoutes.add(`/${locale.code}`);
+                localizedRoute = `/${locale.code}`;
               } else {
-                additionalRoutes.add(`/${locale.code}${route}`);
+                localizedRoute = `/${locale.code}${route}`;
+              }
+              const routeRule = routeRules[route];
+              if (routeRule && routeRule.prerender === false) {
+                return;
+              }
+              const localizedRouteRule = routeRules[localizedRoute];
+              if (localizedRouteRule && localizedRouteRule.prerender === false) {
+                return;
               }
+              additionalRoutes.add(localizedRoute);
             }
           });
         }

package/dist/runtime/components/i18n-group.vue

@@ -8,16 +8,13 @@
 </template>
 
 <script setup>
-import { useNuxtApp, useRoute } from '#imports'
-
+import { useNuxtApp, useRoute } from "#imports";
 const props = defineProps({
   prefix: { type: String, required: true },
-  groupClass: { type: String, default: '' },
-})
-
-const { $_t } = useNuxtApp()
-const route = useRoute()
-const $t = $_t(route)
-
-const translate = (key, params = {}) => $t(`${props.prefix}.${key}`, params)
+  groupClass: { type: String, default: "" }
+});
+const { $_t } = useNuxtApp();
+const route = useRoute();
+const $t = $_t(route);
+const translate = (key, params = {}) => $t(`${props.prefix}.${key}`, params);
 </script>

package/dist/runtime/components/i18n-group.vue.d.ts

@@ -0,0 +1,19 @@
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    prefix: string;
+    groupClass: string;
+    $props: {
+        readonly prefix?: string | undefined;
+        readonly groupClass?: string | undefined;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {
+        prefix: string;
+        t: (key: any, params?: {}) => any;
+    }) => any) | undefined;
+};

package/dist/runtime/components/i18n-link.vue

@@ -18,57 +18,40 @@
   </NuxtLink>
 </template>
 
-<script lang="ts" setup>
-import type { RouteLocationNamedRaw, RouteLocationResolvedGeneric } from 'vue-router'
-import { useNuxtApp, computed, useRoute, useRouter } from '#imports'
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const { $localeRoute } = useNuxtApp()
-
-interface Props {
-  to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string
-  activeStyle?: Partial<CSSStyleValue>
-}
-
-const props = defineProps<Props>()
-const route = useRoute()
-
+<script setup>
+import { useNuxtApp, computed, useRoute, useRouter } from "#imports";
+const { $localeRoute } = useNuxtApp();
+const props = defineProps({
+  to: { type: [Object, String], required: true },
+  activeStyle: { type: Object, required: false }
+});
+const route = useRoute();
 const isExternalLink = computed(() => {
-  if (typeof props.to === 'string') {
-    return /^(?:https?:\/\/|\/\/|[a-zA-Z0-9-]+\.[a-zA-Z]{2,})|tel:|mailto:/.test(props.to)
+  if (typeof props.to === "string") {
+    return /^(?:https?:\/\/|\/\/|[a-zA-Z0-9-]+\.[a-zA-Z]{2,})|tel:|mailto:/.test(props.to);
   }
-  return false
-})
-
+  return false;
+});
 const externalHref = computed(() => {
-  if (isExternalLink.value && typeof props.to === 'string') {
+  if (isExternalLink.value && typeof props.to === "string") {
     if (!/^https?:\/\//.test(props.to)) {
-      return `https://${props.to}`
+      return `https://${props.to}`;
     }
-    return props.to
+    return props.to;
   }
-  return undefined
-})
-
+  return void 0;
+});
 const isActive = computed(() => {
   if (isExternalLink.value) {
-    return false
+    return false;
   }
-  // If `to` is a string, compare it directly to the route path
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  const newPath = $localeRoute(props.to)
-  if (typeof newPath === 'string') {
-    return route.path === useRouter().resolve(newPath).path
+  const newPath = $localeRoute(props.to);
+  if (typeof newPath === "string") {
+    return route.path === useRouter().resolve(newPath).path;
   }
-
-  return route.path === newPath.path
-})
-
-const computedStyle = computed((): Partial<CSSStyleValue> => {
-  return isActive.value
-    ? { ...props.activeStyle }
-    : {}
-})
+  return route.path === newPath.path;
+});
+const computedStyle = computed(() => {
+  return isActive.value ? { ...props.activeStyle } : {};
+});
 </script>

package/dist/runtime/components/i18n-link.vue.d.ts

@@ -0,0 +1,19 @@
+import type { RouteLocationNamedRaw, RouteLocationResolvedGeneric } from 'vue-router';
+interface Props {
+    to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string;
+    activeStyle?: Partial<CSSStyleValue>;
+}
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};