@tanstack/react-router 0.0.1-beta.5 → 0.0.1-beta.51

package/src/index.tsx

@@ -1,16 +1,11 @@
 import * as React from 'react'
 
-import { useSyncExternalStore } from 'use-sync-external-store/shim'
-
-import {
-  AnyRoute,
-  CheckId,
-  rootRouteId,
-  Router,
-  RouterState,
-  ToIdOption,
-} from '@tanstack/router-core'
 import {
+  Route,
+  RegisteredAllRouteInfo,
+  RegisteredRouter,
+  RouterStore,
+  last,
   warning,
   RouterOptions,
   RouteMatch,
@@ -20,10 +15,7 @@ import {
   AnyAllRouteInfo,
   DefaultAllRouteInfo,
   functionalUpdate,
-  createRouter,
-  AnyRouteInfo,
   AllRouteInfo,
-  RouteInfo,
   ValidFromPath,
   LinkOptions,
   RouteInfoByPath,
@@ -31,111 +23,51 @@ import {
   NoInfer,
   ToOptions,
   invariant,
+  Router,
+  Expand,
+  Action,
+  ActionStore,
+  ActionSubmission,
 } from '@tanstack/router-core'
+import { useStore } from './useStore'
+
+//
 
 export * from '@tanstack/router-core'
 
-declare module '@tanstack/router-core' {
-  interface FrameworkGenerics {
-    Element: React.ReactNode
-    // Any is required here so import() will work without having to do import().then(d => d.default)
-    SyncOrAsyncElement: React.ReactNode | (() => Promise<any>)
-  }
+export { useStore }
 
-  interface Router<
-    TRouteConfig extends AnyRouteConfig = RouteConfig,
-    TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>,
-  > {
-    useState: () => RouterState
-    useRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(
-      routeId: TId,
-    ) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>
-    useMatch: <TId extends keyof TAllRouteInfo['routeInfoById']>(
-      routeId: TId,
-    ) => RouteMatch<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>
-    linkProps: <TTo extends string = '.'>(
-      props: LinkPropsOptions<TAllRouteInfo, '/', TTo> &
-        React.AnchorHTMLAttributes<HTMLAnchorElement>,
-    ) => React.AnchorHTMLAttributes<HTMLAnchorElement>
-    Link: <TTo extends string = '.'>(
-      props: LinkPropsOptions<TAllRouteInfo, '/', TTo> &
-        React.AnchorHTMLAttributes<HTMLAnchorElement> &
-        Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-          // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
-          children?:
-            | React.ReactNode
-            | ((state: { isActive: boolean }) => React.ReactNode)
-        },
-    ) => JSX.Element
-    MatchRoute: <TTo extends string = '.'>(
-      props: ToOptions<TAllRouteInfo, '/', TTo> &
-        MatchRouteOptions & {
-          // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
-          children?:
-            | React.ReactNode
-            | ((
-                params: RouteInfoByPath<
-                  TAllRouteInfo,
-                  ResolveRelativePath<'/', NoInfer<TTo>>
-                >['allParams'],
-              ) => React.ReactNode)
-        },
-    ) => JSX.Element
-  }
+//
+
+type ReactNode = any
+
+export type SyncRouteComponent<TProps = {}> = (props: TProps) => ReactNode
+
+export type RouteComponent<TProps = {}> = SyncRouteComponent<TProps> & {
+  preload?: () => Promise<void>
+}
+
+export function lazy(
+  importer: () => Promise<{ default: SyncRouteComponent }>,
+): RouteComponent {
+  const lazyComp = React.lazy(importer as any)
+  let preloaded: Promise<SyncRouteComponent>
+
+  const finalComp = lazyComp as unknown as RouteComponent
 
-  interface Route<
-    TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-    TRouteInfo extends AnyRouteInfo = RouteInfo,
-  > {
-    useRoute: <
-      TTo extends string = '.',
-      TResolved extends string = ResolveRelativePath<
-        TRouteInfo['id'],
-        NoInfer<TTo>
-      >,
-    >(
-      routeId: CheckId<
-        TAllRouteInfo,
-        TResolved,
-        ToIdOption<TAllRouteInfo, TRouteInfo['id'], TTo>
-      >,
-    ) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TResolved]>
-    linkProps: <TTo extends string = '.'>(
-      props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> &
-        React.AnchorHTMLAttributes<HTMLAnchorElement>,
-    ) => React.AnchorHTMLAttributes<HTMLAnchorElement>
-    Link: <TTo extends string = '.'>(
-      props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> &
-        React.AnchorHTMLAttributes<HTMLAnchorElement> &
-        Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-          // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
-          children?:
-            | React.ReactNode
-            | ((state: { isActive: boolean }) => React.ReactNode)
-        },
-    ) => JSX.Element
-    MatchRoute: <TTo extends string = '.'>(
-      props: ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> &
-        MatchRouteOptions & {
-          // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
-          children?:
-            | React.ReactNode
-            | ((
-                params: RouteInfoByPath<
-                  TAllRouteInfo,
-                  ResolveRelativePath<TRouteInfo['fullPath'], NoInfer<TTo>>
-                >['allParams'],
-              ) => React.ReactNode)
-        },
-    ) => JSX.Element
+  finalComp.preload = async () => {
+    if (!preloaded) {
+      await importer()
+    }
   }
+
+  return finalComp
 }
 
-type LinkPropsOptions<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+export type LinkPropsOptions<
+  TFrom extends RegisteredAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
-> = LinkOptions<TAllRouteInfo, TFrom, TTo> & {
+> = LinkOptions<RegisteredAllRouteInfo, TFrom, TTo> & {
   // A function that returns additional props for the `active` state of this link. These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)
   activeProps?:
     | React.AnchorHTMLAttributes<HTMLAnchorElement>
@@ -146,396 +78,568 @@ type LinkPropsOptions<
     | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>)
 }
 
+export type MakeUseMatchRouteOptions<
+  TFrom extends RegisteredAllRouteInfo['routePaths'] = '/',
+  TTo extends string = '.',
+> = ToOptions<RegisteredAllRouteInfo, TFrom, TTo> & MatchRouteOptions
+
+export type MakeMatchRouteOptions<
+  TFrom extends RegisteredAllRouteInfo['routePaths'] = '/',
+  TTo extends string = '.',
+> = ToOptions<RegisteredAllRouteInfo, TFrom, TTo> &
+  MatchRouteOptions & {
+    // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
+    children?:
+      | ReactNode
+      | ((
+          params: RouteInfoByPath<
+            RegisteredAllRouteInfo,
+            ResolveRelativePath<TFrom, NoInfer<TTo>>
+          >['allParams'],
+        ) => ReactNode)
+  }
+
+export type MakeLinkPropsOptions<
+  TFrom extends ValidFromPath<RegisteredAllRouteInfo> = '/',
+  TTo extends string = '.',
+> = LinkPropsOptions<TFrom, TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>
+
+export type MakeLinkOptions<
+  TFrom extends RegisteredAllRouteInfo['routePaths'] = '/',
+  TTo extends string = '.',
+> = LinkPropsOptions<TFrom, TTo> &
+  React.AnchorHTMLAttributes<HTMLAnchorElement> &
+  Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
+    // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
+    children?: ReactNode | ((state: { isActive: boolean }) => ReactNode)
+  }
+
+declare module '@tanstack/router-core' {
+  interface FrameworkGenerics {
+    Component: RouteComponent
+    ErrorComponent: RouteComponent<{
+      error: unknown
+      info: { componentStack: string }
+    }>
+  }
+
+  interface RouterOptions<TRouteConfig, TRouterContext> {
+    // ssrFooter?: () => JSX.Element | Node
+  }
+}
+
 export type PromptProps = {
   message: string
   when?: boolean | any
-  children?: React.ReactNode
+  children?: ReactNode
 }
 
 //
 
-const matchesContext = React.createContext<RouteMatch[]>(null!)
-const routerContext = React.createContext<{ router: Router<any, any> }>(null!)
+export function useLinkProps<
+  TFrom extends ValidFromPath<RegisteredAllRouteInfo> = '/',
+  TTo extends string = '.',
+>(
+  options: MakeLinkPropsOptions<TFrom, TTo>,
+): React.AnchorHTMLAttributes<HTMLAnchorElement> {
+  const router = useRouter()
+
+  const {
+    // custom props
+    type,
+    children,
+    target,
+    activeProps = () => ({ className: 'active' }),
+    inactiveProps = () => ({}),
+    activeOptions,
+    disabled,
+    // fromCurrent,
+    hash,
+    search,
+    params,
+    to = '.',
+    preload,
+    preloadDelay,
+    preloadMaxAge,
+    replace,
+    // element props
+    style,
+    className,
+    onClick,
+    onFocus,
+    onMouseEnter,
+    onMouseLeave,
+    onTouchStart,
+    onTouchEnd,
+    ...rest
+  } = options
+
+  const linkInfo = router.buildLink(options as any)
+
+  if (linkInfo.type === 'external') {
+    const { href } = linkInfo
+    return { href }
+  }
 
-// Detect if we're in the DOM
-const isDOM = Boolean(
-  typeof window !== 'undefined' &&
-    window.document &&
-    window.document.createElement,
-)
+  const { handleClick, handleFocus, handleEnter, handleLeave, isActive, next } =
+    linkInfo
+
+  const reactHandleClick = (e: Event) => {
+    if (React.startTransition) {
+      // This is a hack for react < 18
+      React.startTransition(() => {
+        handleClick(e)
+      })
+    } else {
+      handleClick(e)
+    }
+  }
 
-const useLayoutEffect = isDOM ? React.useLayoutEffect : React.useEffect
+  const composeHandlers =
+    (handlers: (undefined | ((e: any) => void))[]) =>
+    (e: React.SyntheticEvent) => {
+      if (e.persist) e.persist()
+      handlers.filter(Boolean).forEach((handler) => {
+        if (e.defaultPrevented) return
+        handler!(e)
+      })
+    }
 
-export type MatchesProviderProps = {
-  value: RouteMatch[]
-  children: React.ReactNode
+  // Get the active props
+  const resolvedActiveProps: React.HTMLAttributes<HTMLAnchorElement> = isActive
+    ? functionalUpdate(activeProps as any, {}) ?? {}
+    : {}
+
+  // Get the inactive props
+  const resolvedInactiveProps: React.HTMLAttributes<HTMLAnchorElement> =
+    isActive ? {} : functionalUpdate(inactiveProps, {}) ?? {}
+
+  return {
+    ...resolvedActiveProps,
+    ...resolvedInactiveProps,
+    ...rest,
+    href: disabled ? undefined : next.href,
+    onClick: composeHandlers([onClick, reactHandleClick]),
+    onFocus: composeHandlers([onFocus, handleFocus]),
+    onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
+    onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
+    target,
+    style: {
+      ...style,
+      ...resolvedActiveProps.style,
+      ...resolvedInactiveProps.style,
+    },
+    className:
+      [
+        className,
+        resolvedActiveProps.className,
+        resolvedInactiveProps.className,
+      ]
+        .filter(Boolean)
+        .join(' ') || undefined,
+    ...(disabled
+      ? {
+          role: 'link',
+          'aria-disabled': true,
+        }
+      : undefined),
+    ['data-status']: isActive ? 'active' : undefined,
+  }
 }
 
-export function MatchesProvider(props: MatchesProviderProps) {
-  return <matchesContext.Provider {...props} />
+export interface LinkFn<
+  TDefaultFrom extends RegisteredAllRouteInfo['routePaths'] = '/',
+  TDefaultTo extends string = '.',
+> {
+  <
+    TFrom extends RegisteredAllRouteInfo['routePaths'] = TDefaultFrom,
+    TTo extends string = TDefaultTo,
+  >(
+    props: MakeLinkOptions<TFrom, TTo> & React.RefAttributes<HTMLAnchorElement>,
+  ): ReactNode
 }
 
-const useRouterSubscription = (router: Router<any, any>) => {
-  useSyncExternalStore(
-    (cb) => router.subscribe(() => cb()),
-    () => router.state,
-    () => router.state,
+export const Link: LinkFn = React.forwardRef((props: any, ref) => {
+  const linkProps = useLinkProps(props)
+
+  return (
+    <a
+      {...{
+        ref: ref as any,
+        ...linkProps,
+        children:
+          typeof props.children === 'function'
+            ? props.children({
+                isActive: (linkProps as any)['data-status'] === 'active',
+              })
+            : props.children,
+      }}
+    />
   )
+}) as any
+
+type MatchesContextValue = RouteMatch[]
+
+export const matchesContext = React.createContext<MatchesContextValue>(null!)
+export const routerContext = React.createContext<{ router: RegisteredRouter }>(
+  null!,
+)
+
+export type MatchesProviderProps = {
+  value: MatchesContextValue
+  children: ReactNode
 }
 
-export function createReactRouter<
+export class ReactRouter<
   TRouteConfig extends AnyRouteConfig = RouteConfig,
->(opts: RouterOptions<TRouteConfig>): Router<TRouteConfig> {
-  const makeRouteExt = (
-    route: AnyRoute,
-    router: Router<any, any>,
-  ): Pick<AnyRoute, 'useRoute' | 'linkProps' | 'Link' | 'MatchRoute'> => {
-    return {
-      useRoute: (subRouteId = '.' as any) => {
-        const resolvedRouteId = router.resolvePath(
-          route.routeId,
-          subRouteId as string,
-        )
-        const resolvedRoute = router.getRoute(resolvedRouteId)
-        useRouterSubscription(router)
-        invariant(
-          resolvedRoute,
-          `Could not find a route for route "${
-            resolvedRouteId as string
-          }"! Did you forget to add it to your route config?`,
-        )
-        return resolvedRoute
-      },
-      linkProps: (options) => {
-        const {
-          // custom props
-          type,
-          children,
-          target,
-          activeProps = () => ({ className: 'active' }),
-          inactiveProps = () => ({}),
-          activeOptions,
-          disabled,
-          // fromCurrent,
-          hash,
-          search,
-          params,
-          to,
-          preload,
-          preloadDelay,
-          preloadMaxAge,
-          replace,
-          // element props
-          style,
-          className,
-          onClick,
-          onFocus,
-          onMouseEnter,
-          onMouseLeave,
-          onTouchStart,
-          onTouchEnd,
-          ...rest
-        } = options
-
-        const linkInfo = route.buildLink(options)
-
-        if (linkInfo.type === 'external') {
-          const { href } = linkInfo
-          return { href }
+  TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>,
+  TRouterContext = unknown,
+> extends Router<TRouteConfig, TAllRouteInfo, TRouterContext> {
+  constructor(opts: RouterOptions<TRouteConfig, TRouterContext>) {
+    super({
+      ...opts,
+      loadComponent: async (component) => {
+        if (component.preload) {
+          await component.preload()
         }
 
-        const {
-          handleClick,
-          handleFocus,
-          handleEnter,
-          handleLeave,
-          isActive,
-          next,
-        } = linkInfo
-
-        const composeHandlers =
-          (handlers: (undefined | ((e: any) => void))[]) =>
-          (e: React.SyntheticEvent) => {
-            e.persist()
-            handlers.forEach((handler) => {
-              if (handler) handler(e)
-            })
-          }
-
-        // Get the active props
-        const resolvedActiveProps: React.HTMLAttributes<HTMLAnchorElement> =
-          isActive ? functionalUpdate(activeProps, {}) ?? {} : {}
-
-        // Get the inactive props
-        const resolvedInactiveProps: React.HTMLAttributes<HTMLAnchorElement> =
-          isActive ? {} : functionalUpdate(inactiveProps, {}) ?? {}
-
-        return {
-          ...resolvedActiveProps,
-          ...resolvedInactiveProps,
-          ...rest,
-          href: disabled ? undefined : next.href,
-          onClick: composeHandlers([handleClick, onClick]),
-          onFocus: composeHandlers([handleFocus, onFocus]),
-          onMouseEnter: composeHandlers([handleEnter, onMouseEnter]),
-          onMouseLeave: composeHandlers([handleLeave, onMouseLeave]),
-          target,
-          style: {
-            ...style,
-            ...resolvedActiveProps.style,
-            ...resolvedInactiveProps.style,
-          },
-          className:
-            [
-              className,
-              resolvedActiveProps.className,
-              resolvedInactiveProps.className,
-            ]
-              .filter(Boolean)
-              .join(' ') || undefined,
-          ...(disabled
-            ? {
-                role: 'link',
-                'aria-disabled': true,
-              }
-            : undefined),
-          ['data-status']: isActive ? 'active' : undefined,
-        }
+        return component as any
       },
-      Link: React.forwardRef((props: any, ref) => {
-        const linkProps = route.linkProps(props)
-
-        useRouterSubscription(router)
-
-        return (
-          <a
-            {...{
-              ref: ref as any,
-              ...linkProps,
-              children:
-                typeof props.children === 'function'
-                  ? props.children({
-                      isActive: (linkProps as any)['data-status'] === 'active',
-                    })
-                  : props.children,
-            }}
-          />
-        )
-      }) as any,
-      MatchRoute: (opts) => {
-        const { pending, caseSensitive, children, ...rest } = opts
-
-        const params = route.matchRoute(rest as any, {
-          pending,
-          caseSensitive,
-        })
-
-        if (!params) {
-          return null
-        }
-
-        return typeof opts.children === 'function'
-          ? opts.children(params as any)
-          : (opts.children as any)
-      },
-    }
+    })
   }
-
-  const coreRouter = createRouter<TRouteConfig>({
-    ...opts,
-    createRouter: (router) => {
-      const routerExt: Pick<Router<any, any>, 'useMatch' | 'useState'> = {
-        useState: () => {
-          useRouterSubscription(router)
-          return router.state
-        },
-        useMatch: (routeId) => {
-          useRouterSubscription(router)
-
-          invariant(
-            routeId !== rootRouteId,
-            `"${rootRouteId}" cannot be used with useMatch! Did you mean to useRoute("${rootRouteId}")?`,
-          )
-
-          const runtimeMatch = useMatch()
-          const match = router.state.matches.find((d) => d.routeId === routeId)
-
-          invariant(
-            match,
-            `Could not find a match for route "${
-              routeId as string
-            }" being rendered in this component!`,
-          )
-
-          invariant(
-            runtimeMatch.routeId == match?.routeId,
-            `useMatch('${
-              match?.routeId as string
-            }') is being called in a component that is meant to render the '${
-              runtimeMatch.routeId
-            }' route. Did you mean to 'useRoute(${
-              match?.routeId as string
-            })' instead?`,
-          )
-
-          if (!match) {
-            invariant('Match not found!')
-          }
-
-          return match
-        },
-      }
-
-      const routeExt = makeRouteExt(router.getRoute('/'), router)
-
-      Object.assign(router, routerExt, routeExt)
-    },
-    createRoute: ({ router, route }) => {
-      const routeExt = makeRouteExt(route, router)
-
-      Object.assign(route, routeExt)
-    },
-    createElement: async (element) => {
-      if (typeof element === 'function') {
-        const res = (await element()) as any
-
-        // Support direct import() calls
-        if (typeof res === 'object' && res.default) {
-          return React.createElement(res.default)
-        } else {
-          return res
-        }
-      }
-
-      return element
-    },
-  })
-
-  return coreRouter as any
 }
 
 export type RouterProps<
   TRouteConfig extends AnyRouteConfig = RouteConfig,
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-> = RouterOptions<TRouteConfig> & {
-  router: Router<TRouteConfig, TAllRouteInfo>
-  // Children will default to `<Outlet />` if not provided
-  children?: React.ReactNode
+  TRouterContext = unknown,
+> = RouterOptions<TRouteConfig, TRouterContext> & {
+  router: Router<TRouteConfig, TAllRouteInfo, TRouterContext>
 }
 
 export function RouterProvider<
   TRouteConfig extends AnyRouteConfig = RouteConfig,
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
->({ children, router, ...rest }: RouterProps<TRouteConfig, TAllRouteInfo>) {
+  TRouterContext = unknown,
+>({
+  router,
+  ...rest
+}: RouterProps<TRouteConfig, TAllRouteInfo, TRouterContext>) {
   router.update(rest)
 
-  useRouterSubscription(router)
+  const currentMatches = useStore(
+    router.store,
+    (s) => s.currentMatches,
+    undefined,
+  )
 
-  useLayoutEffect(() => {
-    return router.mount()
-  }, [router])
+  React.useEffect(router.mount, [router])
 
   return (
-    <routerContext.Provider value={{ router }}>
-      <MatchesProvider value={router.state.matches}>
-        {children ?? <Outlet />}
-      </MatchesProvider>
-    </routerContext.Provider>
+    <>
+      <routerContext.Provider value={{ router: router as any }}>
+        <matchesContext.Provider value={[undefined!, ...currentMatches]}>
+          <Outlet />
+        </matchesContext.Provider>
+      </routerContext.Provider>
+    </>
   )
 }
 
-function useRouter(): Router {
+export function useRouter(): RegisteredRouter {
   const value = React.useContext(routerContext)
   warning(!value, 'useRouter must be used inside a <Router> component!')
+  return value.router
+}
 
-  useRouterSubscription(value.router)
-
-  return value.router as Router
+export function useRouterStore<T = RouterStore>(
+  selector?: (state: Router['store']) => T,
+  shallow?: boolean,
+): T {
+  const router = useRouter()
+  return useStore(router.store, selector as any, shallow)
 }
 
-function useMatches(): RouteMatch[] {
+export function useMatches(): RouteMatch[] {
   return React.useContext(matchesContext)
 }
 
-// function useParentMatches(): RouteMatch[] {
-//   const router = useRouter()
-//   const match = useMatch()
-//   const matches = router.state.matches
-//   return matches.slice(
-//     0,
-//     matches.findIndex((d) => d.matchId === match.matchId) - 1,
-//   )
-// }
+export function useMatch<
+  TFrom extends keyof RegisteredAllRouteInfo['routeInfoById'],
+  TStrict extends boolean = true,
+  TRouteMatch = RouteMatch<
+    RegisteredAllRouteInfo,
+    RegisteredAllRouteInfo['routeInfoById'][TFrom]
+  >,
+>(opts?: {
+  from: TFrom
+  strict?: TStrict
+  track?: (match: TRouteMatch) => any
+  shallow?: boolean
+}): TStrict extends true ? TRouteMatch : TRouteMatch | undefined {
+  const router = useRouter()
+  const nearestMatch = useMatches()[0]!
+  const match = opts?.from
+    ? router.store.state.currentMatches.find((d) => d.route.id === opts?.from)
+    : nearestMatch
+
+  invariant(
+    match,
+    `Could not find ${
+      opts?.from ? `an active match from "${opts.from}"` : 'a nearest match!'
+    }`,
+  )
+
+  if (opts?.strict ?? true) {
+    invariant(
+      nearestMatch.route.id == match?.route.id,
+      `useMatch("${
+        match?.route.id as string
+      }") is being called in a component that is meant to render the '${
+        nearestMatch.route.id
+      }' route. Did you mean to 'useMatch("${
+        match?.route.id as string
+      }", { strict: false })' or 'useRoute("${
+        match?.route.id as string
+      }")' instead?`,
+    )
+  }
 
-function useMatch<T>(): RouteMatch {
-  return useMatches()?.[0] as RouteMatch
+  useStore(
+    match!.store,
+    (d) => opts?.track?.(match as any) ?? match,
+    opts?.shallow,
+  )
+
+  return match as any
 }
 
-export function Outlet() {
+export function useRoute<
+  TId extends keyof RegisteredAllRouteInfo['routeInfoById'] = '/',
+>(
+  routeId: TId,
+): Route<RegisteredAllRouteInfo, RegisteredAllRouteInfo['routeInfoById'][TId]> {
   const router = useRouter()
-  const [, ...matches] = useMatches()
+  const resolvedRoute = router.getRoute(routeId as any)
 
-  const childMatch = matches[0]
+  invariant(
+    resolvedRoute,
+    `Could not find a route for route "${
+      routeId as string
+    }"! Did you forget to add it to your route config?`,
+  )
 
-  if (!childMatch) return null
+  return resolvedRoute as any
+}
 
-  const element = ((): React.ReactNode => {
-    if (!childMatch) {
-      return null
-    }
+export function useLoaderData<
+  TFrom extends keyof RegisteredAllRouteInfo['routeInfoById'] = '/',
+  TStrict extends boolean = true,
+  TLoaderData = RegisteredAllRouteInfo['routeInfoById'][TFrom]['loaderData'],
+>(opts?: {
+  from: TFrom
+  strict?: TStrict
+  track?: (loaderData: TLoaderData) => any
+}): TStrict extends true ? TLoaderData : TLoaderData | undefined {
+  const match = useMatch(opts)
+
+  invariant(
+    match,
+    `Could not find ${
+      opts?.from ? `an active match from "${opts.from}"` : 'a nearest match!'
+    }`,
+  )
 
-    const errorElement =
-      childMatch.__.errorElement ?? router.options.defaultErrorElement
+  useStore(
+    (match as any).store,
+    (d: any) => opts?.track?.(d.loaderData) ?? d.loaderData,
+  )
 
-    if (childMatch.status === 'error') {
-      if (errorElement) {
-        return errorElement as any
-      }
+  return (match as unknown as RouteMatch).store.state.loaderData as any
+}
 
-      if (
-        childMatch.options.useErrorBoundary ||
-        router.options.useErrorBoundary
-      ) {
-        throw childMatch.error
-      }
+export function useSearch<
+  TFrom extends keyof RegisteredAllRouteInfo['routeInfoById'],
+  TStrict extends boolean = true,
+  TSearch = RegisteredAllRouteInfo['routeInfoById'][TFrom]['fullSearchSchema'],
+  TSelected = TSearch,
+>(opts?: {
+  from: TFrom
+  strict?: TStrict
+  track?: (search: TSearch) => TSelected
+}): TStrict extends true ? TSelected : TSelected | undefined {
+  const match = useMatch(opts)
+  useStore(
+    (match as any).store,
+    (d: any) => opts?.track?.(d.search) ?? d.search,
+  )
 
-      return <DefaultErrorBoundary error={childMatch.error} />
-    }
+  return (match as unknown as RouteMatch).store.state.search as any
+}
 
-    if (childMatch.status === 'loading' || childMatch.status === 'idle') {
-      if (childMatch.isPending) {
-        const pendingElement =
-          childMatch.__.pendingElement ?? router.options.defaultPendingElement
+export function useParams<
+  TFrom extends keyof RegisteredAllRouteInfo['routeInfoById'] = '/',
+  TDefaultSelected = Expand<
+    RegisteredAllRouteInfo['allParams'] &
+      RegisteredAllRouteInfo['routeInfoById'][TFrom]['allParams']
+  >,
+  TSelected = TDefaultSelected,
+>(opts?: {
+  from: TFrom
+  track?: (search: TDefaultSelected) => TSelected
+}): TSelected {
+  const router = useRouter()
+  useStore(router.store, (d) => {
+    const params = last(d.currentMatches)?.params as any
+    return opts?.track?.(params) ?? params
+  })
 
-        if (childMatch.options.pendingMs || pendingElement) {
-          return (pendingElement as any) ?? null
-        }
-      }
+  return last(router.store.state.currentMatches)?.params as any
+}
+
+export function useNavigate<
+  TDefaultFrom extends keyof RegisteredAllRouteInfo['routeInfoById'] = '/',
+>(defaultOpts: { from?: TDefaultFrom }) {
+  const router = useRouter()
+  return <
+    TFrom extends keyof RegisteredAllRouteInfo['routeInfoById'] = TDefaultFrom,
+    TTo extends string = '.',
+  >(
+    opts: MakeLinkOptions<TFrom, TTo>,
+  ) => {
+    return router.navigate({ ...defaultOpts, ...(opts as any) })
+  }
+}
+
+export function useMatchRoute() {
+  const router = useRouter()
+
+  return <
+    TFrom extends ValidFromPath<RegisteredAllRouteInfo> = '/',
+    TTo extends string = '.',
+  >(
+    opts: MakeUseMatchRouteOptions<TFrom, TTo>,
+  ) => {
+    const { pending, caseSensitive, ...rest } = opts
+
+    return router.matchRoute(rest as any, {
+      pending,
+      caseSensitive,
+    })
+  }
+}
+
+export function MatchRoute<
+  TFrom extends ValidFromPath<RegisteredAllRouteInfo> = '/',
+  TTo extends string = '.',
+>(props: MakeMatchRouteOptions<TFrom, TTo>): any {
+  const matchRoute = useMatchRoute()
+  const params = matchRoute(props)
+
+  if (!params) {
+    return null
+  }
+
+  if (typeof props.children === 'function') {
+    return (props.children as any)(params)
+  }
+
+  return params ? props.children : null
+}
 
-      return null
+export function Outlet() {
+  const matches = useMatches().slice(1)
+  const match = matches[0]
+
+  if (!match) {
+    return null
+  }
+
+  return <SubOutlet matches={matches} match={match} />
+}
+
+function SubOutlet({
+  matches,
+  match,
+}: {
+  matches: RouteMatch[]
+  match: RouteMatch
+}) {
+  const router = useRouter()
+  useStore(match!.store)
+
+  const defaultPending = React.useCallback(() => null, [])
+
+  const Inner = React.useCallback((props: { match: RouteMatch }): any => {
+    if (props.match.store.state.status === 'error') {
+      throw props.match.store.state.error
+    }
+
+    if (props.match.store.state.status === 'success') {
+      return React.createElement(
+        (props.match.component as any) ??
+          router.options.defaultComponent ??
+          Outlet,
+      )
+    }
+
+    if (props.match.store.state.status === 'loading') {
+      throw props.match.__loadPromise
     }
 
-    return (childMatch.__.element as any) ?? router.options.defaultElement
-  })() as JSX.Element
+    invariant(
+      false,
+      'Idle routeMatch status encountered during rendering! You should never see this. File an issue!',
+    )
+  }, [])
 
-  const catchElement =
-    childMatch?.options.catchElement ?? router.options.defaultCatchElement
+  const PendingComponent = (match.pendingComponent ??
+    router.options.defaultPendingComponent ??
+    defaultPending) as any
+
+  const errorComponent =
+    match.errorComponent ?? router.options.defaultErrorComponent
 
   return (
-    <MatchesProvider value={matches} key={childMatch.matchId}>
-      <CatchBoundary catchElement={catchElement}>{element}</CatchBoundary>
-    </MatchesProvider>
+    <matchesContext.Provider value={matches}>
+      <React.Suspense fallback={<PendingComponent />}>
+        <CatchBoundary
+          key={match.route.id}
+          errorComponent={errorComponent}
+          match={match as any}
+        >
+          <Inner match={match} />
+        </CatchBoundary>
+      </React.Suspense>
+      {/* Provide a suffix suspense boundary to make sure the router is
+  ready to be dehydrated on the server */}
+      {/* {router.options.ssrFooter && match.id === rootRouteId ? (
+        <React.Suspense fallback={null}>
+          {(() => {
+            if (router.store.pending) {
+              throw router.navigationPromise
+            }
+
+            return router.options.ssrFooter()
+          })()}
+        </React.Suspense>
+      ) : null} */}
+    </matchesContext.Provider>
   )
 }
 
 class CatchBoundary extends React.Component<{
   children: any
-  catchElement: any
+  errorComponent: any
+  match: RouteMatch
 }> {
   state = {
     error: false,
+    info: undefined,
   }
+
   componentDidCatch(error: any, info: any) {
+    console.error(`Error in route match: ${this.props.match.id}`)
     console.error(error)
 
     this.setState({
@@ -543,23 +647,63 @@ class CatchBoundary extends React.Component<{
       info,
     })
   }
-  reset = () => {
-    this.setState({
-      error: false,
-      info: false,
-    })
-  }
+
   render() {
-    const catchElement = this.props.catchElement ?? DefaultErrorBoundary
+    return (
+      <CatchBoundaryInner
+        {...this.props}
+        errorState={this.state}
+        reset={() => this.setState({})}
+      />
+    )
+  }
+}
+
+// This is the messiest thing ever... I'm either seriously tired (likely) or
+// there has to be a better way to reset error boundaries when the
+// router's location key changes.
+function CatchBoundaryInner(props: {
+  children: any
+  errorComponent: any
+  errorState: { error: unknown; info: any }
+  reset: () => void
+}) {
+  const [activeErrorState, setActiveErrorState] = React.useState(
+    props.errorState,
+  )
+  const router = useRouter()
+  const errorComponent = props.errorComponent ?? DefaultErrorBoundary
+
+  // React.useEffect(() => {
+  //   if (activeErrorState) {
+  //     let prevKey = router.store.state.currentLocation.key
+  //     return createRoot((dispose) => {
+  //       createEffect(() => {
+  //         if (router.store.state.currentLocation.key !== prevKey) {
+  //           prevKey = router.store.state.currentLocation.key
+  //           setActiveErrorState({} as any)
+  //         }
+  //       })
+
+  //       return dispose
+  //     })
+  //   }
+
+  //   return
+  // }, [activeErrorState])
 
-    if (this.state.error) {
-      return typeof catchElement === 'function'
-        ? catchElement(this.state)
-        : catchElement
+  React.useEffect(() => {
+    if (props.errorState.error) {
+      setActiveErrorState(props.errorState)
     }
+    props.reset()
+  }, [props.errorState.error])
 
-    return this.props.children
+  if (props.errorState.error) {
+    return React.createElement(errorComponent, activeErrorState)
   }
+
+  return props.children
 }
 
 export function DefaultErrorBoundary({ error }: { error: any }) {
@@ -584,43 +728,65 @@ export function DefaultErrorBoundary({ error }: { error: any }) {
           ) : null}
         </pre>
       </div>
-      <div style={{ height: '1rem' }} />
-      <div
-        style={{
-          fontSize: '.8em',
-          borderLeft: '3px solid rgba(127, 127, 127, 1)',
-          paddingLeft: '.5rem',
-          opacity: 0.5,
-        }}
-      >
-        If you are the owner of this website, it's highly recommended that you
-        configure your own custom Catch/Error boundaries for the router. You can
-        optionally configure a boundary for each route.
-      </div>
     </div>
   )
 }
 
-export function usePrompt(message: string, when: boolean | any): void {
-  const router = useRouter()
-
-  React.useEffect(() => {
-    if (!when) return
-
-    let unblock = router.history.block((transition) => {
-      if (window.confirm(message)) {
-        unblock()
-        transition.retry()
-      } else {
-        router.location.pathname = window.location.pathname
-      }
-    })
+export function useAction<
+  TKey extends string = string,
+  TPayload = unknown,
+  TResponse = unknown,
+  TError = Error,
+>(
+  action: Action<TKey, TPayload, TResponse, TError>,
+  opts?: {
+    track?: (actionStore: ActionStore<TPayload, TResponse, TError>) => any
+  },
+): Action & {
+  latestSubmission: ActionSubmission<TPayload, TResponse, TError>
+  pendingSubmissions: ActionSubmission<TPayload, TResponse, TError>[]
+} {
+  useStore(action.store, (d) => opts?.track?.(d) ?? d, true)
+
+  const [ref] = React.useState({})
+
+  Object.assign(ref, {
+    ...action,
+    latestSubmission:
+      action.store.state.submissions[action.store.state.submissions.length - 1],
+    pendingSubmissions: React.useMemo(
+      () =>
+        action.store.state.submissions.filter((d) => d.status === 'pending'),
+      [action.store.state.submissions],
+    ),
+  })
 
-    return unblock
-  }, [when, location, message])
+  return ref as any
 }
 
-export function Prompt({ message, when, children }: PromptProps) {
-  usePrompt(message, when ?? true)
-  return (children ?? null) as React.ReactNode
-}
+// TODO: While we migrate away from the history package, these need to be disabled
+// export function usePrompt(message: string, when: boolean | any): void {
+//   const router = useRouter()
+
+//   React.useEffect(() => {
+//     if (!when) return
+
+//     let unblock = router.getHistory().block((transition) => {
+//       if (window.confirm(message)) {
+//         unblock()
+//         transition.retry()
+//       } else {
+//         router.setStore((s) => {
+//           s.currentLocation.pathname = window.location.pathname
+//         })
+//       }
+//     })
+
+//     return unblock
+//   }, [when, message])
+// }
+
+// export function Prompt({ message, when, children }: PromptProps) {
+//   usePrompt(message, when ?? true)
+//   return (children ?? null) as ReactNode
+// }