@tanstack/router-core 0.0.1-beta.8 → 1.20.3-alpha.1

package/src/routeInfo.ts

@@ -1,228 +1,235 @@
-import { ParsePathParams } from './link'
-import { Route } from './route'
-import {
-  AnyLoaderData,
-  AnyPathParams,
-  AnyRouteConfig,
-  AnyRouteConfigWithChildren,
-  AnySearchSchema,
-  RootRouteId,
-  RouteConfig,
-  RouteOptions,
-} from './routeConfig'
-import { IsAny, Values } from './utils'
-
-export interface AnyAllRouteInfo {
-  routeConfig: AnyRouteConfig
-  routeInfo: AnyRouteInfo
-  routeInfoById: Record<string, AnyRouteInfo>
-  routeInfoByFullPath: Record<string, AnyRouteInfo>
-  routeIds: any
-  routePaths: any
-}
+import type { InferFileRouteTypes } from './fileRoute'
+import type { AddTrailingSlash, RemoveTrailingSlashes } from './link'
+import type { AnyRoute } from './route'
+import type { AnyRouter, TrailingSlashOption } from './router'
+import type { PartialMergeAll } from './utils'
 
-export interface DefaultAllRouteInfo {
-  routeConfig: RouteConfig
-  routeInfo: RouteInfo
-  routeInfoById: Record<string, RouteInfo>
-  routeInfoByFullPath: Record<string, RouteInfo>
-  routeIds: string
-  routePaths: string
+export type ParseRoute<TRouteTree, TAcc = TRouteTree> = TRouteTree extends {
+  types: { children: infer TChildren }
 }
+  ? unknown extends TChildren
+    ? TAcc
+    : TChildren extends ReadonlyArray<any>
+      ? ParseRoute<TChildren[number], TAcc | TChildren[number]>
+      : ParseRoute<
+          TChildren[keyof TChildren],
+          TAcc | TChildren[keyof TChildren]
+        >
+  : TAcc
 
-export interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig>
-  extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {}
+export type ParseRouteWithoutBranches<TRouteTree> =
+  ParseRoute<TRouteTree> extends infer TRoute extends AnyRoute
+    ? TRoute extends any
+      ? unknown extends TRoute['types']['children']
+        ? TRoute
+        : TRoute['types']['children'] extends ReadonlyArray<any>
+          ? '/' extends TRoute['types']['children'][number]['path']
+            ? never
+            : TRoute
+          : '/' extends TRoute['types']['children'][keyof TRoute['types']['children']]['path']
+            ? never
+            : TRoute
+      : never
+    : never
 
-export type ParseRouteConfig<TRouteConfig = AnyRouteConfig> =
-  TRouteConfig extends AnyRouteConfig
-    ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig>
+export type CodeRoutesById<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? {
+        [K in TRoutes as K['id']]: K
+      }
     : 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
+export type RoutesById<TRouteTree extends AnyRoute> =
+  InferFileRouteTypes<TRouteTree> extends never
+    ? CodeRoutesById<TRouteTree>
+    : InferFileRouteTypes<TRouteTree>['fileRoutesById']
+
+export type RouteById<TRouteTree extends AnyRoute, TId> = Extract<
+  RoutesById<TRouteTree>[TId & keyof RoutesById<TRouteTree>],
+  AnyRoute
 >
-  ? string extends TRouteId
-    ? never
-    : RouteInfo<
-        TId,
-        TRouteId,
-        TPath,
-        TFullPath,
-        TRouteLoaderData,
-        TLoaderData,
-        TActionPayload,
-        TActionResponse,
-        TParentSearchSchema,
-        TSearchSchema,
-        TFullSearchSchema,
-        TParentParams,
-        TParams,
-        TAllParams
-      >
-  : never
-
-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
-  },
-  TRouteInfoByFullPath = {
-    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId
-      ? never
-      : string extends TInfo['fullPath']
-      ? never
-      : TInfo['fullPath']]: TInfo
-  },
-> {
-  routeConfig: TRouteConfig
-  routeInfo: TRouteInfo
-  routeInfoById: TRouteInfoById
-  routeInfoByFullPath: TRouteInfoByFullPath
-  routeIds: keyof TRouteInfoById
-  routePaths: keyof TRouteInfoByFullPath
-}
 
-export interface AnyRouteInfo
-  extends RouteInfo<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  > {}
-
-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 CodeRouteIds<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? TRoutes['id']
+    : never
+
+export type RouteIds<TRouteTree extends AnyRoute> =
+  InferFileRouteTypes<TRouteTree> extends never
+    ? CodeRouteIds<TRouteTree>
+    : InferFileRouteTypes<TRouteTree>['id']
+
+export type ParentPath<TRouter extends AnyRouter> =
+  TrailingSlashOptionByRouter<TRouter> extends 'always'
+    ? '../'
+    : TrailingSlashOptionByRouter<TRouter> extends 'never'
+      ? '..'
+      : '../' | '..'
+
+export type CurrentPath<TRouter extends AnyRouter> =
+  TrailingSlashOptionByRouter<TRouter> extends 'always'
+    ? './'
+    : TrailingSlashOptionByRouter<TRouter> extends 'never'
+      ? '.'
+      : './' | '.'
+
+export type ToPath<TRouter extends AnyRouter, TTo extends string> =
+  TrailingSlashOptionByRouter<TRouter> extends 'always'
+    ? AddTrailingSlash<TTo>
+    : TrailingSlashOptionByRouter<TRouter> extends 'never'
+      ? RemoveTrailingSlashes<TTo>
+      : AddTrailingSlash<TTo> | RemoveTrailingSlashes<TTo>
+
+export type CatchAllPaths<TRouter extends AnyRouter> =
+  | CurrentPath<TRouter>
+  | ParentPath<TRouter>
+
+export type CodeRoutesByPath<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? {
+        [K in TRoutes as K['fullPath']]: K
+      }
+    : never
+
+export type RoutesByPath<TRouteTree extends AnyRoute> =
+  InferFileRouteTypes<TRouteTree> extends never
+    ? CodeRoutesByPath<TRouteTree>
+    : InferFileRouteTypes<TRouteTree>['fileRoutesByFullPath']
+
+export type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<
+  RoutesByPath<TRouteTree>[TPath & keyof RoutesByPath<TRouteTree>],
+  AnyRoute
+>
+
+export type CodeRoutePaths<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? TRoutes['fullPath']
+    : never
+
+export type RoutePaths<TRouteTree extends AnyRoute> = unknown extends TRouteTree
+  ? string
+  :
+      | (InferFileRouteTypes<TRouteTree> extends never
+          ? CodeRoutePaths<TRouteTree>
+          : InferFileRouteTypes<TRouteTree>['fullPaths'])
+      | '/'
+
+export type RouteToPathAlwaysTrailingSlash<TRoute extends AnyRoute> =
+  TRoute['path'] extends '/'
+    ? TRoute['fullPath']
+    : TRoute['fullPath'] extends '/'
+      ? TRoute['fullPath']
+      : `${TRoute['fullPath']}/`
+
+export type RouteToPathNeverTrailingSlash<TRoute extends AnyRoute> =
+  TRoute['path'] extends '/'
+    ? TRoute['fullPath'] extends '/'
+      ? TRoute['fullPath']
+      : RemoveTrailingSlashes<TRoute['fullPath']>
+    : TRoute['fullPath']
+
+export type RouteToPathPreserveTrailingSlash<TRoute extends AnyRoute> =
+  | RouteToPathNeverTrailingSlash<TRoute>
+  | RouteToPathAlwaysTrailingSlash<TRoute>
 
-export type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
-  [K in keyof TAllRouteInfo['routeInfoById']]: Route<
-    TAllRouteInfo,
-    TAllRouteInfo['routeInfoById'][K]
-  >
+export type RouteToPathByTrailingSlashOption<TRoute extends AnyRoute> = {
+  always: RouteToPathAlwaysTrailingSlash<TRoute>
+  preserve: RouteToPathPreserveTrailingSlash<TRoute>
+  never: RouteToPathNeverTrailingSlash<TRoute>
 }
 
-export type RouteInfoById<
-  TAllRouteInfo extends AnyAllRouteInfo,
-  TId,
-> = TId extends keyof TAllRouteInfo['routeInfoById']
-  ? IsAny<
-      TAllRouteInfo['routeInfoById'][TId]['id'],
-      RouteInfo,
-      TAllRouteInfo['routeInfoById'][TId]
-    >
-  : never
-
-export type RouteInfoByPath<
-  TAllRouteInfo extends AnyAllRouteInfo,
-  TPath,
-> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath']
-  ? IsAny<
-      TAllRouteInfo['routeInfoByFullPath'][TPath]['id'],
-      RouteInfo,
-      TAllRouteInfo['routeInfoByFullPath'][TPath]
-    >
-  : never
+export type TrailingSlashOptionByRouter<TRouter extends AnyRouter> =
+  TrailingSlashOption extends TRouter['options']['trailingSlash']
+    ? 'never'
+    : NonNullable<TRouter['options']['trailingSlash']>
+
+export type RouteToByRouter<
+  TRouter extends AnyRouter,
+  TRoute extends AnyRoute,
+> = RouteToPathByTrailingSlashOption<TRoute>[TrailingSlashOptionByRouter<TRouter>]
+
+export type CodeRouteToPath<TRouter extends AnyRouter> =
+  ParseRouteWithoutBranches<TRouter['routeTree']> extends infer TRoute extends
+    AnyRoute
+    ? TRoute extends any
+      ? RouteToByRouter<TRouter, TRoute>
+      : never
+    : never
+
+export type FileRouteToPath<
+  TRouter extends AnyRouter,
+  TTo = InferFileRouteTypes<TRouter['routeTree']>['to'],
+  TTrailingSlashOption = TrailingSlashOptionByRouter<TRouter>,
+> = 'never' extends TTrailingSlashOption
+  ? TTo
+  : 'always' extends TTrailingSlashOption
+    ? AddTrailingSlash<TTo>
+    : TTo | AddTrailingSlash<TTo>
+
+export type RouteToPath<TRouter extends AnyRouter> = unknown extends TRouter
+  ? string
+  : InferFileRouteTypes<TRouter['routeTree']> extends never
+    ? CodeRouteToPath<TRouter>
+    : FileRouteToPath<TRouter>
+
+export type CodeRoutesByToPath<TRouter extends AnyRouter> =
+  ParseRouteWithoutBranches<TRouter['routeTree']> extends infer TRoutes extends
+    AnyRoute
+    ? {
+        [TRoute in TRoutes as RouteToByRouter<TRouter, TRoute>]: TRoute
+      }
+    : never
+
+export type RoutesByToPath<TRouter extends AnyRouter> =
+  InferFileRouteTypes<TRouter['routeTree']> extends never
+    ? CodeRoutesByToPath<TRouter>
+    : InferFileRouteTypes<TRouter['routeTree']>['fileRoutesByTo']
+
+export type CodeRouteByToPath<TRouter extends AnyRouter, TTo> = Extract<
+  RoutesByToPath<TRouter>[TTo & keyof RoutesByToPath<TRouter>],
+  AnyRoute
+>
+
+export type FileRouteByToPath<TRouter extends AnyRouter, TTo> =
+  'never' extends TrailingSlashOptionByRouter<TRouter>
+    ? CodeRouteByToPath<TRouter, TTo>
+    : 'always' extends TrailingSlashOptionByRouter<TRouter>
+      ? TTo extends '/'
+        ? CodeRouteByToPath<TRouter, TTo>
+        : TTo extends `${infer TPath}/`
+          ? CodeRouteByToPath<TRouter, TPath>
+          : never
+      : CodeRouteByToPath<
+          TRouter,
+          TTo extends '/' ? TTo : RemoveTrailingSlashes<TTo>
+        >
+
+export type RouteByToPath<TRouter extends AnyRouter, TTo> =
+  InferFileRouteTypes<TRouter['routeTree']> extends never
+    ? CodeRouteByToPath<TRouter, TTo>
+    : FileRouteByToPath<TRouter, TTo>
+
+export type FullSearchSchema<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? PartialMergeAll<TRoutes['types']['fullSearchSchema']>
+    : never
+
+export type FullSearchSchemaInput<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? PartialMergeAll<TRoutes['types']['fullSearchSchemaInput']>
+    : never
+
+export type AllParams<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? PartialMergeAll<TRoutes['types']['allParams']>
+    : never
+
+export type AllContext<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? PartialMergeAll<TRoutes['types']['allContext']>
+    : never
+
+export type AllLoaderData<TRouteTree extends AnyRoute> =
+  ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute
+    ? PartialMergeAll<TRoutes['types']['loaderData']>
+    : never