fix : intersection to variable

Author: mdm317

packages/react-router/tests/link.test-d.tsx

@@ -2162,6 +2162,20 @@ test('when navigating from a route with params to a route with an additional par
   }>()
 })
 
+test('when resolving parent-relative to values from a union of routes', () => {
+  const DefaultRouterLink = Link<
+    DefaultRouter,
+    '/invoices/$invoiceId/details' | '/posts/$postId/preview',
+    '../'
+  >
+
+  expectTypeOf(DefaultRouterLink)
+    .parameter(0)
+    .toHaveProperty('to')
+    .toEqualTypeOf<'..' | '../..' | '../edit' | undefined>()
+
+})
+
 test('when navigating to a union of routes with params', () => {
   const DefaultRouterLink = Link<
     DefaultRouter,

packages/router-core/src/link.ts

@@ -23,6 +23,9 @@ import type {
   MakeDifferenceOptional,
   NoInfer,
   NonNullableUpdater,
+  ToObject,
+  UnObject,
+  UnionToIntersection,
   Updater,
 } from './utils'
 import type { ParsedLocation } from './location'
@@ -229,13 +232,27 @@ export type RelativeToPath<
       : ToPath<TRouter, TTo>)
   | `${RemoveTrailingSlashes<TTo>}/${InferDescendantToPaths<TRouter, RemoveTrailingSlashes<TResolvedPath>>}`
 
+
+type WrapRelativeToPathForIntersection<
+  TRouter extends AnyRouter,
+  TTo extends string,
+  TResolvedPath extends string,
+> = TResolvedPath extends any
+  ? ToObject<RelativeToPath<TRouter, TTo, TResolvedPath>>
+  : never
+
 export type RelativeToParentPath<
   TRouter extends AnyRouter,
   TFrom extends string,
   TTo extends string,
   TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>,
 > =
-  | RelativeToPath<TRouter, TTo, TResolvedPath>
+  | UnObject<
+      UnionToIntersection<
+        WrapRelativeToPathForIntersection<TRouter, TTo, TResolvedPath>
+      >
+    >
+  // RelativeToPath<TRouter, TTo, TResolvedPath>
   | (TTo extends `${string}..` | `${string}../`
       ? TResolvedPath extends '/' | ''
         ? never

packages/router-core/src/utils.ts

@@ -145,6 +145,9 @@ export type UnionToIntersection<T> = (
   ? T
   : never
 
+export type UnObject<T> = T extends { foo: any } ? T["foo"] : never
+export type ToObject<T> = { foo: T }
+
 /**
  * Merges everything in a union into one object.
  * This mapped type is homomorphic which means it preserves stuff! :)