types(router): enable exactOptionalPropertyTypes

Enable exactOptionalPropertyTypes: true in packages/router/tsconfig.json.

- Add | undefined only where code genuinely assigns undefined
- Zero runtime changes in scrollBehavior, unplugin, experimental/router
- 2 unavoidable runtime changes in RouterLink and matcher (driven by ParamValueZeroOrMore)
- Fix TrackedRoute.params bug (LocationQuery -> RouteParamsGeneric)
- Add 10 type-level regression tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: YevheniiKotyrlo

packages/router/__tests__/guards/extractComponentsGuards.spec.ts

@@ -88,7 +88,6 @@ describe('extractComponentsGuards', () => {
   })
 
   it('throws if component is null', async () => {
-    // @ts-expect-error
     await expect(checkGuards([InvalidRoute], 0))
     expect('either missing a "component(s)" or "children"').toHaveBeenWarned()
   })

packages/router/__tests__/guards/onBeforeRouteUpdate.spec.ts

@@ -27,7 +27,7 @@ const component = {
 function withSpy(name?: string, isAsync = false) {
   const spy = vi.fn()
   const Component = defineComponent({
-    name,
+    ...(name != null ? { name } : {}),
     template: `<p>${name || 'No Name'}</p>`,
     setup() {
       onBeforeRouteUpdate(spy)

packages/router/__tests__/matcher/resolve.spec.ts

@@ -37,7 +37,7 @@ describe('RouterMatcher.resolve', () => {
     }
 
     // add location if provided as it should be the same value
-    if ('path' in location && !('path' in resolved)) {
+    if ('path' in location && !('path' in resolved) && location.path != null) {
       resolved.path = location.path
     }
 

packages/router/__tests__/utils.ts

@@ -57,7 +57,7 @@ export interface RouteRecordViewLoose extends Pick<
   enterCallbacks: Record<string, Function[]>
   props: Record<string, _RouteRecordProps>
   aliasOf: RouteRecordNormalized | RouteRecordViewLoose | undefined
-  children?: RouteRecordRaw[]
+  children?: RouteRecordRaw[] | undefined
   components: Record<string, RouteComponent> | null | undefined
 }
 
@@ -67,17 +67,17 @@ export interface RouteLocationNormalizedLoose extends RouteLocationNormalized {
   path: string
   // record?
   params: any
-  redirectedFrom?: Partial<MatcherLocation>
+  redirectedFrom?: Partial<MatcherLocation> | undefined
   meta: any
   matched: Partial<RouteRecordViewLoose>[]
 }
 
 export interface MatcherLocationNormalizedLoose {
-  name: string
+  name: string | undefined
   path: string
   // record?
   params: any
-  redirectedFrom?: Partial<MatcherLocation>
+  redirectedFrom?: Partial<MatcherLocation> | undefined
   meta: any
   matched: Partial<RouteRecordViewLoose>[]
   instances: Record<string, any>

packages/router/src/RouterLink.ts

@@ -438,7 +438,7 @@ function includesParams(
     const outerValue = outer[key]
     if (typeof innerValue === 'string') {
       if (innerValue !== outerValue) return false
-    } else {
+    } else if (isArray(innerValue)) {
       if (
         !isArray(outerValue) ||
         outerValue.length !== innerValue.length ||

packages/router/src/exactOptionalPropertyTypes.test-d.ts

@@ -0,0 +1,69 @@
+import { describe, it, expectTypeOf } from 'vitest'
+import type {
+  ScrollPositionCoordinates,
+  _ScrollPositionNormalized,
+} from './scrollBehavior'
+import type { RouteParamsGeneric, _RouteRecordBase } from './types'
+import type { ResolvedOptions } from './unplugin/options'
+
+describe('exactOptionalPropertyTypes', () => {
+  it('ScrollPositionCoordinates rejects explicit undefined for behavior', () => {
+    // @ts-expect-error: behavior cannot be explicitly undefined under exactOptionalPropertyTypes
+    const pos: ScrollPositionCoordinates = { behavior: undefined }
+    void pos
+  })
+
+  it('ScrollPositionCoordinates rejects explicit undefined for left', () => {
+    // @ts-expect-error: left cannot be explicitly undefined under exactOptionalPropertyTypes
+    const pos: ScrollPositionCoordinates = { left: undefined }
+    void pos
+  })
+
+  it('ScrollPositionCoordinates accepts valid values', () => {
+    expectTypeOf<ScrollPositionCoordinates>().toEqualTypeOf<{
+      behavior?: ScrollBehavior
+      left?: number
+      top?: number
+    }>()
+  })
+
+  it('_ScrollPositionNormalized rejects explicit undefined for behavior', () => {
+    // @ts-expect-error: behavior cannot be explicitly undefined under exactOptionalPropertyTypes
+    const pos: _ScrollPositionNormalized = {
+      behavior: undefined,
+      left: 0,
+      top: 0,
+    }
+    void pos
+  })
+
+  it('_RouteRecordBase meta does not allow undefined', () => {
+    expectTypeOf<_RouteRecordBase['meta']>().not.toEqualTypeOf<undefined>()
+  })
+
+  it('RouteParamsGeneric accepts undefined values for optional repeatable params', () => {
+    // RouteParamsGeneric includes `| undefined` because
+    // ParamValueZeroOrMore<false> = string[] | undefined
+    // for optional repeatable params like [[files]]+
+    const params: RouteParamsGeneric = { id: 'abc', files: undefined }
+    expectTypeOf(params).toEqualTypeOf<RouteParamsGeneric>()
+  })
+
+  it('ResolvedOptions has non-nullable extensions after resolveOptions', () => {
+    expectTypeOf<ResolvedOptions['extensions']>().toEqualTypeOf<string[]>()
+  })
+
+  it('ResolvedOptions has non-nullable root after resolveOptions', () => {
+    expectTypeOf<ResolvedOptions['root']>().toEqualTypeOf<string>()
+  })
+
+  it('ResolvedOptions has non-nullable getRouteName after resolveOptions', () => {
+    expectTypeOf<
+      ResolvedOptions['getRouteName']
+    >().not.toEqualTypeOf<undefined>()
+  })
+
+  it('ResolvedOptions has non-nullable dts after resolveOptions', () => {
+    expectTypeOf<ResolvedOptions['dts']>().not.toEqualTypeOf<undefined>()
+  })
+})

packages/router/src/experimental/data-loaders/auto-exports.ts

@@ -54,7 +54,7 @@ export interface AutoExportLoadersOptions {
    * Root of the project. All paths are resolved relatively to this one.
    * @default `process.cwd()`
    */
-  root?: string
+  root?: string | undefined
 }
 
 /**
@@ -76,6 +76,8 @@ export function AutoExportLoaders({
     transform: {
       order: 'post',
       filter: {
+        // @ts-expect-error: unplugin's StringFilter adds `| undefined` to optional include/exclude
+        // but vite's StringFilter omits it; structurally compatible at runtime
         id: transformFilter,
       },
 

packages/router/src/experimental/data-loaders/defineColadaLoader.ts

@@ -44,6 +44,7 @@ import type {
 import { useRoute, useRouter } from '../../useApi'
 import type { Router } from '../../router'
 import type { LocationQuery } from '../../query'
+import type { RouteParamsGeneric } from '../../types'
 
 /**
  * Creates a Pinia Colada data loader with `data` is always defined.
@@ -729,7 +730,7 @@ export interface DataLoaderColadaEntry<
 
 interface TrackedRoute {
   ready: boolean
-  params: Partial<LocationQuery>
+  params: Partial<RouteParamsGeneric>
   query: Partial<LocationQuery>
   hash: { v: string | null }
 }

packages/router/src/experimental/data-loaders/utils.ts

@@ -1,4 +1,3 @@
-import { LocationQuery } from '../../query'
 import { Router } from '../../router'
 import { RouteLocationNormalizedLoaded } from '../../typed-routes'
 import type { DataLoaderEntryBase, UseDataLoader } from './createDataLoader'
@@ -113,10 +112,10 @@ function trackObjectReads<T extends Record<string, unknown>>(obj: T) {
  * @param outer - the bigger params
  * @param inner - the smaller params
  */
-export function isSubsetOf(
-  inner: Partial<LocationQuery>,
-  outer: LocationQuery
-): boolean {
+export function isSubsetOf<
+  V extends string | null | undefined,
+  T extends Record<string, V | V[]>,
+>(inner: Partial<T>, outer: T): boolean {
   for (const key in inner) {
     const innerValue = inner[key]
     const outerValue = outer[key]

packages/router/src/experimental/route-resolver/matchers/matcher-pattern.ts

@@ -230,11 +230,13 @@ export class MatcherPatternPathDynamic<
   ): string {
     let paramIndex = 0
     let paramName: keyof TParamsOptions
-    let parser: (TParamsOptions &
-      Record<
-        string,
-        MatcherPatternPathDynamic_ParamOptions<any, any>
-      >)[keyof TParamsOptions][0]
+    let parser:
+      | (TParamsOptions &
+          Record<
+            string,
+            MatcherPatternPathDynamic_ParamOptions<any, any>
+          >)[keyof TParamsOptions][0]
+      | undefined
     let repeatable: boolean | undefined
     let optional: boolean | undefined
     let value: ReturnType<NonNullable<ParamParser['set']>> | undefined