fix(unplugin): skip unnamed params in generated route types

Segments like `[[]]+` produce a param without a name. The param parsers
version of the type generation kept it, generating invalid types such as
`{ : string[] }` without reporting anything. Move the filtering (and the
VUE_ROUTER_B0017 report) into `normalizeParamsForTypes()` so both versions
drop unnamed params.

Author: posva

packages/router/src/unplugin/codegen/generateRouteMap.spec.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import { generateRouteNamedMap } from './generateRouteMap'
 import { PrefixTree } from '../core/tree'
 import { resolveOptions } from '../options'
+import { mockWarn } from '../../tests/vitest-mock-warn'
 
 const DEFAULT_OPTIONS = resolveOptions({})
 
@@ -1135,6 +1136,56 @@ describe('generateRouteNamedMap', () => {
       `)
     })
   })
+
+  describe('unnamed params', () => {
+    mockWarn()
+    const OPTIONS_WITH_PARSERS = resolveOptions({
+      experimental: { paramParsers: true },
+    })
+
+    it('skips unnamed params with param parsers enabled', () => {
+      const tree = new PrefixTree(OPTIONS_WITH_PARSERS)
+      // `[[]]+` produces a param without a name
+      tree.insert('[[]]+', '[[]]+.vue')
+      const routeMap = formatExports(
+        generateRouteNamedMap(tree, OPTIONS_WITH_PARSERS, new Map())
+      )
+      expect('VUE_ROUTER_B0017').toHaveBeenWarnedTimes(1)
+
+      expect(routeMap).toMatchInlineSnapshot(`
+        "export interface RouteNamedMap {
+          '/[[]]+': RouteRecordInfo<
+            '/[[]]+',
+            '/:*',
+            Record<never, never>,
+            Record<never, never>,
+            | never
+          >,
+        }"
+      `)
+    })
+
+    it('skips unnamed params without param parsers', () => {
+      const tree = new PrefixTree(DEFAULT_OPTIONS)
+      tree.insert('[[]]+', '[[]]+.vue')
+      const routeMap = formatExports(
+        generateRouteNamedMap(tree, DEFAULT_OPTIONS, new Map())
+      )
+      expect('VUE_ROUTER_B0017').toHaveBeenWarned()
+
+      expect(routeMap).toMatchInlineSnapshot(`
+        "export interface RouteNamedMap {
+          '/[[]]+': RouteRecordInfo<
+            '/[[]]+',
+            '/:*',
+            Record<never, never>,
+            Record<never, never>,
+            | never
+          >,
+        }"
+      `)
+    })
+  })
 })
 
 /**

packages/router/src/unplugin/codegen/generateRouteMap.ts

@@ -45,11 +45,14 @@ export function generateRouteRecordInfo(
   options: ResolvedOptions,
   paramParsersMap: ParamParsersMap
 ): string {
-  let paramParsers: Array<string | null> = []
-  const params = normalizeParamsForTypes(node.params)
-  if (options.experimental.paramParsers) {
-    paramParsers = generateParamsTypes(params, paramParsersMap)
-  }
+  // only the experimental version handles query params and param parsers, the
+  // other one extracts the params from the node itself
+  const params = options.experimental.paramParsers
+    ? normalizeParamsForTypes(node, node.params)
+    : []
+  const paramParsers: Array<string | null> = options.experimental.paramParsers
+    ? generateParamsTypes(params, paramParsersMap)
+    : []
 
   const typeParams = [
     toStringLiteral(node.name),

packages/router/src/unplugin/codegen/generateRouteParams.ts

@@ -10,18 +10,27 @@ import type { ParamParsersMap } from './generateParamParsers'
 import { diagnostics } from '../diagnostics'
 
 /**
- * Prepares params to be rendered as a type: a param can be declared more than
- * once across the chain of records, and duplicated keys are invalid in a type
- * literal. The deepest declaration wins like at runtime, then params are sorted
- * by name to keep the generated types stable.
+ * Prepares params to be rendered as a type: params without a name are dropped
+ * and reported as they would generate invalid types. A param can also be
+ * declared more than once across the chain of records, and duplicated keys are
+ * invalid in a type literal, so the deepest declaration wins like at runtime.
+ * Params are then sorted by name to keep the generated types stable.
  *
  * @internal
  */
 export function normalizeParamsForTypes<
   T extends TreePathParam | TreeQueryParam,
->(params: T[]): T[] {
+>(node: TreeNode, params: T[]): T[] {
   const byName = new Map<string, T>()
   for (const param of params) {
+    // invalid segments like `[[]]+` produce params without a name
+    if (!param.paramName) {
+      diagnostics.VUE_ROUTER_B0017({
+        fullPath: node.fullPath,
+        path: node.path,
+      })
+      continue
+    }
     byName.set(param.paramName, param)
   }
 
@@ -34,18 +43,7 @@ export function normalizeParamsForTypes<
 export function generateRouteParams(node: TreeNode, isRaw: boolean): string {
   // node.pathParams is a getter so we compute it once
   // this version does not support query params
-  const nodeParams = normalizeParamsForTypes(
-    node.pathParams.filter(param => {
-      if (!param.paramName) {
-        diagnostics.VUE_ROUTER_B0017({
-          fullPath: node.fullPath,
-          path: node.path,
-        })
-        return false
-      }
-      return true
-    })
-  )
+  const nodeParams = normalizeParamsForTypes(node, node.pathParams)
   return nodeParams.length > 0
     ? `{ ${nodeParams
         .map(