Parse URL Params

In this medium-level challenge, you'll implement a type-level parser that extracts URL parameter names (prefixed with :) from a URL path string and produces a union of those parameter names.

ParseUrlParams<':id'> // id
ParseUrlParams<'posts/:id'> // id
ParseUrlParams<'posts/:id/:user'> // id | user

type cases = [
  Expect<Equal<ParseUrlParams<''>, never>>,
  Expect<Equal<ParseUrlParams<':id'>, 'id'>>,
  Expect<Equal<ParseUrlParams<'posts/:id'>, 'id'>>,
  Expect<Equal<ParseUrlParams<'posts/:id/'>, 'id'>>,
  Expect<Equal<ParseUrlParams<'posts/:id/:user'>, 'id' | 'user'>>,
  Expect<Equal<ParseUrlParams<'posts/:id/:user/like'>, 'id' | 'user'>>,
]

Detailed Explanation

type ParseUrlParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ParseUrlParams<Rest>
    : T extends `${string}:${infer Param}`
      ? Param
      : never

How it works:

• The first conditional checks if the string contains a :param followed by a / and more content. If so, it extracts the parameter name Param and recursively processes the Rest of the string.
• The second conditional handles the case where a :param appears at the end of the string with no trailing /. It extracts just that final parameter name.
• If neither pattern matches (no : parameter segments remain), it returns never, which is the identity element for union types.
• The ${string} prefix in each template literal pattern matches any leading characters before the :, allowing parameters to appear anywhere in the path.

This challenge helps you understand recursive template literal type parsing with infer and how to apply this concept in real-world scenarios like type-safe routing.