fix(path-strategy): keep nested parent when child is absolute

Only skip parent join when the child path already starts with
the parent (#239); restores change-activity nested routes.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: s00d

packages/path-strategy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@i18n-micro/path-strategy",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "description": "Shared strategy-based path and route name builder for Nuxt I18n Micro frontend routing.",
   "keywords": [
     "i18n",

packages/path-strategy/src/path.ts

@@ -255,6 +255,22 @@ export const normalizePath = (p: string): string => {
   return withLeadingSlash(withoutTrailingSlash(cleanDoubleSlashes(p))) || '/'
 }
 
+/**
+ * Join a nested child custom path under its parent.
+ * If the child is already absolute and starts with the parent (e.g. parent `/blog-es`,
+ * child `/blog-es/:slug` → `/blog-es/hello`), return the child as-is to avoid
+ * duplicating the parent segment (#239 Case A). Otherwise prepend the parent
+ * (e.g. parent `/change-activity`, child `/book-activity/skiing`).
+ */
+export function joinNestedCustomPath(parentPath: string, customPath: string): string {
+  const child = normalizePath(customPath)
+  if (!parentPath) return child
+  const parent = normalizePath(parentPath)
+  if (child === parent || child.startsWith(`${parent}/`)) return child
+  const segment = child.charCodeAt(0) === 47 ? child.slice(1) : child
+  return joinUrl(parent, segment)
+}
+
 export function normalizePathForCompare(p: string): string {
   return withoutTrailingSlash(cleanDoubleSlashes(p || '/')) || '/'
 }

packages/path-strategy/src/strategies/common.ts

@@ -6,7 +6,7 @@
  */
 
 import { findLocalizedRouteName, preserveQueryAndHash, tryResolveByLocalizedName, tryResolveByLocalizedNameWithParams } from '../helpers'
-import { getPathSegments, hasKeys, joinUrl, nameKeyFirstSlash, nameKeyLastSlash, normalizePath, transformNameKeyToPath } from '../path'
+import { getPathSegments, hasKeys, joinNestedCustomPath, joinUrl, nameKeyFirstSlash, nameKeyLastSlash, normalizePath, transformNameKeyToPath } from '../path'
 import {
   analyzeRoute,
   getPathForUnlocalizedRoute,
@@ -151,16 +151,15 @@ export function defaultResolveLocaleRoute(
       const isNested = isNestedFirst || isNestedLast
       const keyWithSlash = isNestedLast ? keyLastSlash : keyFirstSlash
       let pathWithoutLocale: string
-      if (isNested && customSegment.charCodeAt(0) !== 47) {
-        // Relative nested segment — join under parent. Absolute custom paths are complete (#239).
+      if (isNested) {
         const nameSegments = getPathSegments(keyWithSlash)
         const parentKey = nameSegments.length > 1 ? nameSegments.slice(0, -1).join('-') : ''
         const parentRules =
           parentKey && gr?.[parentKey] && typeof gr[parentKey] === 'object' && !Array.isArray(gr[parentKey])
             ? (gr[parentKey] as Record<string, string>)
             : null
         const parentPath = parentRules?.[targetLocale] ? normalizePath(parentRules[targetLocale]) : joinUrl('/', ...nameSegments.slice(0, -1))
-        pathWithoutLocale = joinUrl(parentPath, customSegment)
+        pathWithoutLocale = joinNestedCustomPath(parentPath, customSegment)
       } else {
         pathWithoutLocale = normalizePath(customSegment)
       }

packages/path-strategy/src/strategies/prefix-except-default.ts

@@ -20,6 +20,7 @@ import {
   normalizePath,
   normalizePathForCompare,
   parentKeyFromSlashKey,
+  joinNestedCustomPath,
   transformNameKeyToPath,
 } from '../path'
 import { analyzeRoute, getPathForUnlocalizedRoute, getPathForUnlocalizedRouteByName, isIndexRouteName, resolveCustomPath } from '../resolver'
@@ -427,21 +428,13 @@ export class PrefixExceptDefaultPathStrategy extends BasePathStrategy {
     sourceRoute: RouteLike,
     currentRoute?: ResolvedRouteLike,
   ): RouteLike | string {
-    // Absolute custom paths already include the full locale path (e.g. `/blog-es/:slug`).
-    // Prepending a parent segment duplicates it when Nuxt's dashed name (`blog-slug`) is
-    // mistaken for nesting under `blog` (#239 Case A).
-    const isAbsoluteCustom = customPath.charCodeAt(0) === 47
+    const nestedInfo = this.getNestedRouteInfo(routeName)
     let pathNorm: string
-    if (isAbsoluteCustom) {
-      pathNorm = normalizePath(customPath)
+    if (nestedInfo) {
+      const parentPath = this.getParentPathForTarget(nestedInfo.parentKey, nestedInfo.keyWithSlash, targetLocale, currentRoute)
+      pathNorm = joinNestedCustomPath(parentPath, customPath)
     } else {
-      const nestedInfo = this.getNestedRouteInfo(routeName)
-      if (nestedInfo) {
-        const parentPath = this.getParentPathForTarget(nestedInfo.parentKey, nestedInfo.keyWithSlash, targetLocale, currentRoute)
-        pathNorm = parentPath ? joinUrl(parentPath, customPath) : normalizePath(customPath)
-      } else {
-        pathNorm = normalizePath(customPath)
-      }
+      pathNorm = normalizePath(customPath)
     }
     if (!needsPrefix) return preserveQueryAndHash(this.applyBaseUrl(targetLocale, pathNorm), sourceRoute)
     return preserveQueryAndHash(this.applyBaseUrl(targetLocale, joinUrl(targetLocale, pathNorm)), sourceRoute)