refactor: remove ParamParseSegment and use PathParam

Author: tyankatsu0105

docs/hooks/use-match.md

@@ -8,8 +8,8 @@ title: useMatch
   <summary>Type declaration</summary>
 
 ```tsx
-declare function useMatch<ParamKey extends string = string>(
-  pattern: PathPattern | string
+declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(
+  pattern: PathPattern<Path> | Path
 ): PathMatch<ParamKey> | null;
 ```
 

packages/router/utils.ts

@@ -159,51 +159,35 @@ export interface DataRouteObject extends RouteObject {
   id: string;
 }
 
-type ParamParseFailed = { failed: true };
-
-type ParamParseSegment<Segment extends string> =
-  // Check here if there exists a forward slash in the string.
-  Segment extends `${infer LeftSegment}/${infer RightSegment}`
-    ? // If there is a forward slash, then attempt to parse each side of the
-      // forward slash.
-      ParamParseSegment<LeftSegment> extends infer LeftResult
-      ? ParamParseSegment<RightSegment> extends infer RightResult
-        ? LeftResult extends string
-          ? // If the left side is successfully parsed as a param, then check if
-            // the right side can be successfully parsed as well. If both sides
-            // can be parsed, then the result is a union of the two sides
-            // (read: "foo" | "bar").
-            RightResult extends string
-            ? LeftResult | RightResult
-            : LeftResult
-          : // If the left side is not successfully parsed as a param, then check
-          // if only the right side can be successfully parse as a param. If it
-          // can, then the result is just right, else it's a failure.
-          RightResult extends string
-          ? RightResult
-          : ParamParseFailed
-        : ParamParseFailed
-      : // If the left side didn't parse into a param, then just check the right
-      // side.
-      ParamParseSegment<RightSegment> extends infer RightResult
-      ? RightResult extends string
-        ? RightResult
-        : ParamParseFailed
-      : ParamParseFailed
-    : // If there's no forward slash, then check if this segment starts with a
-    // colon. If it does, then this is a dynamic segment, so the result is
-    // just the remainder of the string, optionally prefixed with another string.
-    // Otherwise, it's a failure.
-    Segment extends `${string}:${infer Remaining}`
-    ? Remaining
-    : ParamParseFailed;
+type Star = "*"
+/**
+ * @private
+ * Return string union from path string.
+ * @example
+ * PathParam<"/path/:a/:b"> // "a" | "b"
+ * PathParam<"/path/:a/:b/*"> // "a" | "b" | "*"
+ */
+ type PathParam<
+ Path extends string
+> = 
+    Path extends `:${infer Param}/${infer Rest}`
+      ? Param | PathParam<Rest>
+      : Path extends `:${infer Param}`
+        ? Param
+        : Path extends `${any}:${infer Param}`
+            ? PathParam<`:${Param}`>
+            : Path extends `${any}/${Star}`
+              ? Star
+              : Path extends Star
+                ? Star 
+                : never
 
 // Attempt to parse the given string segment. If it fails, then just return the
 // plain string type as a default fallback. Otherwise return the union of the
 // parsed string literals that were referenced as dynamic segments in the route.
 export type ParamParseKey<Segment extends string> =
-  ParamParseSegment<Segment> extends string
-    ? ParamParseSegment<Segment>
+  [PathParam<Segment>] extends [never]
+    ? PathParam<Segment>
     : string;
 
 /**
@@ -441,24 +425,6 @@ function matchRouteBranch<
   return matches;
 }
 
-/**
- * @private
- * Parameters in the path
- */
- type PathParam<
- Path extends string
-> = Path extends `:${infer Param}/${infer Rest}`
-   ? Param | PathParam<Rest>
-   : Path extends `:${infer Param}`
-     ? Param
-     : Path extends `${any}:${infer Param}`
-         ? PathParam<`:${Param}`>
-         : Path extends `${any}/*`
-           ? "*"
-           : Path extends "*"
-             ? "*" 
-             : never
-
 /**
  * Returns a path with params interpolated.
  *