@tanstack/router-core 0.0.1-beta.151 → 0.0.1-beta.153

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/router-core",
   "author": "Tanner Linsley",
-  "version": "0.0.1-beta.151",
+  "version": "0.0.1-beta.153",
   "license": "MIT",
   "repository": "tanstack/router",
   "homepage": "https://tanstack.com/router",
@@ -43,7 +43,7 @@
     "tiny-invariant": "^1.3.1",
     "tiny-warning": "^1.0.3",
     "@gisatcz/cross-package-react-context": "^0.2.0",
-    "@tanstack/react-store": "0.0.1-beta.151"
+    "@tanstack/react-store": "0.0.1-beta.153"
   },
   "scripts": {
     "build": "rollup --config rollup.config.js",

package/src/fileRoute.ts

@@ -1,8 +1,7 @@
-import { Last, ParsePathParams, Split } from './link'
+import { ParsePathParams } from './link'
 import {
   AnyRoute,
   ResolveFullPath,
-  ResolveId,
   AnySearchSchema,
   ResolveFullSearchSchema,
   MergeParamsFromParent,
@@ -12,8 +11,11 @@ import {
   InferFullSearchSchema,
   UpdatableRouteOptions,
   Route,
+  AnyPathParams,
+  RootRouteId,
+  TrimPathLeft,
+  RouteConstraints,
 } from './route'
-import { DefaultRoutesInfo } from './routeInfo'
 
 export interface FileRoutesByPath {
   // '/': {
@@ -21,62 +23,102 @@ export interface FileRoutesByPath {
   // }
 }
 
+type Replace<
+  S extends string,
+  From extends string,
+  To extends string,
+> = S extends `${infer Start}${From}${infer Rest}`
+  ? `${Start}${To}${Replace<Rest, From, To>}`
+  : S
+
+export type TrimLeft<
+  T extends string,
+  S extends string,
+> = T extends `${S}${infer U}` ? U : T
+
+export type TrimRight<
+  T extends string,
+  S extends string,
+> = T extends `${infer U}${S}` ? U : T
+
+export type Trim<T extends string, S extends string> = TrimLeft<
+  TrimRight<T, S>,
+  S
+>
+
+export type RemoveUnderScores<T extends string> = Replace<
+  Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>,
+  '/_',
+  '/'
+>
+
+export type ResolveFilePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = TParentRoute['id'] extends RootRouteId
+  ? TrimPathLeft<TFilePath>
+  : Replace<
+      TrimPathLeft<TFilePath>,
+      TrimPathLeft<TParentRoute['__types']['customId']>,
+      ''
+    >
+
+export type FileRoutePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`
+  ? string
+  : ResolveFilePath<TParentRoute, TFilePath>
+
 export class FileRoute<
   TFilePath extends keyof FileRoutesByPath,
   TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
-  TPath extends string = Last<Split<TFilePath>>,
-  TCustomId extends string = TPath extends `_${infer T}` ? T : string,
+  TId extends RouteConstraints['TId'] = TFilePath,
+  TPath extends RouteConstraints['TPath'] = FileRoutePath<
+    TParentRoute,
+    TFilePath
+  >,
+  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<
+    TParentRoute,
+    RemoveUnderScores<TPath>
+  >,
 > {
   constructor(public path: TFilePath) {}
 
   createRoute = <
-    TFullPath extends ResolveFullPath<TParentRoute, TPath> = ResolveFullPath<
-      TParentRoute,
-      TPath
-    >,
-    TId extends ResolveId<TParentRoute, TCustomId, TPath> = ResolveId<
-      TParentRoute,
-      TCustomId,
-      TPath
-    >,
     TLoader = unknown,
-    TSearchSchema extends AnySearchSchema = {},
-    TFullSearchSchema extends AnySearchSchema = ResolveFullSearchSchema<
+    TSearchSchema extends RouteConstraints['TSearchSchema'] = {},
+    TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<
       TParentRoute,
       TSearchSchema
     >,
-    TParams extends Record<ParsePathParams<TPath>, any> = Record<
-      ParsePathParams<TPath>,
-      string
-    >,
-    TAllParams extends MergeParamsFromParent<
+    TParams extends RouteConstraints['TParams'] = ParsePathParams<TPath> extends never
+      ? AnyPathParams
+      : Record<ParsePathParams<TPath>, RouteConstraints['TPath']>,
+    TAllParams extends RouteConstraints['TAllParams'] = MergeParamsFromParent<
       TParentRoute['__types']['allParams'],
       TParams
-    > = MergeParamsFromParent<TParentRoute['__types']['allParams'], TParams>,
-    TParentContext extends TParentRoute['__types']['routeContext'] = TParentRoute['__types']['routeContext'],
-    TAllParentContext extends TParentRoute['__types']['context'] = TParentRoute['__types']['context'],
-    TRouteContext extends RouteContext = RouteContext,
-    TContext extends MergeParamsFromParent<
-      TParentRoute['__types']['context'],
-      TRouteContext
-    > = MergeParamsFromParent<
+    >,
+    TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['__types']['routeContext'],
+    TAllParentContext extends RouteConstraints['TId'] = TParentRoute['__types']['context'],
+    TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext,
+    TContext extends RouteConstraints['TContext'] = MergeParamsFromParent<
       TParentRoute['__types']['context'],
       TRouteContext
     >,
-    TRouterContext extends AnyContext = AnyContext,
-    TChildren extends unknown = unknown,
-    TRoutesInfo extends DefaultRoutesInfo = DefaultRoutesInfo,
+    TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext,
+    TChildren extends RouteConstraints['TChildren'] = unknown,
+    TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute,
   >(
     options: Omit<
       RouteOptions<
         TParentRoute,
-        TCustomId,
-        TPath,
+        string,
+        string,
         TLoader,
         InferFullSearchSchema<TParentRoute>,
         TSearchSchema,
         TFullSearchSchema,
-        TParentRoute['__types']['allParams'],
         TParams,
         TAllParams,
         TParentContext,
@@ -98,7 +140,7 @@ export class FileRoute<
     TParentRoute,
     TPath,
     TFullPath,
-    TCustomId,
+    TFilePath,
     TId,
     TLoader,
     TSearchSchema,
@@ -111,7 +153,7 @@ export class FileRoute<
     TContext,
     TRouterContext,
     TChildren,
-    TRoutesInfo
+    TRouteTree
   > => {
     const route = new Route(options as any)
     ;(route as any).isRoot = false

package/src/link.ts

@@ -1,5 +1,13 @@
-import { AnyRoutesInfo, RouteByPath } from './routeInfo'
-import { ParsedLocation, LocationState, RegisteredRoutesInfo } from './router'
+import { Trim } from './fileRoute'
+import { AnyRoute } from './route'
+import {
+  AllParams,
+  FullSearchSchema,
+  RouteByPath,
+  RouteIds,
+  RoutePaths,
+} from './routeInfo'
+import { ParsedLocation, LocationState } from './router'
 import { NoInfer, PickRequired, UnionToIntersection, Updater } from './utils'
 
 export type LinkInfo =
@@ -19,7 +27,7 @@ export type LinkInfo =
       disabled?: boolean
     }
 
-type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
+export type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
   ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`>
   : T extends `${infer L}//`
   ? `${CleanPath<L>}/`
@@ -49,11 +57,9 @@ export type Split<S, TIncludeTrailingSlash = true> = S extends unknown
     : never
   : never
 
-export type ParsePathParams<T extends string> = Split<T>[number] extends infer U
-  ? U extends `$${infer V}`
-    ? V
-    : never
-  : never
+export type ParsePathParams<T extends string> = keyof {
+  [K in Trim<Split<T>[number], '_'> as K extends `$${infer L}` ? L : never]: K
+}
 
 export type Join<T, Delimiter extends string = '/'> = T extends []
   ? ''
@@ -112,21 +118,21 @@ export type RelativeToPathAutoComplete<
       | AllPaths
 
 export type NavigateOptions<
-  TRoutesInfo extends AnyRoutesInfo = RegisteredRoutesInfo,
-  TFrom extends TRoutesInfo['routePaths'] = '/',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
   TTo extends string = '',
-> = ToOptions<TRoutesInfo, TFrom, TTo> & {
+> = ToOptions<TRouteTree, TFrom, TTo> & {
   // `replace` is a boolean that determines whether the navigation should replace the current history entry or push a new one.
   replace?: boolean
 }
 
 export type ToOptions<
-  TRoutesInfo extends AnyRoutesInfo = RegisteredRoutesInfo,
-  TFrom extends TRoutesInfo['routePaths'] = '/',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
   TTo extends string = '',
   TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>,
 > = {
-  to?: ToPathOption<TRoutesInfo, TFrom, TTo>
+  to?: ToPathOption<TRouteTree, TFrom, TTo>
   // The new has string or a function to update it
   hash?: Updater<string>
   // State to pass to the history stack
@@ -135,37 +141,34 @@ export type ToOptions<
   from?: TFrom
   // // When using relative route paths, this option forces resolution from the current path, instead of the route API's path or `from` path
   // fromCurrent?: boolean
-} & CheckPath<TRoutesInfo, NoInfer<TResolvedTo>, {}> &
-  SearchParamOptions<TRoutesInfo, TFrom, TResolvedTo> &
-  PathParamOptions<TRoutesInfo, TFrom, TResolvedTo>
+} & CheckPath<TRouteTree, NoInfer<TResolvedTo>, {}> &
+  SearchParamOptions<TRouteTree, TFrom, TResolvedTo> &
+  PathParamOptions<TRouteTree, TFrom, TResolvedTo>
 
 export type SearchParamOptions<
-  TRoutesInfo extends AnyRoutesInfo,
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
   TFromSchema = UnionToIntersection<
-    TRoutesInfo['fullSearchSchema'] &
-      RouteByPath<TRoutesInfo, TFrom> extends never
+    FullSearchSchema<TRouteTree> & RouteByPath<TRouteTree, TFrom> extends never
       ? {}
-      : RouteByPath<TRoutesInfo, TFrom>['__types']['fullSearchSchema']
+      : RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']
   >,
   // Find the schema for the new path, and make optional any keys
   // that are already defined in the current schema
   TToSchema = Partial<
-    RouteByPath<TRoutesInfo, TFrom>['__types']['fullSearchSchema']
+    RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']
   > &
     Omit<
-      RouteByPath<TRoutesInfo, TTo>['__types']['fullSearchSchema'],
+      RouteByPath<TRouteTree, TTo>['__types']['fullSearchSchema'],
       keyof PickRequired<
-        RouteByPath<TRoutesInfo, TFrom>['__types']['fullSearchSchema']
+        RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']
       >
     >,
   TFromFullSchema = UnionToIntersection<
-    TRoutesInfo['fullSearchSchema'] & TFromSchema
-  >,
-  TToFullSchema = UnionToIntersection<
-    TRoutesInfo['fullSearchSchema'] & TToSchema
+    FullSearchSchema<TRouteTree> & TFromSchema
   >,
+  TToFullSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & TToSchema>,
 > = keyof PickRequired<TToSchema> extends never
   ? {
       search?: true | SearchReducer<TFromFullSchema, TToFullSchema>
@@ -179,25 +182,23 @@ type SearchReducer<TFrom, TTo> =
   | ((current: TFrom) => TTo)
 
 export type PathParamOptions<
-  TRoutesInfo extends AnyRoutesInfo,
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
   TFromSchema = UnionToIntersection<
-    RouteByPath<TRoutesInfo, TFrom> extends never
+    RouteByPath<TRouteTree, TFrom> extends never
       ? {}
-      : RouteByPath<TRoutesInfo, TFrom>['__types']['allParams']
+      : RouteByPath<TRouteTree, TFrom>['__types']['allParams']
   >,
   // Find the schema for the new path, and make optional any keys
   // that are already defined in the current schema
-  TToSchema = Partial<RouteByPath<TRoutesInfo, TFrom>['__types']['allParams']> &
+  TToSchema = Partial<RouteByPath<TRouteTree, TFrom>['__types']['allParams']> &
     Omit<
-      RouteByPath<TRoutesInfo, TTo>['__types']['allParams'],
-      keyof PickRequired<
-        RouteByPath<TRoutesInfo, TFrom>['__types']['allParams']
-      >
+      RouteByPath<TRouteTree, TTo>['__types']['allParams'],
+      keyof PickRequired<RouteByPath<TRouteTree, TFrom>['__types']['allParams']>
     >,
-  TFromFullParams = UnionToIntersection<TRoutesInfo['allParams'] & TFromSchema>,
-  TToFullParams = UnionToIntersection<TRoutesInfo['allParams'] & TToSchema>,
+  TFromFullParams = UnionToIntersection<AllParams<TRouteTree> & TFromSchema>,
+  TToFullParams = UnionToIntersection<AllParams<TRouteTree> & TToSchema>,
 > = keyof PickRequired<TToSchema> extends never
   ? {
       params?: ParamsReducer<TFromFullParams, TToFullParams>
@@ -209,25 +210,25 @@ export type PathParamOptions<
 type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
 
 export type ToPathOption<
-  TRoutesInfo extends AnyRoutesInfo = RegisteredRoutesInfo,
-  TFrom extends TRoutesInfo['routePaths'] = '/',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
   TTo extends string = '',
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TRoutesInfo['routePaths'],
+      RoutePaths<TRouteTree>,
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
 
 export type ToIdOption<
-  TRoutesInfo extends AnyRoutesInfo = RegisteredRoutesInfo,
-  TFrom extends TRoutesInfo['routePaths'] = '/',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
   TTo extends string = '',
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TRoutesInfo['routeIds'],
+      RouteIds<TRouteTree>,
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
@@ -239,10 +240,10 @@ export interface ActiveOptions {
 }
 
 export type LinkOptions<
-  TRoutesInfo extends AnyRoutesInfo = RegisteredRoutesInfo,
-  TFrom extends TRoutesInfo['routePaths'] = '/',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
   TTo extends string = '',
-> = NavigateOptions<TRoutesInfo, TFrom, TTo> & {
+> = NavigateOptions<TRouteTree, TFrom, TTo> & {
   // The standard anchor tag target attribute
   target?: HTMLAnchorElement['target']
   // Defaults to `{ exact: false, includeHash: false }`
@@ -256,47 +257,46 @@ export type LinkOptions<
 }
 
 export type CheckRelativePath<
-  TRoutesInfo extends AnyRoutesInfo,
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
 > = TTo extends string
   ? TFrom extends string
-    ? ResolveRelativePath<TFrom, TTo> extends TRoutesInfo['routePaths']
+    ? ResolveRelativePath<TFrom, TTo> extends RoutePaths<TRouteTree>
       ? {}
       : {
           Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<
             TFrom,
             TTo
           >}, which is not a valid route path.`
-          'Valid Route Paths': TRoutesInfo['routePaths']
+          'Valid Route Paths': RoutePaths<TRouteTree>
         }
     : {}
   : {}
 
-export type CheckPath<
-  TRoutesInfo extends AnyRoutesInfo,
+export type CheckPath<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<
   TPath,
-  TPass,
-> = Exclude<TPath, TRoutesInfo['routePaths']> extends never
+  RoutePaths<TRouteTree>
+> extends never
   ? TPass
-  : CheckPathError<TRoutesInfo, Exclude<TPath, TRoutesInfo['routePaths']>>
+  : CheckPathError<TRouteTree, Exclude<TPath, RoutePaths<TRouteTree>>>
 
-export type CheckPathError<TRoutesInfo extends AnyRoutesInfo, TInvalids> = {
-  to: TRoutesInfo['routePaths']
+export type CheckPathError<TRouteTree extends AnyRoute, TInvalids> = {
+  to: RoutePaths<TRouteTree>
 }
 
-export type CheckId<TRoutesInfo extends AnyRoutesInfo, TPath, TPass> = Exclude<
+export type CheckId<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<
   TPath,
-  TRoutesInfo['routeIds']
+  RouteIds<TRouteTree>
 > extends never
   ? TPass
-  : CheckIdError<TRoutesInfo, Exclude<TPath, TRoutesInfo['routeIds']>>
+  : CheckIdError<TRouteTree, Exclude<TPath, RouteIds<TRouteTree>>>
 
-export type CheckIdError<TRoutesInfo extends AnyRoutesInfo, TInvalids> = {
+export type CheckIdError<TRouteTree extends AnyRoute, TInvalids> = {
   Error: `${TInvalids extends string
     ? TInvalids
     : never} is not a valid route ID.`
-  'Valid Route IDs': TRoutesInfo['routeIds']
+  'Valid Route IDs': RouteIds<TRouteTree>
 }
 
 export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string