types(router): add | undefined to optional properties for exactOptionalPropertyTypes consumers

Add | undefined to all optional interface properties across published and
internal types. This is a no-op for the default TypeScript configuration but
fixes TS2375 errors for consumers with exactOptionalPropertyTypes: true.

Zero runtime changes. Zero type assertions.

Follows the same approach as vuejs/core#12771 which was merged for
@vue/runtime-dom.

Author: YevheniiKotyrlo

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: name || 'no-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/exactOptionalPropertyTypes.test-d.ts

@@ -0,0 +1,50 @@
+import { describe, it, expectTypeOf } from 'vitest'
+import type {
+  ScrollPositionCoordinates,
+  _ScrollPositionNormalized,
+} from './scrollBehavior'
+import type { _RouteRecordBase } from './types'
+import type { ResolvedOptions } from './unplugin/options'
+
+describe('exactOptionalPropertyTypes', () => {
+  it('ScrollPositionCoordinates accepts valid values', () => {
+    expectTypeOf<ScrollPositionCoordinates>().toEqualTypeOf<{
+      behavior?: ScrollBehavior
+      left?: number
+      top?: number
+    }>()
+  })
+
+  it('_ScrollPositionNormalized accepts explicit undefined for behavior', () => {
+    // behavior includes | undefined because savedPosition.behavior
+    // can be absent at runtime (e.g. computeScrollPosition omits it)
+    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('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
 }
 
 /**

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

packages/router/src/experimental/route-resolver/resolver-fixed.ts

@@ -33,22 +33,22 @@ export interface EXPERIMENTAL_ResolverRecord_Base {
    * Name of the matcher. Unique across all matchers. If missing, this record
    * cannot be matched. This is useful for grouping records.
    */
-  name?: RecordName
+  name?: RecordName | undefined
 
   /**
    * {@link MatcherPattern} for the path section of the URI.
    */
-  path?: MatcherPatternPath
+  path?: MatcherPatternPath | undefined
 
   /**
    * {@link MatcherPattern} for the query section of the URI.
    */
-  query?: MatcherPatternQuery[]
+  query?: MatcherPatternQuery[] | undefined
 
   /**
    * {@link MatcherPattern} for the hash section of the URI.
    */
-  hash?: MatcherPatternHash
+  hash?: MatcherPatternHash | undefined
 
   /**
    * Parent record. The parent can be a group or a matchable record.

packages/router/src/location.ts

@@ -24,8 +24,8 @@ export interface LocationNormalized {
  */
 interface LocationPartial {
   path: string
-  query?: LocationQueryRaw
-  hash?: string
+  query?: LocationQueryRaw | undefined
+  hash?: string | undefined
 }
 
 const TRAILING_SLASH_RE = /\/$/
@@ -212,8 +212,8 @@ export function isSameRouteLocationParams(
 }
 
 function isSameRouteLocationParamsValue(
-  a: RouteParamValue | readonly RouteParamValue[],
-  b: RouteParamValue | readonly RouteParamValue[]
+  a: RouteParamValue | readonly RouteParamValue[] | undefined,
+  b: RouteParamValue | readonly RouteParamValue[] | undefined
 ): boolean {
   return isArray(a)
     ? isEquivalentArray(a, b)