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

package/src/routeMatch.ts

@@ -1,6 +1,6 @@
+import { boolean } from 'zod'
 import { GetFrameworkGeneric } from './frameworks'
 import { Route } from './route'
-import { AnyPathParams } from './routeConfig'
 import {
   AnyAllRouteInfo,
   AnyRouteInfo,
@@ -8,41 +8,55 @@ import {
   RouteInfo,
 } from './routeInfo'
 import { Router } from './router'
-import { replaceEqualDeep, Timeout } from './utils'
+import { batch, createStore } from '@solidjs/reactivity'
+import { Expand } from './utils'
+import { sharedClone } from './sharedClone'
 
-export interface RouteMatch<
+export interface RouteMatchStore<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
   TRouteInfo extends AnyRouteInfo = RouteInfo,
-> extends Route<TAllRouteInfo, TRouteInfo> {
-  matchId: string
-  pathname: string
-  params: TRouteInfo['params']
+> {
   parentMatch?: RouteMatch
-  childMatches: RouteMatch[]
   routeSearch: TRouteInfo['searchSchema']
-  search: TRouteInfo['fullSearchSchema']
+  search: Expand<
+    TAllRouteInfo['fullSearchSchema'] & TRouteInfo['fullSearchSchema']
+  >
   status: 'idle' | 'loading' | 'success' | 'error'
   updatedAt?: number
   error?: unknown
+  invalid: boolean
   isInvalid: boolean
-  getIsInvalid: () => boolean
   loaderData: TRouteInfo['loaderData']
   routeLoaderData: TRouteInfo['routeLoaderData']
   isFetching: boolean
-  isPending: boolean
   invalidAt: number
+}
+
+export interface RouteMatch<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TRouteInfo extends AnyRouteInfo = RouteInfo,
+> extends Route<TAllRouteInfo, TRouteInfo> {
+  store: RouteMatchStore<TAllRouteInfo, TRouteInfo>
+  // setStore: WritableStore<RouteMatchStore<TAllRouteInfo, TRouteInfo>>
+  matchId: string
+  pathname: string
+  params: TRouteInfo['allParams']
+  childMatches: RouteMatch[]
+  cancel: () => void
+  load: (
+    loaderOpts?:
+      | { preload: true; maxAge: number; gcMaxAge: number }
+      | { preload?: false; maxAge?: never; gcMaxAge?: never },
+  ) => Promise<TRouteInfo['routeLoaderData']>
+  fetch: (opts?: { maxAge?: number }) => Promise<TRouteInfo['routeLoaderData']>
+  invalidate: () => void
+  hasLoaders: () => boolean
   __: {
-    element?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    errorElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    catchElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    pendingElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
+    setParentMatch: (parentMatch?: RouteMatch) => void
+    component?: GetFrameworkGeneric<'Component'>
+    errorComponent?: GetFrameworkGeneric<'ErrorComponent'>
+    pendingComponent?: GetFrameworkGeneric<'Component'>
     loadPromise?: Promise<void>
-    loaderPromise?: Promise<void>
-    elementsPromise?: Promise<void>
-    dataPromise?: Promise<void>
-    pendingTimeout?: Timeout
-    pendingMinTimeout?: Timeout
-    pendingMinPromise?: Promise<void>
     onExit?:
       | void
       | ((matchContext: {
@@ -50,143 +64,127 @@ export interface RouteMatch<
           search: TRouteInfo['fullSearchSchema']
         }) => void)
     abortController: AbortController
-    latestId: string
-    // setParentMatch: (parentMatch: RouteMatch) => void
-    // addChildMatch: (childMatch: RouteMatch) => void
     validate: () => void
-    startPending: () => void
-    cancelPending: () => void
-    notify: () => void
-    resolve: () => void
   }
-  cancel: () => void
-  load: (
-    loaderOpts?: { withPending?: boolean } & (
-      | { preload: true; maxAge: number; gcMaxAge: number }
-      | { preload?: false; maxAge?: never; gcMaxAge?: never }
-    ),
-  ) => Promise<TRouteInfo['routeLoaderData']>
-  fetch: (opts?: { maxAge?: number }) => Promise<TRouteInfo['routeLoaderData']>
-  invalidate: () => void
-  hasLoaders: () => boolean
 }
 
-const elementTypes = [
-  'element',
-  'errorElement',
-  'catchElement',
-  'pendingElement',
+const componentTypes = [
+  'component',
+  'errorComponent',
+  'pendingComponent',
 ] as const
 
 export function createRouteMatch<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
   TRouteInfo extends AnyRouteInfo = RouteInfo,
 >(
-  router: Router<any, any>,
+  router: Router<any, any, any>,
   route: Route<TAllRouteInfo, TRouteInfo>,
   opts: {
+    parentMatch?: RouteMatch<any, any>
     matchId: string
     params: TRouteInfo['allParams']
     pathname: string
   },
 ): RouteMatch<TAllRouteInfo, TRouteInfo> {
-  const routeMatch: RouteMatch<TAllRouteInfo, TRouteInfo> = {
-    ...route,
-    ...opts,
-    router,
+  let componentsPromise: Promise<void>
+  let dataPromise: Promise<TRouteInfo['routeLoaderData']>
+  let latestId = ''
+  let resolve = () => {}
+
+  function setLoaderData(loaderData: TRouteInfo['routeLoaderData']) {
+    batch(() => {
+      setStore((s) => {
+        s.routeLoaderData = sharedClone(s.routeLoaderData, loaderData)
+      })
+      updateLoaderData()
+    })
+  }
+
+  function updateLoaderData() {
+    setStore((s) => {
+      s.loaderData = sharedClone(s.loaderData, {
+        ...store.parentMatch?.store.loaderData,
+        ...s.routeLoaderData,
+      }) as TRouteInfo['loaderData']
+    })
+  }
+
+  const [store, setStore] = createStore<
+    RouteMatchStore<TAllRouteInfo, TRouteInfo>
+  >({
     routeSearch: {},
-    search: {},
-    childMatches: [],
+    search: {} as any,
     status: 'idle',
     routeLoaderData: {} as TRouteInfo['routeLoaderData'],
     loaderData: {} as TRouteInfo['loaderData'],
-    isPending: false,
     isFetching: false,
-    isInvalid: false,
+    invalid: false,
     invalidAt: Infinity,
-    getIsInvalid: () => {
+    get isInvalid(): boolean {
       const now = Date.now()
-      return routeMatch.isInvalid || routeMatch.invalidAt < now
+      return this.invalid || this.invalidAt < now
     },
-    __: {
-      abortController: new AbortController(),
-      latestId: '',
-      resolve: () => {},
-      notify: () => {
-        routeMatch.__.resolve()
-        routeMatch.router.notify()
-      },
-      startPending: () => {
-        const pendingMs =
-          routeMatch.options.pendingMs ?? router.options.defaultPendingMs
-        const pendingMinMs =
-          routeMatch.options.pendingMinMs ?? router.options.defaultPendingMinMs
+  })
 
-        if (
-          routeMatch.__.pendingTimeout ||
-          routeMatch.status !== 'loading' ||
-          typeof pendingMs === 'undefined'
-        ) {
-          return
-        }
+  const routeMatch: RouteMatch<TAllRouteInfo, TRouteInfo> = {
+    ...route,
+    ...opts,
+    store,
+    // setStore,
+    router,
+    childMatches: [],
+    __: {
+      setParentMatch: (parentMatch?: RouteMatch) => {
+        batch(() => {
+          setStore((s) => {
+            s.parentMatch = parentMatch
+          })
 
-        routeMatch.__.pendingTimeout = setTimeout(() => {
-          routeMatch.isPending = true
-          routeMatch.__.resolve()
-          if (typeof pendingMinMs !== 'undefined') {
-            routeMatch.__.pendingMinPromise = new Promise(
-              (r) =>
-                (routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs)),
-            )
-          }
-        }, pendingMs)
+          updateLoaderData()
+        })
       },
-      cancelPending: () => {
-        routeMatch.isPending = false
-        clearTimeout(routeMatch.__.pendingTimeout)
-        clearTimeout(routeMatch.__.pendingMinTimeout)
-        delete routeMatch.__.pendingMinPromise
-      },
-      // setParentMatch: (parentMatch?: RouteMatch) => {
-      //   routeMatch.parentMatch = parentMatch
-      // },
-      // addChildMatch: (childMatch: RouteMatch) => {
-      //   if (
-      //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
-      //   ) {
-      //     return
-      //   }
-
-      //   routeMatch.childMatches.push(childMatch)
-      // },
+      abortController: new AbortController(),
       validate: () => {
         // Validate the search params and stabilize them
         const parentSearch =
-          routeMatch.parentMatch?.search ?? router.location.search
+          store.parentMatch?.store.search ?? router.store.currentLocation.search
 
         try {
-          const prevSearch = routeMatch.routeSearch
+          const prevSearch = store.routeSearch
 
           const validator =
             typeof routeMatch.options.validateSearch === 'object'
               ? routeMatch.options.validateSearch.parse
               : routeMatch.options.validateSearch
 
-          let nextSearch = replaceEqualDeep(
+          let nextSearch = sharedClone(
             prevSearch,
-            validator?.(parentSearch),
+            validator?.(parentSearch) ?? {},
           )
 
-          // Invalidate route matches when search param stability changes
-          if (prevSearch !== nextSearch) {
-            routeMatch.isInvalid = true
-          }
+          batch(() => {
+            // Invalidate route matches when search param stability changes
+            if (prevSearch !== nextSearch) {
+              setStore((s) => (s.invalid = true))
+            }
+
+            // TODO: Alright, do we need batch() here?
+            setStore((s) => {
+              s.routeSearch = nextSearch
+              s.search = sharedClone(parentSearch, {
+                ...parentSearch,
+                ...nextSearch,
+              })
+            })
+          })
 
-          routeMatch.routeSearch = nextSearch
+          componentTypes.map(async (type) => {
+            const component = routeMatch.options[type]
 
-          routeMatch.search = replaceEqualDeep(parentSearch, {
-            ...parentSearch,
-            ...nextSearch,
+            if (typeof routeMatch.__[type] !== 'function') {
+              routeMatch.__[type] = component
+            }
           })
         } catch (err: any) {
           console.error(err)
@@ -194,8 +192,12 @@ export function createRouteMatch<
             cause: err,
           })
           error.code = 'INVALID_SEARCH_PARAMS'
-          routeMatch.status = 'error'
-          routeMatch.error = error
+
+          setStore((s) => {
+            s.status = 'error'
+            s.error = error
+          })
+
           // Do not proceed with loading the route
           return
         }
@@ -203,15 +205,14 @@ export function createRouteMatch<
     },
     cancel: () => {
       routeMatch.__.abortController?.abort()
-      routeMatch.__.cancelPending()
     },
     invalidate: () => {
-      routeMatch.isInvalid = true
+      setStore((s) => (s.invalid = true))
     },
     hasLoaders: () => {
       return !!(
         route.options.loader ||
-        elementTypes.some((d) => typeof route.options[d] === 'function')
+        componentTypes.some((d) => route.options[d]?.preload)
       )
     },
     load: async (loaderOpts) => {
@@ -224,12 +225,14 @@ export function createRouteMatch<
       if (loaderOpts?.preload && minMaxAge > 0) {
         // If the match is currently active, don't preload it
         if (
-          router.state.matches.find((d) => d.matchId === routeMatch.matchId)
+          router.store.currentMatches.find(
+            (d) => d.matchId === routeMatch.matchId,
+          )
         ) {
           return
         }
 
-        router.matchCache[routeMatch.matchId] = {
+        router.store.matchCache[routeMatch.matchId] = {
           gc: now + loaderOpts.gcMaxAge,
           match: routeMatch as RouteMatch<any, any>,
         }
@@ -237,137 +240,121 @@ export function createRouteMatch<
 
       // If the match is invalid, errored or idle, trigger it to load
       if (
-        (routeMatch.status === 'success' && routeMatch.getIsInvalid()) ||
-        routeMatch.status === 'error' ||
-        routeMatch.status === 'idle'
+        (store.status === 'success' && store.isInvalid) ||
+        store.status === 'error' ||
+        store.status === 'idle'
       ) {
         const maxAge = loaderOpts?.preload ? loaderOpts?.maxAge : undefined
 
-        routeMatch.fetch({ maxAge })
+        await routeMatch.fetch({ maxAge })
       }
     },
     fetch: async (opts) => {
-      const id = '' + Date.now() + Math.random()
-      routeMatch.__.latestId = id
-
-      // If the match was in an error state, set it
-      // to a loading state again. Otherwise, keep it
-      // as loading or resolved
-      if (routeMatch.status === 'idle') {
-        routeMatch.status = 'loading'
+      const loadId = '' + Date.now() + Math.random()
+      latestId = loadId
+      const checkLatest = async () => {
+        if (loadId !== latestId) {
+          // warning(true, 'Data loader is out of date!')
+          return new Promise(() => {})
+        }
       }
 
-      // We started loading the route, so it's no longer invalid
-      routeMatch.isInvalid = false
+      batch(() => {
+        // If the match was in an error state, set it
+        // to a loading state again. Otherwise, keep it
+        // as loading or resolved
+        if (store.status === 'idle') {
+          setStore((s) => (s.status = 'loading'))
+        }
+
+        // We started loading the route, so it's no longer invalid
+        setStore((s) => (s.invalid = false))
+      })
 
-      routeMatch.__.loadPromise = new Promise(async (resolve) => {
+      routeMatch.__.loadPromise = new Promise(async (r) => {
         // We are now fetching, even if it's in the background of a
         // resolved state
-        routeMatch.isFetching = true
-        routeMatch.__.resolve = resolve as () => void
-
-        const loaderPromise = (async () => {
-          // Load the elements and data in parallel
+        setStore((s) => (s.isFetching = true))
+        resolve = r as () => void
 
-          routeMatch.__.elementsPromise = (async () => {
-            // then run all element and data loaders in parallel
-            // For each element type, potentially load it asynchronously
+        componentsPromise = (async () => {
+          // then run all component and data loaders in parallel
+          // For each component type, potentially load it asynchronously
 
-            await Promise.all(
-              elementTypes.map(async (type) => {
-                const routeElement = routeMatch.options[type]
+          await Promise.all(
+            componentTypes.map(async (type) => {
+              const component = routeMatch.options[type]
 
-                if (routeMatch.__[type]) {
-                  return
-                }
-
-                routeMatch.__[type] = await router.options.createElement!(
-                  routeElement,
-                )
-              }),
-            )
-          })()
-
-          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
-            try {
-              if (routeMatch.options.loader) {
-                const data = await routeMatch.options.loader({
-                  params: routeMatch.params,
-                  search: routeMatch.routeSearch,
-                  signal: routeMatch.__.abortController.signal,
-                })
-                if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loaderPromise
-                }
-
-                routeMatch.routeLoaderData = replaceEqualDeep(
-                  routeMatch.routeLoaderData,
-                  data,
+              if (routeMatch.__[type]?.preload) {
+                routeMatch.__[type] = await router.options.loadComponent!(
+                  component,
                 )
               }
+            }),
+          )
+        })()
+
+        dataPromise = Promise.resolve().then(async () => {
+          try {
+            if (routeMatch.options.loader) {
+              const data = await router.loadMatchData(routeMatch)
+              await checkLatest()
+
+              setLoaderData(data)
+            }
 
-              routeMatch.error = undefined
-              routeMatch.status = 'success'
-              routeMatch.updatedAt = Date.now()
-              routeMatch.invalidAt =
-                routeMatch.updatedAt +
+            setStore((s) => {
+              s.error = undefined
+              s.status = 'success'
+              s.updatedAt = Date.now()
+              s.invalidAt =
+                s.updatedAt +
                 (opts?.maxAge ??
                   routeMatch.options.loaderMaxAge ??
                   router.options.defaultLoaderMaxAge ??
                   0)
-            } catch (err) {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise
-              }
+            })
 
-              if (process.env.NODE_ENV !== 'production') {
-                console.error(err)
-              }
-              routeMatch.error = err
-              routeMatch.status = 'error'
-              routeMatch.updatedAt = Date.now()
-            }
-          })
+            return store.routeLoaderData
+          } catch (err) {
+            await checkLatest()
 
-          try {
-            await Promise.all([
-              routeMatch.__.elementsPromise,
-              routeMatch.__.dataPromise,
-            ])
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise
+            if (process.env.NODE_ENV !== 'production') {
+              console.error(err)
             }
 
-            if (routeMatch.__.pendingMinPromise) {
-              await routeMatch.__.pendingMinPromise
-              delete routeMatch.__.pendingMinPromise
-            }
-          } finally {
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise
-            }
-            routeMatch.__.cancelPending()
-            routeMatch.isPending = false
-            routeMatch.isFetching = false
-            routeMatch.__.notify()
+            setStore((s) => {
+              s.error = err
+              s.status = 'error'
+              s.updatedAt = Date.now()
+            })
+
+            throw err
           }
-        })()
+        })
 
-        routeMatch.__.loaderPromise = loaderPromise
-        await loaderPromise
+        const after = async () => {
+          await checkLatest()
+          setStore((s) => (s.isFetching = false))
+          delete routeMatch.__.loadPromise
+          resolve()
+        }
 
-        if (id !== routeMatch.__.latestId) {
-          return routeMatch.__.loaderPromise
+        try {
+          await Promise.all([componentsPromise, dataPromise.catch(() => {})])
+          after()
+        } catch {
+          after()
         }
-        delete routeMatch.__.loaderPromise
       })
 
-      return await routeMatch.__.loadPromise
+      await routeMatch.__.loadPromise
+      await checkLatest()
     },
   }
 
   if (!routeMatch.hasLoaders()) {
-    routeMatch.status = 'success'
+    setStore((s) => (s.status = 'success'))
   }
 
   return routeMatch