fix: derive route resources from route localization (#4047)

Author: BobbieGoede

internals.d.ts

@@ -29,7 +29,8 @@ declare module '#internal/i18n-type-generation-options' {
 }
 
 declare module '#build/i18n-route-resources.mjs' {
+  export const localizedPaths: string[]
   export const i18nPathToPath: Record<string, string>
-  export const pathToI18nConfig: Record<string, Record<string, string | boolean>>
-  export const disabledI18nPathToPath: Record<string, string>
+  export const pathToI18nConfig: Record<string, Record<string, string | false>>
+  export const disabledPaths: string[]
 }

src/kit/gen.ts

@@ -8,7 +8,6 @@ const join = (...args: (string | undefined)[]) => args.filter(Boolean).join('')
 export interface ComputedRouteOptions {
   locales: readonly string[]
   paths: Record<string, string>
-  srcPaths?: Record<string, string>
 }
 
 /**
@@ -39,6 +38,19 @@ export type LocalizeRouteParams = {
   parent?: LocalizableRoute
   /** localized parent route */
   parentLocalized?: LocalizableRoute
+  /** accumulated full path of the parent route */
+  parentPath?: string
+}
+
+/**
+ * Compose a child path with its parent's full path, absolute child paths are kept as-is
+ * (matching how Vue Router resolves nested paths).
+ */
+export function joinPath(parent: string | undefined, path: string): string {
+  const full = (!parent || path.startsWith('/'))
+    ? path
+    : (parent === '/' ? '' : parent) + (path ? '/' + path : '')
+  return full.replace(/\/+$/, '') || '/'
 }
 
 function handlePathNesting(localizedPath: string, parentLocalizedPath: string = '') {
@@ -80,7 +92,13 @@ function createLocalizeAliases(ctx: RouteContext): RouteContext['localizeAliases
 
 function createLocalizeChildren(ctx: RouteContext): RouteContext['localizeChildren'] {
   return (route: LocalizableRoute, parentLocalized: LocalizableRoute, locale: string, opts: LocalizeRouteParams) => {
-    const localizeParams = { ...opts, parent: route, locales: [locale], parentLocalized }
+    const localizeParams = {
+      ...opts,
+      parent: route,
+      locales: [locale],
+      parentLocalized,
+      parentPath: joinPath(opts.parentPath, route.path),
+    }
     return route.children?.flatMap(child => localizeSingleRoute(child, localizeParams, ctx)) ?? []
   }
 }
@@ -108,6 +126,7 @@ export function localizeSingleRoute(
 ): LocalizableRoute[] {
   // resolve custom route (config/page) options
   const routeOptions = ctx.optionsResolver(route, options.locales)
+  ctx.onLocalize?.(route, routeOptions, options)
   if (!routeOptions) {
     return [route]
   }
@@ -118,7 +137,11 @@ export function localizeSingleRoute(
     && canCompactRoute(routeOptions, options.locales)
     && canCompactChildren(route.children, options.locales, ctx)) {
     const compacted = ctx.compactRoute(route, routeOptions, options)
-    if (compacted) { return compacted }
+    if (compacted) {
+      // compaction keeps children as-is instead of walking them, report them here
+      reportSkippedChildren(route, options, ctx)
+      return compacted
+    }
   }
 
   const resultRoutes: LocalizableRoute[] = []
@@ -139,6 +162,19 @@ export function localizeSingleRoute(
   return resultRoutes
 }
 
+/**
+ * Fire `onLocalize` for descendants of a compacted route — these are compact-eligible
+ * (all locales, no custom paths) so their localized paths are identical to their plain paths.
+ */
+function reportSkippedChildren(route: LocalizableRoute, options: LocalizeRouteParams, ctx: RouteContext): void {
+  if (ctx.onLocalize == null || !route.children?.length) { return }
+  const opts = { ...options, parentPath: joinPath(options.parentPath, route.path) }
+  for (const child of route.children) {
+    ctx.onLocalize(child, ctx.optionsResolver(child, options.locales), opts)
+    reportSkippedChildren(child, opts, ctx)
+  }
+}
+
 type LocalizerData = {
   route: LocalizableRoute
   prefixed: string
@@ -163,6 +199,12 @@ export type RouteContext = {
   localizeRouteName: (name: LocalizableRoute, locale: string, isDefault: boolean) => string | undefined
   handleTrailingSlash: (localizedPath: string, hasParent: boolean) => string
   localizers: { enabled: (data: LocalizerData) => boolean, localizer: LocalizerFn }[]
+  /** Called for each route visited during localization, before locale variants are produced. */
+  onLocalize?: (
+    route: LocalizableRoute,
+    routeOptions: ComputedRouteOptions | undefined,
+    options: LocalizeRouteParams,
+  ) => void
   /** When set, eligible routes are compacted into a single regex-prefixed route instead of per-locale duplicates. */
   compactRoute?: (
     route: LocalizableRoute,
@@ -206,9 +248,11 @@ export function createRouteContext(opts: {
   optionsResolver?: RouteOptionsResolver
   routesNameSeparator?: string
   defaultLocaleRouteNameSuffix?: string
+  onLocalize?: RouteContext['onLocalize']
 }) {
   const ctx = { localizers: [] as RouteContext['localizers'] } as RouteContext
   ctx.trailingSlash = opts.trailingSlash ?? false
+  ctx.onLocalize = opts.onLocalize
   ctx.isDefaultLocale = (locale: string) => opts.defaultLocales.includes(locale)
   ctx.localizeRouteName = createLocalizeRouteName(opts)
   ctx.optionsResolver = createDefaultOptionsResolver(opts)

src/pages.ts

@@ -5,7 +5,8 @@ import { parse as parseSFC } from '@vue/compiler-sfc'
 import { parseAndWalk } from 'oxc-walker'
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { parseSegment, toVueRouterSegment } from 'unrouting'
-import { localizeRoutes, shouldLocalizeRoutes } from './routing'
+import { createRouteResourcesCollector, localizeRoutes } from './routing'
+import type { RouteResources } from './routing'
 import { logger } from './utils'
 import { dirname, parse as parsePath, resolve } from 'pathe'
 import { createRoutesContext, resolveOptions } from 'vue-router/unplugin'
@@ -15,24 +16,20 @@ import type { Nuxt, NuxtPage, ResolvedNuxtTemplate } from '@nuxt/schema'
 import type { EditableTreeNode, Options as TypedRouterOptions } from 'vue-router/unplugin'
 import type { NuxtI18nOptions } from './types'
 import type { I18nNuxtContext } from './context'
-import type { ComputedRouteOptions, LocalizableRoute, RouteOptionsResolver } from './kit/gen'
+import type { ComputedRouteOptions, RouteOptionsResolver } from './kit/gen'
 import type { I18nRoute } from './runtime/composables'
 import { type CallExpression, type ExpressionStatement, type ObjectExpression, parseSync } from 'oxc-parser'
 
 export class NuxtPageAnalyzeContext {
   config: NuxtI18nOptions['pages']
   pages: Map<string, { path: string, name?: string }> = new Map()
-  pathToConfig: Record<string, Record<string, string | boolean> | undefined> = {}
-  fileToPath: Record<string, string> = {}
 
   constructor(config: NuxtI18nOptions['pages']) {
     this.config = config || {}
   }
 
   addPage(page: NuxtPage, path: string, name?: string) {
     this.pages.set(page.file!, { path, name })
-    const p = path === 'index' ? '/' : '/' + path.replace(/\/index$/, '')
-    this.fileToPath[page.file!] = p
   }
 }
 
@@ -42,20 +39,22 @@ type NarrowedNuxtPage = Omit<NuxtPage, 'redirect' | 'children'> & {
 }
 
 export async function setupPages({ localeCodes, options, normalizedLocales }: I18nNuxtContext, nuxt: Nuxt) {
-  const routeResources = {
-    i18nPathToPath: {},
+  let routeResources: RouteResources = {
+    localizedPaths: [],
     pathToI18nConfig: {},
-    disabledI18nPathToPath: {},
+    i18nPathToPath: {},
+    disabledPaths: [],
   }
 
   addTemplate({
     filename: 'i18n-route-resources.mjs',
     write: true,
     getContents: () => {
       return `// Generated by @nuxtjs/i18n
+export const localizedPaths = ${JSON.stringify(routeResources.localizedPaths, null, 2)};
 export const pathToI18nConfig = ${JSON.stringify(routeResources.pathToI18nConfig, null, 2)};
-export const i18nPathToPath = ${JSON.stringify(routeResources.i18nPathToPath, null, 2)}
-export const disabledI18nPathToPath = ${JSON.stringify(routeResources.disabledI18nPathToPath, null, 2)};`
+export const i18nPathToPath = ${JSON.stringify(routeResources.i18nPathToPath, null, 2)};
+export const disabledPaths = ${JSON.stringify(routeResources.disabledPaths, null, 2)};`
     },
   })
   if (!localeCodes.length) { return }
@@ -104,21 +103,18 @@ export const disabledI18nPathToPath = ${JSON.stringify(routeResources.disabledI1
       normalizeRouteMeta(ctx, pages, localeCodes, options.customRoutes ?? 'page', nuxt.vfs)
 
       const resolver = createPureOptionsResolver(ctx, options.defaultLocale, options.customRoutes)
+      const resources = createRouteResourcesCollector()
 
       const localizationOptions = {
         ...options,
         locales: normalizedLocales,
         optionsResolver: resolver,
         compactRoutes: !!options.experimental?.compactRoutes,
+        onLocalize: resources.collect,
       }
 
       const localizedPages = localizeRoutes(pages as NarrowedNuxtPage[], localizationOptions)
 
-      // Build path config from original pages (not localized copies)
-      if (shouldLocalizeRoutes(localizationOptions)) {
-        buildPathToConfig(ctx, localeCodes, resolver, pages as LocalizableRoute[])
-      }
-
       // keep root when using prefixed routing without prerendering
       const indexPage = pages.find(x => x.path === '/')
       if (options.strategy === 'prefix' && indexPage != null) {
@@ -129,28 +125,7 @@ export const disabledI18nPathToPath = ${JSON.stringify(routeResources.disabledI1
       // (the boolean form is kept, it marks routes with disabled localization at runtime)
       stripRouteMetaI18n(localizedPages)
 
-      const invertedMap = {} as Record<string, Record<string, string | false>>
-      const localizedMapInvert: Record<string, string> = {}
-      const notLocalizedMapInvert: Record<string, string> = {}
-      for (const [path, localeConfig] of Object.entries(ctx.pathToConfig)) {
-        const resPath = resolveRoutePath(path)
-        invertedMap[resPath] ??= {}
-        let hasLocalized = false
-        for (const [locale, localePath] of Object.entries(localeConfig!)) {
-          const localized = localePath === true ? path : localePath
-          invertedMap[resPath][locale] = localized && resolveRoutePath(localized)
-          if (invertedMap[resPath][locale]) {
-            localizedMapInvert[invertedMap[resPath][locale]] = resPath
-            hasLocalized = true
-          }
-        }
-        if (!hasLocalized) {
-          notLocalizedMapInvert[resPath] = resPath
-        }
-      }
-      routeResources.i18nPathToPath = localizedMapInvert
-      routeResources.pathToI18nConfig = invertedMap
-      routeResources.disabledI18nPathToPath = notLocalizedMapInvert
+      routeResources = resources.toResources()
 
       await updateTemplates({
         filter: (template: ResolvedNuxtTemplate) => template.filename === 'i18n-route-resources.mjs',
@@ -388,49 +363,6 @@ export function createPureOptionsResolver(
   }
 }
 
-/**
- * Post-processing step: builds ctx.pathToConfig from the original (pre-localized) routes.
- * Call this after localizeRoutes() with the same resolver used for localization.
- */
-export function buildPathToConfig(
-  ctx: NuxtPageAnalyzeContext,
-  localeCodes: string[],
-  resolver: RouteOptionsResolver,
-  routes: LocalizableRoute[],
-): void {
-  for (const route of routes) {
-    if (route.file) {
-      const res = resolver(route, localeCodes)
-      const localeCfg = res?.srcPaths
-      const mappedPath = ctx.fileToPath[route.file]
-      if (mappedPath) {
-        ctx.pathToConfig[mappedPath] ??= {} as Record<string, string | boolean>
-        for (const l of localeCodes) {
-          ctx.pathToConfig[mappedPath][l] ??= localeCfg?.[l] ?? false
-        }
-        for (const l of res?.locales ?? []) {
-          ctx.pathToConfig[mappedPath][l] ||= true
-        }
-      }
-    }
-    if (route.children?.length) {
-      buildPathToConfig(ctx, localeCodes, resolver, route.children)
-    }
-  }
-}
-
-/**
- * Function factory, returns a function based on the `customRoutes` option property.
- * @deprecated Use createPureOptionsResolver + buildPathToConfig instead.
- */
-export function getRouteOptionsResolver(
-  ctx: NuxtPageAnalyzeContext,
-  defaultLocale: string,
-  customRoutes: NuxtI18nOptions['customRoutes'],
-): RouteOptionsResolver {
-  return createPureOptionsResolver(ctx, defaultLocale, customRoutes)
-}
-
 function resolveRoutePath(path: string): string {
   const tokens = parseSegment(path.slice(1))
   return '/' + toVueRouterSegment(tokens)
@@ -592,7 +524,7 @@ function getRouteOptions(
     }
   }
 
-  return { locales, paths, srcPaths: resolvedOptions.paths }
+  return { locales, paths }
 }
 
 /**

src/routing.ts

@@ -4,10 +4,79 @@ import {
   type RouteContext,
   type RouteOptionsResolver,
   createRouteContext,
+  joinPath,
   localizeSingleRoute,
 } from './kit/gen'
 import type { LocaleObject, Strategies } from './types'
 
+export type RouteResources = {
+  /** plain paths mounted as-is for at least one locale */
+  localizedPaths: string[]
+  /** per-locale custom paths and disables, locales without an entry use the plain path */
+  pathToI18nConfig: Record<string, Record<string, string | false>>
+  /** custom localized path to plain path */
+  i18nPathToPath: Record<string, string>
+  /** paths with localization fully disabled */
+  disabledPaths: string[]
+}
+
+/**
+ * Collects the runtime route resources (`i18n-route-resources.mjs`) during route
+ * localization, keyed by the full paths routes actually mount at.
+ */
+export function createRouteResourcesCollector() {
+  const pathToConfig: Record<string, Record<string, string | false>> = {}
+
+  const collect: RouteContext['onLocalize'] = (route, routeOptions, options) => {
+    const path = joinPath(options.parentPath, route.path)
+    if (routeOptions == null) {
+      // only routes with localization explicitly disabled are recorded (not e.g. redirect-only routes)
+      if ((route.meta as Record<string, unknown> | undefined)?.i18n === false) {
+        const entry = (pathToConfig[path] ??= {})
+        for (const locale of options.locales) { entry[locale] ??= false }
+      }
+      return
+    }
+
+    const entry = (pathToConfig[path] ??= {})
+    for (const locale of routeOptions.locales) {
+      // the walk is top-down, the parent's localized path (unprefixed) is already collected
+      const parentPath = options.parentPath ? pathToConfig[options.parentPath]?.[locale] || options.parentPath : undefined
+      entry[locale] = joinPath(parentPath, routeOptions.paths[locale] ?? route.path)
+    }
+    for (const locale of options.locales) { entry[locale] ??= false }
+  }
+
+  const toResources = (): RouteResources => {
+    const resources: RouteResources = { localizedPaths: [], pathToI18nConfig: {}, i18nPathToPath: {}, disabledPaths: [] }
+    for (const [path, entry] of Object.entries(pathToConfig)) {
+      // identity localizations (localized path equals the plain path) are kept implicit
+      const exceptions: Record<string, string | false> = {}
+      let hasIdentity = false
+      let hasLocalized = false
+      for (const [locale, localized] of Object.entries(entry)) {
+        if (localized === path) {
+          hasIdentity = hasLocalized = true
+          continue
+        }
+        exceptions[locale] = localized
+        if (!localized) { continue }
+        resources.i18nPathToPath[localized] = path
+        hasLocalized = true
+      }
+      if (!hasLocalized) {
+        resources.disabledPaths.push(path)
+        continue
+      }
+      if (hasIdentity) { resources.localizedPaths.push(path) }
+      if (Object.keys(exceptions).length) { resources.pathToI18nConfig[path] = exceptions }
+    }
+    return resources
+  }
+
+  return { collect, toResources }
+}
+
 function createShouldPrefix(opts: SetupLocalizeRoutesOptions, ctx: RouteContext) {
   if (opts.strategy === 'no_prefix') { return () => false }
   return (path: string, locale: string, options: LocalizeRouteParams) => {
@@ -72,6 +141,7 @@ type SetupLocalizeRoutesOptions = {
   defaultLocale?: string
   optionsResolver?: RouteOptionsResolver
   compactRoutes?: boolean
+  onLocalize?: RouteContext['onLocalize']
 }
 
 /**
@@ -86,6 +156,7 @@ export function localizeRoutes(routes: LocalizableRoute[], config: SetupLocalize
     defaultLocales: resolveDefaultLocales(config),
     routesNameSeparator: config.routesNameSeparator,
     defaultLocaleRouteNameSuffix: config.defaultLocaleRouteNameSuffix,
+    onLocalize: config.onLocalize,
   })
 
   const strategy = config.strategy ?? 'prefix_and_default'