@tanstack/router-core 0.0.1-beta.5 → 0.0.1-beta.50

package/src/routeMatch.ts

@@ -1,374 +1,346 @@
 import { GetFrameworkGeneric } from './frameworks'
 import { Route } from './route'
-import { AnyPathParams } from './routeConfig'
 import {
   AnyAllRouteInfo,
   AnyRouteInfo,
   DefaultAllRouteInfo,
   RouteInfo,
 } from './routeInfo'
-import { Router } from './router'
-import { replaceEqualDeep, Timeout } from './utils'
+import { AnyRouter, Router } from './router'
+import { batch, createStore, Store } from './store'
+import { Expand } from './utils'
+import { replaceEqualDeep } from './interop'
 
-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
-  isInvalid: boolean
-  getIsInvalid: () => boolean
+  invalid: boolean
   loaderData: TRouteInfo['loaderData']
   routeLoaderData: TRouteInfo['routeLoaderData']
   isFetching: boolean
-  isPending: boolean
   invalidAt: number
-  __: {
-    element?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    errorElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    catchElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    pendingElement?: GetFrameworkGeneric<'Element'> // , TRouteInfo['loaderData']>
-    loadPromise?: Promise<void>
-    loaderPromise?: Promise<void>
-    elementsPromise?: Promise<void>
-    dataPromise?: Promise<void>
-    pendingTimeout?: Timeout
-    pendingMinTimeout?: Timeout
-    pendingMinPromise?: Promise<void>
-    onExit?:
-      | void
-      | ((matchContext: {
-          params: TRouteInfo['allParams']
-          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<
+export class RouteMatch<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
   TRouteInfo extends AnyRouteInfo = RouteInfo,
->(
-  router: Router<any, any>,
-  route: Route<TAllRouteInfo, TRouteInfo>,
-  opts: {
-    matchId: string
-    params: TRouteInfo['allParams']
-    pathname: string
-  },
-): RouteMatch<TAllRouteInfo, TRouteInfo> {
-  const routeMatch: RouteMatch<TAllRouteInfo, TRouteInfo> = {
-    ...route,
-    ...opts,
-    router,
-    routeSearch: {},
-    search: {},
-    childMatches: [],
-    status: 'idle',
-    routeLoaderData: {} as TRouteInfo['routeLoaderData'],
-    loaderData: {} as TRouteInfo['loaderData'],
-    isPending: false,
-    isFetching: false,
-    isInvalid: false,
-    invalidAt: Infinity,
-    getIsInvalid: () => {
-      const now = Date.now()
-      return routeMatch.isInvalid || routeMatch.invalidAt < now
+> {
+  route!: Route<TAllRouteInfo, TRouteInfo>
+  router!: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>
+  store!: Store<RouteMatchStore<TAllRouteInfo, TRouteInfo>>
+  id!: string
+  pathname!: string
+  params!: TRouteInfo['allParams']
+
+  component: GetFrameworkGeneric<'Component'>
+  errorComponent: GetFrameworkGeneric<'ErrorComponent'>
+  pendingComponent: GetFrameworkGeneric<'Component'>
+  abortController = new AbortController()
+  #latestId = ''
+  #resolve = () => {}
+  onLoaderDataListeners = new Set<() => void>()
+  parentMatch?: RouteMatch
+
+  __loadPromise?: Promise<void>
+  __onExit?:
+    | void
+    | ((matchContext: {
+        params: TRouteInfo['allParams']
+        search: TRouteInfo['fullSearchSchema']
+      }) => void)
+
+  constructor(
+    router: AnyRouter,
+    route: Route<TAllRouteInfo, TRouteInfo>,
+    opts: {
+      matchId: string
+      params: TRouteInfo['allParams']
+      pathname: string
     },
-    __: {
-      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
+  ) {
+    Object.assign(this, {
+      route,
+      router,
+      matchId: opts.matchId,
+      pathname: opts.pathname,
+      params: opts.params,
+      store: createStore<RouteMatchStore<TAllRouteInfo, TRouteInfo>>({
+        routeSearch: {},
+        search: {} as any,
+        status: 'idle',
+        routeLoaderData: {} as TRouteInfo['routeLoaderData'],
+        loaderData: {} as TRouteInfo['loaderData'],
+        isFetching: false,
+        invalid: false,
+        invalidAt: Infinity,
+      }),
+    })
+
+    if (!this.__hasLoaders()) {
+      this.store.setState((s) => (s.status = 'success'))
+    }
+  }
+
+  #setLoaderData = (loaderData: TRouteInfo['routeLoaderData']) => {
+    batch(() => {
+      this.store.setState((s) => {
+        s.routeLoaderData = loaderData
+      })
+      this.#updateLoaderData()
+    })
+  }
+
+  cancel = () => {
+    this.abortController?.abort()
+  }
+
+  load = async (
+    loaderOpts?:
+      | { preload: true; maxAge: number; gcMaxAge: number }
+      | { preload?: false; maxAge?: never; gcMaxAge?: never },
+  ): Promise<void> => {
+    const now = Date.now()
+    const minMaxAge = loaderOpts?.preload
+      ? Math.max(loaderOpts?.maxAge, loaderOpts?.gcMaxAge)
+      : 0
+
+    // If this is a preload, add it to the preload cache
+    if (loaderOpts?.preload && minMaxAge > 0) {
+      // If the match is currently active, don't preload it
+      if (
+        this.router.store.state.currentMatches.find((d) => d.id === this.id)
+      ) {
+        return
+      }
+
+      this.router.store.setState((s) => {
+        s.matchCache[this.id] = {
+          gc: now + loaderOpts.gcMaxAge,
+          match: this as RouteMatch<any, any>,
+        }
+      })
+    }
+
+    // If the match is invalid, errored or idle, trigger it to load
+    if (
+      (this.store.state.status === 'success' && this.getIsInvalid()) ||
+      this.store.state.status === 'error' ||
+      this.store.state.status === 'idle'
+    ) {
+      const maxAge = loaderOpts?.preload ? loaderOpts?.maxAge : undefined
+      await this.fetch({ maxAge })
+    }
+  }
+
+  fetch = async (opts?: {
+    maxAge?: number
+  }): Promise<TRouteInfo['routeLoaderData']> => {
+    this.__loadPromise = new Promise(async (resolve) => {
+      const loadId = '' + Date.now() + Math.random()
+      this.#latestId = loadId
+
+      const checkLatest = () =>
+        loadId !== this.#latestId
+          ? this.__loadPromise?.then(() => resolve())
+          : undefined
+
+      let latestPromise
+
+      batch(() => {
+        // If the match was in an error state, set it
+        // to a loading state again. Otherwise, keep it
+        // as loading or resolved
+        if (this.store.state.status === 'idle') {
+          this.store.setState((s) => (s.status = 'loading'))
         }
 
-        routeMatch.__.pendingTimeout = setTimeout(() => {
-          routeMatch.isPending = true
-          routeMatch.__.resolve()
-          if (typeof pendingMinMs !== 'undefined') {
-            routeMatch.__.pendingMinPromise = new Promise(
-              (r) =>
-                (routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs)),
-            )
-          }
-        }, pendingMs)
-      },
-      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)
-      // },
-      validate: () => {
-        // Validate the search params and stabilize them
-        const parentSearch =
-          routeMatch.parentMatch?.search ?? router.location.search
+        // We started loading the route, so it's no longer invalid
+        this.store.setState((s) => (s.invalid = false))
+      })
 
-        try {
-          const prevSearch = routeMatch.routeSearch
+      // We are now fetching, even if it's in the background of a
+      // resolved state
+      this.store.setState((s) => (s.isFetching = true))
+      this.#resolve = resolve as () => void
 
-          const validator =
-            typeof routeMatch.options.validateSearch === 'object'
-              ? routeMatch.options.validateSearch.parse
-              : routeMatch.options.validateSearch
+      const componentsPromise = (async () => {
+        // then run all component and data loaders in parallel
+        // For each component type, potentially load it asynchronously
 
-          let nextSearch = replaceEqualDeep(
-            prevSearch,
-            validator?.(parentSearch),
-          )
+        await Promise.all(
+          componentTypes.map(async (type) => {
+            const component = this.route.options[type]
 
-          // Invalidate route matches when search param stability changes
-          if (prevSearch !== nextSearch) {
-            routeMatch.isInvalid = true
-          }
+            if (this[type]?.preload) {
+              this[type] = await this.router.options.loadComponent!(component)
+            }
+          }),
+        )
+      })()
 
-          routeMatch.routeSearch = nextSearch
+      const dataPromise = Promise.resolve().then(async () => {
+        try {
+          if (this.route.options.loader) {
+            const data = await this.router.loadMatchData(this)
+            if ((latestPromise = checkLatest())) return latestPromise
 
-          routeMatch.search = replaceEqualDeep(parentSearch, {
-            ...parentSearch,
-            ...nextSearch,
+            this.#setLoaderData(data)
+          }
+
+          this.store.setState((s) => {
+            s.error = undefined
+            s.status = 'success'
+            s.updatedAt = Date.now()
+            s.invalidAt =
+              s.updatedAt +
+              (opts?.maxAge ??
+                this.route.options.loaderMaxAge ??
+                this.router.options.defaultLoaderMaxAge ??
+                0)
           })
-        } catch (err: any) {
-          console.error(err)
-          const error = new (Error as any)('Invalid search params found', {
-            cause: err,
+
+          return this.store.state.routeLoaderData
+        } catch (err) {
+          if ((latestPromise = checkLatest())) return latestPromise
+
+          if (process.env.NODE_ENV !== 'production') {
+            console.error(err)
+          }
+
+          this.store.setState((s) => {
+            s.error = err
+            s.status = 'error'
+            s.updatedAt = Date.now()
           })
-          error.code = 'INVALID_SEARCH_PARAMS'
-          routeMatch.status = 'error'
-          routeMatch.error = error
-          // Do not proceed with loading the route
-          return
-        }
-      },
-    },
-    cancel: () => {
-      routeMatch.__.abortController?.abort()
-      routeMatch.__.cancelPending()
-    },
-    invalidate: () => {
-      routeMatch.isInvalid = true
-    },
-    hasLoaders: () => {
-      return !!(
-        route.options.loader ||
-        elementTypes.some((d) => typeof route.options[d] === 'function')
-      )
-    },
-    load: async (loaderOpts) => {
-      const now = Date.now()
-      const minMaxAge = loaderOpts?.preload
-        ? Math.max(loaderOpts?.maxAge, loaderOpts?.gcMaxAge)
-        : 0
-
-      // If this is a preload, add it to the preload cache
-      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)
-        ) {
-          return
-        }
 
-        router.matchCache[routeMatch.matchId] = {
-          gc: now + loaderOpts.gcMaxAge,
-          match: routeMatch as RouteMatch<any, any>,
+          throw err
         }
-      }
-
-      // If the match is invalid, errored or idle, trigger it to load
-      if (
-        (routeMatch.status === 'success' && routeMatch.getIsInvalid()) ||
-        routeMatch.status === 'error' ||
-        routeMatch.status === 'idle'
-      ) {
-        const maxAge = loaderOpts?.preload ? loaderOpts?.maxAge : undefined
+      })
 
-        routeMatch.fetch({ maxAge })
+      const after = async () => {
+        if ((latestPromise = checkLatest())) return latestPromise
+        this.store.setState((s) => (s.isFetching = false))
+        this.#resolve()
+        delete this.__loadPromise
       }
-    },
-    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'
+
+      try {
+        await Promise.all([componentsPromise, dataPromise.catch(() => {})])
+        after()
+      } catch {
+        after()
       }
+    })
 
-      // We started loading the route, so it's no longer invalid
-      routeMatch.isInvalid = false
-
-      routeMatch.__.loadPromise = new Promise(async (resolve) => {
-        // 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
-
-          routeMatch.__.elementsPromise = (async () => {
-            // then run all element and data loaders in parallel
-            // For each element type, potentially load it asynchronously
-
-            await Promise.all(
-              elementTypes.map(async (type) => {
-                const routeElement = 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,
-                )
-              }
-
-              routeMatch.error = undefined
-              routeMatch.status = 'success'
-              routeMatch.updatedAt = Date.now()
-              routeMatch.invalidAt =
-                routeMatch.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 this.__loadPromise
+  }
+  invalidate = async () => {
+    this.store.setState((s) => (s.invalid = true))
+    if (this.router.store.state.currentMatches.find((d) => d.id === this.id)) {
+      await this.load()
+    }
+  }
+  __hasLoaders = () => {
+    return !!(
+      this.route.options.loader ||
+      componentTypes.some((d) => this.route.options[d]?.preload)
+    )
+  }
+  getIsInvalid = () => {
+    const now = Date.now()
+    return this.store.state.invalid || this.store.state.invalidAt < now
+  }
 
-          try {
-            await Promise.all([
-              routeMatch.__.elementsPromise,
-              routeMatch.__.dataPromise,
-            ])
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise
-            }
+  #updateLoaderData = () => {
+    this.store.setState((s) => {
+      s.loaderData = replaceEqualDeep(s.loaderData, {
+        ...this.parentMatch?.store.state.loaderData,
+        ...s.routeLoaderData,
+      }) as TRouteInfo['loaderData']
+    })
+    this.onLoaderDataListeners.forEach((listener) => listener())
+  }
 
-            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()
-          }
-        })()
+  __setParentMatch = (parentMatch?: RouteMatch) => {
+    if (!this.parentMatch && parentMatch) {
+      this.parentMatch = parentMatch
+      this.parentMatch.__onLoaderData(() => {
+        this.#updateLoaderData()
+      })
+    }
+  }
+
+  __onLoaderData = (listener: () => void) => {
+    this.onLoaderDataListeners.add(listener)
+    // return () => this.onLoaderDataListeners.delete(listener)
+  }
+
+  __validate = () => {
+    // Validate the search params and stabilize them
+    const parentSearch =
+      this.parentMatch?.store.state.search ??
+      this.router.store.state.latestLocation.search
+
+    try {
+      const prevSearch = this.store.state.routeSearch
+
+      const validator =
+        typeof this.route.options.validateSearch === 'object'
+          ? this.route.options.validateSearch.parse
+          : this.route.options.validateSearch
+
+      let nextSearch = validator?.(parentSearch) ?? {}
+
+      batch(() => {
+        // Invalidate route matches when search param stability changes
+        if (prevSearch !== nextSearch) {
+          this.store.setState((s) => (s.invalid = true))
+        }
+
+        this.store.setState((s) => {
+          s.routeSearch = nextSearch
+          s.search = {
+            ...parentSearch,
+            ...nextSearch,
+          } as any
+        })
+      })
 
-        routeMatch.__.loaderPromise = loaderPromise
-        await loaderPromise
+      componentTypes.map(async (type) => {
+        const component = this.route.options[type]
 
-        if (id !== routeMatch.__.latestId) {
-          return routeMatch.__.loaderPromise
+        if (typeof this[type] !== 'function') {
+          this[type] = component
         }
-        delete routeMatch.__.loaderPromise
       })
+    } catch (err: any) {
+      console.error(err)
+      const error = new (Error as any)('Invalid search params found', {
+        cause: err,
+      })
+      error.code = 'INVALID_SEARCH_PARAMS'
 
-      return await routeMatch.__.loadPromise
-    },
-  }
+      this.store.setState((s) => {
+        s.status = 'error'
+        s.error = error
+      })
 
-  if (!routeMatch.hasLoaders()) {
-    routeMatch.status = 'success'
+      // Do not proceed with loading the route
+      return
+    }
   }
-
-  return routeMatch
 }