Match alphanumeric params only

src/types/routeMethods.test-d.ts

@@ -405,4 +405,23 @@ test('public parent routes have correct type for parameters', () => {
     param2: string,
     param3: boolean,
   }]>()
+})
+
+test('param names must be alphanumeric', () => {
+  const routes = [
+    {
+      name: 'foo',
+      path: '/:param1-:param2/:param3_:param4',
+      component,
+    },
+  ] as const satisfies Routes
+
+  const router = createRouter(routes)
+
+  expectTypeOf(router.routes.foo).parameters.toEqualTypeOf<[{
+    param1: string,
+    param2: string,
+    param3: string,
+    param4: string,
+  }]>()
 })

src/types/routeMethods.ts

@@ -1,6 +1,6 @@
 import { Param, ParamGetSet, ParamGetter } from '@/types/params'
 import { Route, Routes } from '@/types/routes'
-import { Identity, IsAny, IsEmptyObject, TupleCanBeAllUndefined, UnionToIntersection } from '@/types/utilities'
+import { Identity, IsAny, IsEmptyObject, ReplaceAll, TupleCanBeAllUndefined, UnionToIntersection } from '@/types/utilities'
 import { Path } from '@/utilities/path'
 
 export type RouteMethod<
@@ -58,17 +58,23 @@ export type ExtractRouteMethodParams<T> = T extends RouteMethod<infer Params>
 export type ExtractParamsFromPath<
   TPath extends Route['path']
 > = TPath extends Path
-  ? ExtractParamsFromPathString<TPath['path'], TPath['params']>
+  ? ExtractParamsFromPathString<UnifyParamEnds<TPath['path']>, TPath['params']>
   : TPath extends string
-    ? ExtractParamsFromPathString<TPath>
+    ? ExtractParamsFromPathString<UnifyParamEnds<TPath>>
     : never
 
+type ParamEnd = '/'
+
+type UnifyParamEnds<
+  TPath extends string
+> = ReplaceAll<ReplaceAll<TPath, '-', ParamEnd>, '_', ParamEnd>
+
 export type ExtractParamsFromPathString<
   TPath extends string,
   TParams extends Record<string, Param> = Record<never, never>
-> = TPath extends `${infer Path}/`
+> = TPath extends `${infer Path}${ParamEnd}`
   ? ExtractParamsFromPathString<Path, TParams>
-  : TPath extends `${string}:${infer Param}/${infer Rest}`
+  : TPath extends `${string}:${infer Param}${ParamEnd}${infer Rest}`
     ? MergeParams<{ [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams> }, ExtractParamsFromPathString<Rest, TParams>>
     : TPath extends `${string}:${infer Param}`
       ? { [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams> }

src/types/utilities.ts

@@ -36,4 +36,13 @@ export type UnionToIntersection<Union> = (
   ? Intersection & Union
   : never
 
-export type MaybeLazy<T> = T | (() => Promise<T>)
+export type MaybeLazy<T> = T | (() => Promise<T>)
+
+// Copied and modified from [type-fest](https://github.com/sindresorhus/type-fest/blob/main/source/replace.d.ts)
+export type ReplaceAll<
+  Input extends string,
+  Search extends string,
+  Replacement extends string
+> = Input extends `${infer Head}${Search}${infer Tail}`
+  ? `${Head}${Replacement}${ReplaceAll<Tail, Search, Replacement>}`
+  : Input