@tanstack/router-core 0.0.1-beta.14 → 0.0.1-beta.146

package/src/routeInfo.ts

@@ -1,228 +1,152 @@
-import { ParsePathParams } from './link'
-import { Route } from './route'
-import {
-  AnyLoaderData,
-  AnyPathParams,
-  AnyRouteConfig,
-  AnyRouteConfigWithChildren,
-  AnySearchSchema,
-  RootRouteId,
-  RouteConfig,
-  RouteOptions,
-} from './routeConfig'
-import { IsAny, Values } from './utils'
+import { AnyRoute, Route } from './route'
+import { AnyPathParams, AnySearchSchema, RootRouteId } from './route'
+import { IsAny, MergeUnion, Values } from './utils'
 
-export interface AnyAllRouteInfo {
-  routeConfig: AnyRouteConfig
-  routeInfo: AnyRouteInfo
-  routeInfoById: Record<string, AnyRouteInfo>
-  routeInfoByFullPath: Record<string, AnyRouteInfo>
+export interface AnyRoutesInfo {
+  routeTree: AnyRoute
+  routeUnion: AnyRoute
+  routesById: Record<string, AnyRoute>
+  routesByFullPath: Record<string, AnyRoute>
   routeIds: any
   routePaths: any
+  routeIntersection: AnyRoute
+  fullSearchSchema: Record<string, any>
+  allParams: Record<string, any>
 }
 
-export interface DefaultAllRouteInfo {
-  routeConfig: RouteConfig
-  routeInfo: RouteInfo
-  routeInfoById: Record<string, RouteInfo>
-  routeInfoByFullPath: Record<string, RouteInfo>
+export interface DefaultRoutesInfo {
+  routeTree: AnyRoute
+  routeUnion: AnyRoute
+  routesById: Record<string, Route>
+  routesByFullPath: Record<string, Route>
   routeIds: string
   routePaths: string
+  routeIntersection: AnyRoute
+  fullSearchSchema: AnySearchSchema
+  allParams: AnyPathParams
 }
 
-export interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig>
-  extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {}
-
-export type ParseRouteConfig<TRouteConfig = AnyRouteConfig> =
-  TRouteConfig extends AnyRouteConfig
-    ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig>
-    : never
-
-type ParseRouteChildren<TRouteConfig> =
-  TRouteConfig extends AnyRouteConfigWithChildren<infer TChildren>
-    ? unknown extends TChildren
-      ? never
-      : TChildren extends AnyRouteConfig[]
-      ? Values<{
-          [TId in TChildren[number]['id']]: ParseRouteChild<
-            TChildren[number],
-            TId
-          >
-        }>
-      : never // Children are not routes
-    : never // No children
-
-type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
-  id: TId
-} extends AnyRouteConfig
-  ? ParseRouteConfig<TRouteConfig>
-  : never
-
-export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
-  infer TId,
-  infer TRouteId,
-  infer TPath,
-  infer TFullPath,
-  infer TRouteLoaderData,
-  infer TLoaderData,
-  infer TActionPayload,
-  infer TActionResponse,
-  infer TParentSearchSchema,
-  infer TSearchSchema,
-  infer TFullSearchSchema,
-  infer TParentParams,
-  infer TParams,
-  infer TAllParams,
-  any
->
-  ? string extends TRouteId
-    ? never
-    : RouteInfo<
-        TId,
-        TRouteId,
-        TPath,
-        TFullPath,
-        TRouteLoaderData,
-        TLoaderData,
-        TActionPayload,
-        TActionResponse,
-        TParentSearchSchema,
-        TSearchSchema,
-        TFullSearchSchema,
-        TParentParams,
-        TParams,
-        TAllParams
-      >
-  : never
+export interface RoutesInfo<TRouteTree extends AnyRoute = Route>
+  extends RoutesInfoInner<TRouteTree, ParseRoute<TRouteTree>> {}
 
 export interface RoutesInfoInner<
-  TRouteConfig extends AnyRouteConfig,
-  TRouteInfo extends RouteInfo<
-    string,
-    string,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  > = RouteInfo,
-  TRouteInfoById = {
-    [TInfo in TRouteInfo as TInfo['id']]: TInfo
+  TRouteTree extends AnyRoute,
+  TRouteUnion extends AnyRoute = Route,
+  TRoutesById = { '/': TRouteUnion } & {
+    [TRoute in TRouteUnion as TRoute['id']]: TRoute
   },
-  TRouteInfoByFullPath = {
-    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId
+  // RoutePaths should always use index routes if possible, but not
+  // force trailing slashes. To do this, we check if each route
+  // has an index route registered and if it does, we omit the layout
+  // route. Then for any index routes, we remove the trailing slash
+  TRoutesByFullPath = { '/': TRouteUnion } & {
+    [TRoute in TRouteUnion as TRoute['fullPath'] extends RootRouteId
       ? never
-      : string extends TInfo['fullPath']
+      : string extends TRoute['fullPath']
       ? never
-      : TInfo['fullPath']]: TInfo
+      : `${TRoute['fullPath']}/` extends keyof TRoutesById
+      ? never
+      : TRoute['fullPath'] extends `${infer Trimmed}/`
+      ? Trimmed
+      : TRoute['fullPath']]: TRoute
   },
 > {
-  routeConfig: TRouteConfig
-  routeInfo: TRouteInfo
-  routeInfoById: TRouteInfoById
-  routeInfoByFullPath: TRouteInfoByFullPath
-  routeIds: keyof TRouteInfoById
-  routePaths: keyof TRouteInfoByFullPath
+  routeTree: TRouteTree
+  routeUnion: TRouteUnion
+  routesById: TRoutesById
+  routesByFullPath: TRoutesByFullPath
+  routeIds: keyof TRoutesById
+  routePaths: keyof TRoutesByFullPath
+  routeIntersection: Route<
+    TRouteUnion['__types']['parentRoute'], // TParentRoute,
+    TRouteUnion['__types']['path'], // TPath,
+    TRouteUnion['__types']['fullPath'], // TFullPath,
+    TRouteUnion['__types']['customId'], // TCustomId,
+    TRouteUnion['__types']['id'], // TId,
+    TRouteUnion['__types']['loader'], // TId,
+    MergeUnion<TRouteUnion['__types']['searchSchema']> & {}, // TSearchSchema,
+    MergeUnion<TRouteUnion['__types']['fullSearchSchema']> & {}, // TFullSearchSchema,
+    MergeUnion<TRouteUnion['__types']['params']>, // TParams,
+    MergeUnion<TRouteUnion['__types']['allParams']>, // TAllParams,
+    MergeUnion<TRouteUnion['__types']['parentContext']>, // TParentContext,
+    MergeUnion<TRouteUnion['__types']['allParentContext']>, // TAllParentContext,
+    MergeUnion<TRouteUnion['__types']['routeContext']> & {}, // TRouteContext,
+    MergeUnion<TRouteUnion['__types']['context']> & {}, // TContext,
+    MergeUnion<TRouteUnion['__types']['routerContext']> & {}, // TRouterContext,
+    TRouteUnion['__types']['children'], // TChildren,
+    TRouteUnion['__types']['routesInfo'] // TRoutesInfo,
+  >
+  fullSearchSchema: Partial<
+    MergeUnion<TRouteUnion['__types']['fullSearchSchema']>
+  >
+  allParams: Partial<MergeUnion<TRouteUnion['__types']['allParams']>>
 }
 
-export interface AnyRouteInfo
-  extends RouteInfo<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  > {}
+export type ParseRoute<TRouteTree> = TRouteTree extends AnyRoute
+  ? TRouteTree | ParseRouteChildren<TRouteTree>
+  : never
 
-export interface RouteInfo<
-  TId extends string = string,
-  TRouteId extends string = string,
-  TPath extends string = string,
-  TFullPath extends string = string,
-  TRouteLoaderData extends AnyLoaderData = {},
-  TLoaderData extends AnyLoaderData = {},
-  TActionPayload = unknown,
-  TActionResponse = unknown,
-  TParentSearchSchema extends {} = {},
-  TSearchSchema extends AnySearchSchema = {},
-  TFullSearchSchema extends AnySearchSchema = {},
-  TParentParams extends AnyPathParams = {},
-  TParams extends Record<ParsePathParams<TPath>, unknown> = Record<
-    ParsePathParams<TPath>,
-    string
-  >,
-  TAllParams extends AnyPathParams = {},
-> {
-  id: TId
-  routeId: TRouteId
-  path: TPath
-  fullPath: TFullPath
-  routeLoaderData: TRouteLoaderData
-  loaderData: TLoaderData
-  actionPayload: TActionPayload
-  actionResponse: TActionResponse
-  searchSchema: TSearchSchema
-  fullSearchSchema: TFullSearchSchema
-  parentParams: TParentParams
-  params: TParams
-  allParams: TAllParams
-  options: RouteOptions<
-    TRouteId,
-    TPath,
-    TRouteLoaderData,
-    TLoaderData,
-    TActionPayload,
-    TActionResponse,
-    TParentSearchSchema,
-    TSearchSchema,
-    TFullSearchSchema,
-    TParentParams,
-    TParams,
-    TAllParams
-  >
-}
+export type ParseRouteChildren<TRouteTree> = TRouteTree extends Route<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  infer TChildren,
+  any
+>
+  ? unknown extends TChildren
+    ? never
+    : TChildren extends AnyRoute[]
+    ? Values<{
+        [TId in TChildren[number]['id']]: ParseRouteChild<
+          TChildren[number],
+          TId
+        >
+      }>
+    : never
+  : never
 
-export type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
-  [K in keyof TAllRouteInfo['routeInfoById']]: Route<
-    TAllRouteInfo,
-    TAllRouteInfo['routeInfoById'][K]
-  >
+export type ParseRouteChild<TRoute, TId> = TRoute extends AnyRoute
+  ? ParseRoute<TRoute>
+  : never
+
+export type RoutesById<TRoutesInfo extends AnyRoutesInfo> = {
+  [K in keyof TRoutesInfo['routesById']]: TRoutesInfo['routesById'][K]
 }
 
-export type RouteInfoById<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type RouteById<
+  TRoutesInfo extends AnyRoutesInfo,
   TId,
-> = TId extends keyof TAllRouteInfo['routeInfoById']
+> = TId extends keyof TRoutesInfo['routesById']
   ? IsAny<
-      TAllRouteInfo['routeInfoById'][TId]['id'],
-      RouteInfo,
-      TAllRouteInfo['routeInfoById'][TId]
+      TRoutesInfo['routesById'][TId]['id'],
+      Route,
+      TRoutesInfo['routesById'][TId]
     >
   : never
 
-export type RouteInfoByPath<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type RoutesByPath<TRoutesInfo extends AnyRoutesInfo> = {
+  [K in keyof TRoutesInfo['routesByFullPath']]: TRoutesInfo['routesByFullPath'][K]
+}
+
+export type RouteByPath<
+  TRoutesInfo extends AnyRoutesInfo,
   TPath,
-> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath']
+> = TPath extends keyof TRoutesInfo['routesByFullPath']
   ? IsAny<
-      TAllRouteInfo['routeInfoByFullPath'][TPath]['id'],
-      RouteInfo,
-      TAllRouteInfo['routeInfoByFullPath'][TPath]
+      TRoutesInfo['routesByFullPath'][TPath]['id'],
+      Route,
+      TRoutesInfo['routesByFullPath'][TPath]
     >
   : never