@tanstack/router-core 0.0.1-beta.41 → 0.0.1-beta.49

package/src/route.ts

@@ -1,255 +1,50 @@
-import {
-  CheckRelativePath,
-  LinkInfo,
-  LinkOptions,
-  ResolveRelativePath,
-  ToOptions,
-} from './link'
-import { LoaderContext, RouteConfig, RouteOptions } from './routeConfig'
+import { Action, ActionOptions } from './actions'
+import { RouteConfig, RouteOptions } from './routeConfig'
 import {
   AnyAllRouteInfo,
   AnyRouteInfo,
   DefaultAllRouteInfo,
   RouteInfo,
-  RouteInfoByPath,
 } from './routeInfo'
-import {
-  Action,
-  ActionState,
-  Loader,
-  LoaderState,
-  MatchRouteOptions,
-  Router,
-} from './router'
-import { NoInfer } from './utils'
-import { createStore } from '@solidjs/reactivity'
+import { Router } from './router'
 
 export interface AnyRoute extends Route<any, any, any> {}
 
-export interface Route<
+export class Route<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
   TRouteInfo extends AnyRouteInfo = RouteInfo,
   TRouterContext = unknown,
 > {
-  routeInfo: TRouteInfo
-  routeId: TRouteInfo['id']
-  routeRouteId: TRouteInfo['routeId']
-  routePath: TRouteInfo['path']
-  fullPath: TRouteInfo['fullPath']
-  parentRoute?: AnyRoute
+  routeInfo!: TRouteInfo
+  id!: TRouteInfo['id']
+  customId!: TRouteInfo['customId']
+  path!: TRouteInfo['path']
+  fullPath!: TRouteInfo['fullPath']
+  getParentRoute!: () => undefined | AnyRoute
   childRoutes?: AnyRoute[]
-  options: RouteOptions
-  originalIndex: number
-  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>
-  action: unknown extends TRouteInfo['actionResponse']
-    ?
-        | Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
-        | undefined
-    : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
-  loader: unknown extends TRouteInfo['routeLoaderData']
-    ?
-        | Action<
-            LoaderContext<
-              TRouteInfo['fullSearchSchema'],
-              TRouteInfo['allParams']
-            >,
-            TRouteInfo['routeLoaderData']
-          >
-        | undefined
-    : Loader<
-        TRouteInfo['fullSearchSchema'],
-        TRouteInfo['allParams'],
-        TRouteInfo['routeLoaderData']
-      >
-  // buildLink: <TTo extends string = '.'>(
-  //   options: Omit<
-  //     LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>,
-  //     'from'
-  //   >,
-  // ) => LinkInfo
-  // matchRoute: <
-  //   TTo extends string = '.',
-  //   TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>,
-  // >(
-  //   matchLocation: CheckRelativePath<
-  //     TAllRouteInfo,
-  //     TRouteInfo['fullPath'],
-  //     NoInfer<TTo>
-  //   > &
-  //     Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
-  //   opts?: MatchRouteOptions,
-  // ) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams']
-  // navigate: <TTo extends string = '.'>(
-  //   options: Omit<
-  //     LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>,
-  //     'from'
-  //   >,
-  // ) => Promise<void>
-}
-
-export function createRoute<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TRouteInfo extends AnyRouteInfo = RouteInfo,
-  TRouterContext = unknown,
->(
-  routeConfig: RouteConfig,
-  options: TRouteInfo['options'],
-  originalIndex: number,
-  parent: undefined | Route<TAllRouteInfo, any>,
-  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>,
-): Route<TAllRouteInfo, TRouteInfo, TRouterContext> {
-  const { id, routeId, path: routePath, fullPath } = routeConfig
-
-  let route: Route<TAllRouteInfo, TRouteInfo, TRouterContext> = {
-    routeInfo: undefined!,
-    routeId: id,
-    routeRouteId: routeId,
-    originalIndex,
-    routePath,
-    fullPath,
-    options,
-    router,
-    childRoutes: undefined!,
-    parentRoute: parent,
-    get action() {
-      let action =
-        router.store.actions[id] ||
-        (() => {
-          router.setStore((s) => {
-            s.actions[id] = {
-              submissions: [],
-              submit: async <T, U>(
-                submission: T,
-                actionOpts?: { invalidate?: boolean; multi?: boolean },
-              ) => {
-                if (!route) {
-                  return
-                }
-
-                const invalidate = actionOpts?.invalidate ?? true
-
-                const [actionStore, setActionStore] = createStore<
-                  ActionState<T, U>
-                >({
-                  submittedAt: Date.now(),
-                  status: 'pending',
-                  submission,
-                  isMulti: !!actionOpts?.multi,
-                })
-
-                router.setStore((s) => {
-                  if (!actionOpts?.multi) {
-                    s.actions[id]!.submissions = action.submissions.filter(
-                      (d) => d.isMulti,
-                    )
-                  }
-
-                  s.actions[id]!.current = actionStore
-                  s.actions[id]!.latest = actionStore
-                  s.actions[id]!.submissions.push(actionStore)
-                })
-
-                try {
-                  const res = await route.options.action?.(submission)
-
-                  setActionStore((s) => {
-                    s.data = res as U
-                  })
-
-                  if (invalidate) {
-                    router.invalidateRoute({ to: '.', fromCurrent: true })
-                    await router.reload()
-                  }
-
-                  setActionStore((s) => {
-                    s.status = 'success'
-                  })
-
-                  return res
-                } catch (err) {
-                  console.error(err)
-                  setActionStore((s) => {
-                    s.error = err
-                    s.status = 'error'
-                  })
-                }
-              },
-            }
-          })
-
-          return router.store.actions[id]!
-        })()
-
-      return action
-    },
-    get loader() {
-      let loader =
-        router.store.loaders[id] ||
-        (() => {
-          router.setStore((s) => {
-            s.loaders[id] = {
-              pending: [],
-              fetch: (async (loaderContext: LoaderContext<any, any>) => {
-                if (!route) {
-                  return
-                }
-
-                const loaderState: LoaderState<any, any> = {
-                  loadedAt: Date.now(),
-                  loaderContext,
-                }
-
-                router.setStore((s) => {
-                  s.loaders[id]!.current = loaderState
-                  s.loaders[id]!.latest = loaderState
-                  s.loaders[id]!.pending.push(loaderState)
-                })
-
-                try {
-                  return await route.options.loader?.(loaderContext)
-                } finally {
-                  router.setStore((s) => {
-                    s.loaders[id]!.pending = s.loaders[id]!.pending.filter(
-                      (d) => d !== loaderState,
-                    )
-                  })
-                }
-              }) as any,
-            }
-          })
-
-          return router.store.loaders[id]!
-        })()
-
-      return loader as any
-    },
-
-    // buildLink: (options) => {
-    //   return router.buildLink({
-    //     ...options,
-    //     from: fullPath,
-    //   } as any) as any
-    // },
-
-    // navigate: (options) => {
-    //   return router.navigate({
-    //     ...options,
-    //     from: fullPath,
-    //   } as any) as any
-    // },
-
-    // matchRoute: (matchLocation, opts) => {
-    //   return router.matchRoute(
-    //     {
-    //       ...matchLocation,
-    //       from: fullPath,
-    //     } as any,
-    //     opts,
-    //   ) as any
-    // },
+  options!: RouteOptions
+  originalIndex!: number
+  getRouter!: () => Router<
+    TAllRouteInfo['routeConfig'],
+    TAllRouteInfo,
+    TRouterContext
+  >
+  constructor(
+    routeConfig: RouteConfig,
+    options: TRouteInfo['options'],
+    originalIndex: number,
+    parent: undefined | Route<TAllRouteInfo, any>,
+    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>,
+  ) {
+    Object.assign(this, {
+      ...routeConfig,
+      originalIndex,
+      options,
+      getRouter: () => router,
+      childRoutes: undefined!,
+      getParentRoute: () => parent,
+    })
+
+    router.options.createRoute?.({ router, route: this })
   }
-
-  router.options.createRoute?.({ router, route })
-
-  return route
 }

package/src/routeConfig.ts

@@ -4,7 +4,7 @@ import { ParsePathParams } from './link'
 import { joinPaths, trimPath, trimPathRight } from './path'
 import { RouteInfo } from './routeInfo'
 import { RouteMatch } from './routeMatch'
-import { RegisteredRouter, Router } from './router'
+import { AnyRouter, RegisteredRouter, Router } from './router'
 import { Expand, IsAny, NoInfer, PickUnsafe } from './utils'
 
 export const rootRouteId = '__root__' as const
@@ -62,10 +62,6 @@ export interface LoaderContext<
   // parentLoaderPromise?: Promise<TParentRouteLoaderData>
 }
 
-export type ActionFn<TActionPayload = unknown, TActionResponse = unknown> = (
-  submission: TActionPayload,
-) => TActionResponse | Promise<TActionResponse>
-
 export type UnloaderFn<TPath extends string> = (
   routeMatch: RouteMatch<any, RouteInfo<string, TPath>>,
 ) => void
@@ -77,8 +73,6 @@ export type RouteOptions<
   TRouteLoaderData extends AnyLoaderData = {},
   TParentLoaderData extends AnyLoaderData = {},
   TLoaderData extends AnyLoaderData = {},
-  TActionPayload = unknown,
-  TActionResponse = unknown,
   TParentSearchSchema extends {} = {},
   TSearchSchema extends AnySearchSchema = {},
   TFullSearchSchema extends AnySearchSchema = TSearchSchema,
@@ -120,15 +114,12 @@ export type RouteOptions<
   // The max age to cache the loader data for this route in milliseconds from the time of route inactivity
   // before it is garbage collected.
   loaderGcMaxAge?: number
-  // An asynchronous function made available to the route for performing asynchronous or mutative actions that
-  // might invalidate the route's data.
-  action?: ActionFn<TActionPayload, TActionResponse>
   // This async function is called before a route is loaded.
   // If an error is thrown here, the route's loader will not be called.
   // If thrown during a navigation, the navigation will be cancelled and the error will be passed to the `onLoadError` function.
   // If thrown during a preload event, the error will be logged to the console.
   beforeLoad?: (opts: {
-    router: Router<any, any, unknown>
+    router: AnyRouter
     match: RouteMatch
   }) => Promise<void> | void
   // This function will be called if the route's loader throws an error **during an attempted navigation**.
@@ -181,8 +172,6 @@ export interface RouteConfig<
   TRouteLoaderData extends AnyLoaderData = AnyLoaderData,
   TParentLoaderData extends AnyLoaderData = {},
   TLoaderData extends AnyLoaderData = AnyLoaderData,
-  TActionPayload = unknown,
-  TActionResponse = unknown,
   TParentSearchSchema extends {} = {},
   TSearchSchema extends AnySearchSchema = {},
   TFullSearchSchema extends AnySearchSchema = {},
@@ -202,8 +191,6 @@ export interface RouteConfig<
     TRouteLoaderData,
     TParentLoaderData,
     TLoaderData,
-    TActionPayload,
-    TActionResponse,
     TParentSearchSchema,
     TSearchSchema,
     TFullSearchSchema,
@@ -228,8 +215,6 @@ export interface RouteConfig<
       TRouteLoaderData,
       TParentLoaderData,
       TLoaderData,
-      TActionPayload,
-      TActionResponse,
       TParentSearchSchema,
       TSearchSchema,
       TFullSearchSchema,
@@ -267,8 +252,6 @@ type GenerateFn<
   TParentParams extends AnyPathParams = {},
 > = <
   TRouteLoaderData extends AnyLoaderData = AnyLoaderData,
-  TActionPayload = unknown,
-  TActionResponse = unknown,
   TSearchSchema extends AnySearchSchema = {},
   TParams extends Record<ParsePathParams<TPath>, unknown> = Record<
     ParsePathParams<TPath>,
@@ -288,8 +271,6 @@ type GenerateFn<
       TRouteLoaderData,
       TParentLoaderData,
       Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>,
-      TActionPayload,
-      TActionResponse,
       TParentSearchSchema,
       TSearchSchema,
       Expand<TParentSearchSchema & TSearchSchema>,
@@ -313,8 +294,6 @@ type CreateRouteConfigFn<
   TRouteId extends string,
   TPath extends string,
   TRouteLoaderData extends AnyLoaderData,
-  TActionPayload,
-  TActionResponse,
   TSearchSchema extends AnySearchSchema = AnySearchSchema,
   TParams extends Record<ParsePathParams<TPath>, unknown> = Record<
     ParsePathParams<TPath>,
@@ -341,8 +320,6 @@ type CreateRouteConfigFn<
           TRouteLoaderData,
           TParentLoaderData,
           Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>,
-          TActionPayload,
-          TActionResponse,
           TParentSearchSchema,
           TSearchSchema,
           Expand<TParentSearchSchema & TSearchSchema>,
@@ -359,8 +336,6 @@ type CreateRouteConfigFn<
         TRouteLoaderData,
         TParentLoaderData,
         Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>,
-        TActionPayload,
-        TActionResponse,
         TParentSearchSchema,
         TSearchSchema,
         Expand<TParentSearchSchema & TSearchSchema>,
@@ -381,8 +356,6 @@ type CreateRouteConfigFn<
   TRouteLoaderData,
   TParentLoaderData,
   Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>,
-  TActionPayload,
-  TActionResponse,
   TParentSearchSchema,
   TSearchSchema,
   Expand<TParentSearchSchema & TSearchSchema>,
@@ -423,8 +396,6 @@ export interface AnyRouteConfig
     any,
     any,
     any,
-    any,
-    any,
     any
   > {}
 
@@ -444,8 +415,6 @@ export interface AnyRouteConfigWithChildren<TChildren>
     any,
     any,
     any,
-    any,
-    any,
     TChildren
   > {}
 
@@ -466,7 +435,7 @@ type TrimPathRight<T extends string> = T extends '/'
 
 export const createRouteConfig: CreateRouteConfigFn<true> = (
   options = {} as any,
-  children,
+  children = [] as any,
   isRoot = true,
   parentId,
   parentPath,

package/src/routeInfo.ts

@@ -1,4 +1,3 @@
-import { ParsePathParams } from './link'
 import { Route } from './route'
 import {
   AnyLoaderData,
@@ -65,15 +64,13 @@ type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
 // Generics!
 export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
   infer TId,
-  infer TRouteId,
+  infer TCustomId,
   infer TPath,
   infer TFullPath,
   infer TParentRouteLoaderData,
   infer TRouteLoaderData,
   infer TParentLoaderData,
   infer TLoaderData,
-  infer TActionPayload,
-  infer TActionResponse,
   infer TParentSearchSchema,
   infer TSearchSchema,
   infer TFullSearchSchema,
@@ -82,19 +79,17 @@ export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
   infer TAllParams,
   any
 >
-  ? string extends TRouteId
+  ? string extends TCustomId
     ? never
     : RouteInfo<
         TId,
-        TRouteId,
+        TCustomId,
         TPath,
         TFullPath,
         TParentRouteLoaderData,
         TRouteLoaderData,
         TParentLoaderData,
         TLoaderData,
-        TActionPayload,
-        TActionResponse,
         TParentSearchSchema,
         TSearchSchema,
         TFullSearchSchema,
@@ -120,8 +115,6 @@ export interface RoutesInfoInner<
     any,
     any,
     any,
-    any,
-    any,
     any
   > = RouteInfo,
   TRouteInfoById = { '/': TRouteInfo } & {
@@ -160,22 +153,18 @@ export interface AnyRouteInfo
     any,
     any,
     any,
-    any,
-    any,
     any
   > {}
 
 export interface RouteInfo<
   TId extends string = string,
-  TRouteId extends string = string,
+  TCustomId extends string = string,
   TPath extends string = string,
   TFullPath extends string = '/',
   TParentRouteLoaderData extends AnyLoaderData = {},
   TRouteLoaderData extends AnyLoaderData = {},
   TParentLoaderData extends AnyLoaderData = {},
   TLoaderData extends AnyLoaderData = {},
-  TActionPayload = unknown,
-  TActionResponse = unknown,
   TParentSearchSchema extends {} = {},
   TSearchSchema extends AnySearchSchema = {},
   TFullSearchSchema extends AnySearchSchema = {},
@@ -184,29 +173,25 @@ export interface RouteInfo<
   TAllParams extends AnyPathParams = {},
 > {
   id: TId
-  routeId: TRouteId
+  customId: TCustomId
   path: TPath
   fullPath: TFullPath
   parentRouteLoaderData: TParentRouteLoaderData
   routeLoaderData: TRouteLoaderData
   parentLoaderData: TParentLoaderData
   loaderData: TLoaderData
-  actionPayload: TActionPayload
-  actionResponse: TActionResponse
   searchSchema: TSearchSchema
   fullSearchSchema: TFullSearchSchema
   parentParams: TParentParams
   params: TParams
   allParams: TAllParams
   options: RouteOptions<
-    TRouteId,
+    TCustomId,
     TPath,
     TParentRouteLoaderData,
     TRouteLoaderData,
     TParentLoaderData,
     TLoaderData,
-    TActionPayload,
-    TActionResponse,
     TParentSearchSchema,
     TSearchSchema,
     TFullSearchSchema,