@tanstack/router-core 0.0.1-beta.2 → 0.0.1-beta.201

package/build/cjs/router.js

@@ -0,0 +1,1277 @@
+/**
+ * @tanstack/router-core/src/index.ts
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var store = require('@tanstack/store');
+var invariant = require('tiny-invariant');
+var history = require('@tanstack/history');
+var path = require('./path.js');
+var searchParams = require('./searchParams.js');
+var utils = require('./utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
+
+//
+
+const componentTypes = ['component', 'errorComponent', 'pendingComponent'];
+const visibilityChangeEvent = 'visibilitychange';
+const focusEvent = 'focus';
+const preloadWarning = 'Error preloading route! ☝️';
+class Router {
+  #unsubHistory;
+  resetNextScroll = false;
+  tempLocationKey = `${Math.round(Math.random() * 10000000)}`;
+  // nextTemporaryLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>
+
+  constructor(options) {
+    this.options = {
+      defaultPreloadDelay: 50,
+      context: undefined,
+      ...options,
+      stringifySearch: options?.stringifySearch ?? searchParams.defaultStringifySearch,
+      parseSearch: options?.parseSearch ?? searchParams.defaultParseSearch
+      // fetchServerDataFn: options?.fetchServerDataFn ?? defaultFetchServerDataFn,
+    };
+
+    this.__store = new store.Store(getInitialRouterState(), {
+      onUpdate: () => {
+        const prev = this.state;
+        const next = this.__store.state;
+        const matchesByIdChanged = prev.matchesById !== next.matchesById;
+        let matchesChanged;
+        let pendingMatchesChanged;
+        if (!matchesByIdChanged) {
+          matchesChanged = prev.matchIds.length !== next.matchIds.length || prev.matchIds.some((d, i) => d !== next.matchIds[i]);
+          pendingMatchesChanged = prev.pendingMatchIds.length !== next.pendingMatchIds.length || prev.pendingMatchIds.some((d, i) => d !== next.pendingMatchIds[i]);
+        }
+        if (matchesByIdChanged || matchesChanged) {
+          next.matches = next.matchIds.map(id => {
+            return next.matchesById[id];
+          });
+        }
+        if (matchesByIdChanged || pendingMatchesChanged) {
+          next.pendingMatches = next.pendingMatchIds.map(id => {
+            return next.matchesById[id];
+          });
+        }
+        if (matchesByIdChanged || matchesChanged || pendingMatchesChanged) {
+          const hasPendingComponent = next.pendingMatches.some(d => {
+            const route = this.getRoute(d.routeId);
+            return !!route?.options.pendingComponent;
+          });
+          next.renderedMatchIds = hasPendingComponent ? next.pendingMatchIds : next.matchIds;
+          next.renderedMatches = next.renderedMatchIds.map(id => {
+            return next.matchesById[id];
+          });
+        }
+        next.isFetching = [...next.matches, ...next.pendingMatches].some(d => d.isFetching);
+        this.state = next;
+      },
+      defaultPriority: 'low'
+    });
+    this.state = this.__store.state;
+    this.update(options);
+    const nextLocation = this.buildLocation({
+      search: true,
+      params: true,
+      hash: true,
+      state: true
+    });
+    if (this.state.location.href !== nextLocation.href) {
+      this.#commitLocation({
+        ...nextLocation,
+        replace: true
+      });
+    }
+  }
+  subscribers = new Set();
+  subscribe = (eventType, fn) => {
+    const listener = {
+      eventType,
+      fn
+    };
+    this.subscribers.add(listener);
+    return () => {
+      this.subscribers.delete(listener);
+    };
+  };
+  #emit = routerEvent => {
+    this.subscribers.forEach(listener => {
+      if (listener.eventType === routerEvent.type) {
+        listener.fn(routerEvent);
+      }
+    });
+  };
+  reset = () => {
+    this.__store.setState(s => Object.assign(s, getInitialRouterState()));
+  };
+  mount = () => {
+    // addEventListener does not exist in React Native, but window does
+    // In the future, we might need to invert control here for more adapters
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (typeof window !== 'undefined' && window.addEventListener) {
+      window.addEventListener(visibilityChangeEvent, this.#onFocus, false);
+      window.addEventListener(focusEvent, this.#onFocus, false);
+    }
+    this.safeLoad();
+    return () => {
+      if (typeof window !== 'undefined' && window.removeEventListener) {
+        window.removeEventListener(visibilityChangeEvent, this.#onFocus);
+        window.removeEventListener(focusEvent, this.#onFocus);
+      }
+    };
+  };
+  #onFocus = () => {
+    if (this.options.reloadOnWindowFocus ?? true) {
+      this.invalidate({
+        __fromFocus: true
+      });
+    }
+  };
+  update = opts => {
+    this.options = {
+      ...this.options,
+      ...opts,
+      context: {
+        ...this.options.context,
+        ...opts?.context
+      }
+    };
+    if (!this.history || this.options.history && this.options.history !== this.history) {
+      if (this.#unsubHistory) {
+        this.#unsubHistory();
+      }
+      this.history = this.options.history ?? (isServer ? history.createMemoryHistory() : history.createBrowserHistory());
+      const parsedLocation = this.#parseLocation();
+      this.__store.setState(s => ({
+        ...s,
+        resolvedLocation: parsedLocation,
+        location: parsedLocation
+      }));
+      this.#unsubHistory = this.history.subscribe(() => {
+        this.safeLoad({
+          next: this.#parseLocation(this.state.location)
+        });
+      });
+    }
+    const {
+      basepath,
+      routeTree
+    } = this.options;
+    this.basepath = `/${path.trimPath(basepath ?? '') ?? ''}`;
+    if (routeTree && routeTree !== this.routeTree) {
+      this.#processRoutes(routeTree);
+    }
+    return this;
+  };
+  cancelMatches = () => {
+    this.state.matches.forEach(match => {
+      this.cancelMatch(match.id);
+    });
+  };
+  cancelMatch = id => {
+    this.getRouteMatch(id)?.abortController?.abort();
+  };
+  safeLoad = async opts => {
+    try {
+      return this.load(opts);
+    } catch (err) {
+      // Don't do anything
+    }
+  };
+  latestLoadPromise = Promise.resolve();
+  load = async opts => {
+    const promise = new Promise(async (resolve, reject) => {
+      const prevLocation = this.state.resolvedLocation;
+      const pathDidChange = !!(opts?.next && prevLocation.href !== opts.next.href);
+      let latestPromise;
+      const checkLatest = () => {
+        return this.latestLoadPromise !== promise ? this.latestLoadPromise : undefined;
+      };
+
+      // Cancel any pending matches
+
+      let pendingMatches;
+      this.#emit({
+        type: 'onBeforeLoad',
+        from: prevLocation,
+        to: opts?.next ?? this.state.location,
+        pathChanged: pathDidChange
+      });
+      this.__store.batch(() => {
+        if (opts?.next) {
+          // Ingest the new location
+          this.__store.setState(s => ({
+            ...s,
+            location: opts.next
+          }));
+        }
+
+        // Match the routes
+        pendingMatches = this.matchRoutes(this.state.location.pathname, this.state.location.search, {
+          throwOnError: opts?.throwOnError,
+          debug: true
+        });
+        this.__store.setState(s => ({
+          ...s,
+          status: 'pending',
+          pendingMatchIds: pendingMatches.map(d => d.id),
+          matchesById: this.#mergeMatches(s.matchesById, pendingMatches)
+        }));
+      });
+      try {
+        // Load the matches
+        try {
+          await this.loadMatches(pendingMatches.map(d => d.id));
+        } catch (err) {
+          // swallow this error, since we'll display the
+          // errors on the route components
+        }
+
+        // Only apply the latest transition
+        if (latestPromise = checkLatest()) {
+          return latestPromise;
+        }
+        const exitingMatchIds = this.state.matchIds.filter(id => !this.state.pendingMatchIds.includes(id));
+        const enteringMatchIds = this.state.pendingMatchIds.filter(id => !this.state.matchIds.includes(id));
+        const stayingMatchIds = this.state.matchIds.filter(id => this.state.pendingMatchIds.includes(id));
+        this.__store.setState(s => ({
+          ...s,
+          status: 'idle',
+          resolvedLocation: s.location,
+          matchIds: s.pendingMatchIds,
+          pendingMatchIds: []
+        }));
+        [[exitingMatchIds, 'onLeave'], [enteringMatchIds, 'onEnter'], [stayingMatchIds, 'onTransition']].forEach(([matchIds, hook]) => {
+          matchIds.forEach(id => {
+            const match = this.getRouteMatch(id);
+            const route = this.getRoute(match.routeId);
+            route.options[hook]?.(match);
+          });
+        });
+        this.#emit({
+          type: 'onLoad',
+          from: prevLocation,
+          to: this.state.location,
+          pathChanged: pathDidChange
+        });
+        resolve();
+      } catch (err) {
+        // Only apply the latest transition
+        if (latestPromise = checkLatest()) {
+          return latestPromise;
+        }
+        reject(err);
+      }
+    });
+    this.latestLoadPromise = promise;
+    this.latestLoadPromise.then(() => {
+      this.cleanMatches();
+    });
+    return this.latestLoadPromise;
+  };
+  #mergeMatches = (prevMatchesById, nextMatches) => {
+    let matchesById = {
+      ...prevMatchesById
+    };
+    nextMatches.forEach(match => {
+      if (!matchesById[match.id]) {
+        matchesById[match.id] = match;
+      }
+      matchesById[match.id] = {
+        ...matchesById[match.id],
+        ...match
+      };
+    });
+    return matchesById;
+  };
+  getRoute = id => {
+    const route = this.routesById[id];
+    invariant__default["default"](route, `Route with id "${id}" not found`);
+    return route;
+  };
+  preloadRoute = async (navigateOpts = this.state.location) => {
+    let next = this.buildLocation(navigateOpts);
+    const matches = this.matchRoutes(next.pathname, next.search, {
+      throwOnError: true
+    });
+    this.__store.setState(s => {
+      return {
+        ...s,
+        matchesById: this.#mergeMatches(s.matchesById, matches)
+      };
+    });
+    await this.loadMatches(matches.map(d => d.id), {
+      preload: true,
+      maxAge: navigateOpts.maxAge
+    });
+    return [utils.last(matches), matches];
+  };
+  cleanMatches = () => {
+    const now = Date.now();
+    const outdatedMatchIds = Object.values(this.state.matchesById).filter(match => {
+      const route = this.getRoute(match.routeId);
+      return !this.state.matchIds.includes(match.id) && !this.state.pendingMatchIds.includes(match.id) && (match.preloadMaxAge > -1 ? match.updatedAt + match.preloadMaxAge < now : true) && (route.options.gcMaxAge ? match.updatedAt + route.options.gcMaxAge < now : true);
+    }).map(d => d.id);
+    if (outdatedMatchIds.length) {
+      this.__store.setState(s => {
+        const matchesById = {
+          ...s.matchesById
+        };
+        outdatedMatchIds.forEach(id => {
+          delete matchesById[id];
+        });
+        return {
+          ...s,
+          matchesById
+        };
+      });
+    }
+  };
+  matchRoutes = (pathname, locationSearch, opts) => {
+    let routeParams = {};
+    let foundRoute = this.flatRoutes.find(route => {
+      const matchedParams = path.matchPathname(this.basepath, path.trimPathRight(pathname), {
+        to: route.fullPath,
+        caseSensitive: route.options.caseSensitive ?? this.options.caseSensitive
+      });
+      if (matchedParams) {
+        routeParams = matchedParams;
+        return true;
+      }
+      return false;
+    });
+    let routeCursor = foundRoute || this.routesById['__root__'];
+    let matchedRoutes = [routeCursor];
+    // let includingLayouts = true
+    while (routeCursor?.parentRoute) {
+      routeCursor = routeCursor.parentRoute;
+      if (routeCursor) matchedRoutes.unshift(routeCursor);
+    }
+
+    // Existing matches are matches that are already loaded along with
+    // pending matches that are still loading
+
+    const parseErrors = matchedRoutes.map(route => {
+      let parsedParamsError;
+      if (route.options.parseParams) {
+        try {
+          const parsedParams = route.options.parseParams(routeParams);
+          // Add the parsed params to the accumulated params bag
+          Object.assign(routeParams, parsedParams);
+        } catch (err) {
+          parsedParamsError = new PathParamError(err.message, {
+            cause: err
+          });
+          if (opts?.throwOnError) {
+            throw parsedParamsError;
+          }
+          return parsedParamsError;
+        }
+      }
+      return;
+    });
+    const matches = matchedRoutes.map((route, index) => {
+      const interpolatedPath = path.interpolatePath(route.path, routeParams);
+      const loaderContext = route.options.loaderContext ? route.options.loaderContext({
+        search: locationSearch
+      }) : undefined;
+      const matchId = JSON.stringify([path.interpolatePath(route.id, routeParams, true), loaderContext].filter(d => d !== undefined), (key, value) => {
+        if (typeof value === 'function') {
+          console.info(route);
+          invariant__default["default"](false, `Cannot return functions and other non-serializable values from routeOptions.loaderContext! Please use routeOptions.beforeLoad to do this. Route info is logged above 👆`);
+        }
+        if (typeof value === 'object' && value !== null) {
+          return Object.fromEntries(Object.keys(value).sort().map(key => [key, value[key]]));
+        }
+        return value;
+      });
+
+      // Waste not, want not. If we already have a match for this route,
+      // reuse it. This is important for layout routes, which might stick
+      // around between navigation actions that only change leaf routes.
+      const existingMatch = this.getRouteMatch(matchId);
+      if (existingMatch) {
+        return {
+          ...existingMatch
+        };
+      }
+
+      // Create a fresh route match
+      const hasLoaders = !!(route.options.loader || componentTypes.some(d => route.options[d]?.preload));
+      const routeMatch = {
+        id: matchId,
+        loaderContext,
+        routeId: route.id,
+        params: routeParams,
+        pathname: path.joinPaths([this.basepath, interpolatedPath]),
+        updatedAt: Date.now(),
+        maxAge: -1,
+        preloadMaxAge: -1,
+        routeSearch: {},
+        search: {},
+        status: hasLoaders ? 'pending' : 'success',
+        isFetching: false,
+        invalid: false,
+        error: undefined,
+        paramsError: parseErrors[index],
+        searchError: undefined,
+        loaderData: undefined,
+        loadPromise: Promise.resolve(),
+        context: undefined,
+        abortController: new AbortController(),
+        fetchedAt: 0
+      };
+      return routeMatch;
+    });
+
+    // Take each match and resolve its search params and context
+    // This has to happen after the matches are created or found
+    // so that we can use the parent match's search params and context
+    matches.forEach((match, i) => {
+      const parentMatch = matches[i - 1];
+      const route = this.getRoute(match.routeId);
+      const searchInfo = (() => {
+        // Validate the search params and stabilize them
+        const parentSearchInfo = {
+          search: parentMatch?.search ?? locationSearch,
+          routeSearch: parentMatch?.routeSearch ?? locationSearch
+        };
+        try {
+          const validator = typeof route.options.validateSearch === 'object' ? route.options.validateSearch.parse : route.options.validateSearch;
+          let routeSearch = validator?.(parentSearchInfo.search) ?? {};
+          let search = {
+            ...parentSearchInfo.search,
+            ...routeSearch
+          };
+          routeSearch = utils.replaceEqualDeep(match.routeSearch, routeSearch);
+          search = utils.replaceEqualDeep(match.search, search);
+          return {
+            routeSearch,
+            search,
+            searchDidChange: match.routeSearch !== routeSearch
+          };
+        } catch (err) {
+          match.searchError = new SearchParamError(err.message, {
+            cause: err
+          });
+          if (opts?.throwOnError) {
+            throw match.searchError;
+          }
+          return parentSearchInfo;
+        }
+      })();
+      Object.assign(match, searchInfo);
+    });
+    return matches;
+  };
+  loadMatches = async (matchIds, opts) => {
+    const getFreshMatches = () => matchIds.map(d => this.getRouteMatch(d));
+    if (!opts?.preload) {
+      getFreshMatches().forEach(match => {
+        // Update each match with its latest route data
+        this.setRouteMatch(match.id, s => ({
+          ...s,
+          routeSearch: match.routeSearch,
+          search: match.search,
+          context: match.context,
+          error: match.error,
+          paramsError: match.paramsError,
+          searchError: match.searchError,
+          params: match.params,
+          preloadMaxAge: 0
+        }));
+      });
+    }
+    let firstBadMatchIndex;
+
+    // Check each match middleware to see if the route can be accessed
+    try {
+      for (const [index, match] of getFreshMatches().entries()) {
+        const parentMatch = getFreshMatches()[index - 1];
+        const route = this.getRoute(match.routeId);
+        const handleError = (err, code) => {
+          err.routerCode = code;
+          firstBadMatchIndex = firstBadMatchIndex ?? index;
+          if (isRedirect(err)) {
+            throw err;
+          }
+          try {
+            route.options.onError?.(err);
+          } catch (errorHandlerErr) {
+            err = errorHandlerErr;
+            if (isRedirect(errorHandlerErr)) {
+              throw errorHandlerErr;
+            }
+          }
+          this.setRouteMatch(match.id, s => ({
+            ...s,
+            error: err,
+            status: 'error',
+            updatedAt: Date.now()
+          }));
+        };
+        if (match.paramsError) {
+          handleError(match.paramsError, 'PARSE_PARAMS');
+        }
+        if (match.searchError) {
+          handleError(match.searchError, 'VALIDATE_SEARCH');
+        }
+        let didError = false;
+        const parentContext = parentMatch?.context ?? this?.options.context ?? {};
+        try {
+          const beforeLoadContext = (await route.options.beforeLoad?.({
+            abortController: match.abortController,
+            params: match.params,
+            preload: !!opts?.preload,
+            context: {
+              ...parentContext,
+              ...match.loaderContext
+            }
+          })) ?? {};
+          const context = {
+            ...parentContext,
+            ...match.loaderContext,
+            ...beforeLoadContext
+          };
+          this.setRouteMatch(match.id, s => ({
+            ...s,
+            context: utils.replaceEqualDeep(s.context, context)
+          }));
+        } catch (err) {
+          handleError(err, 'BEFORE_LOAD');
+          didError = true;
+        }
+
+        // If we errored, do not run the next matches' middleware
+        if (didError) {
+          break;
+        }
+      }
+    } catch (err) {
+      if (isRedirect(err)) {
+        if (!opts?.preload) this.navigate(err);
+        return;
+      }
+      throw err;
+    }
+    const validResolvedMatches = getFreshMatches().slice(0, firstBadMatchIndex);
+    const matchPromises = [];
+    validResolvedMatches.forEach((match, index) => {
+      matchPromises.push((async () => {
+        const parentMatchPromise = matchPromises[index - 1];
+        const route = this.getRoute(match.routeId);
+        if (match.isFetching || match.status === 'success' && !isMatchInvalid(match, {
+          preload: opts?.preload
+        })) {
+          return this.getRouteMatch(match.id)?.loadPromise;
+        }
+        const fetchedAt = Date.now();
+        const checkLatest = () => {
+          const latest = this.getRouteMatch(match.id);
+          return latest && latest.fetchedAt !== fetchedAt ? latest.loadPromise : undefined;
+        };
+        const handleIfRedirect = err => {
+          if (isRedirect(err)) {
+            if (!opts?.preload) {
+              this.navigate(err);
+            }
+            return true;
+          }
+          return false;
+        };
+        const load = async () => {
+          let latestPromise;
+          try {
+            const componentsPromise = Promise.all(componentTypes.map(async type => {
+              const component = route.options[type];
+              if (component?.preload) {
+                await component.preload();
+              }
+            }));
+            const loaderPromise = route.options.loader?.({
+              params: match.params,
+              preload: !!opts?.preload,
+              parentMatchPromise,
+              abortController: match.abortController,
+              context: match.context
+            });
+            const [_, loader] = await Promise.all([componentsPromise, loaderPromise]);
+            if (latestPromise = checkLatest()) return await latestPromise;
+            this.setRouteMatchData(match.id, () => loader, opts);
+          } catch (error) {
+            if (latestPromise = checkLatest()) return await latestPromise;
+            if (handleIfRedirect(error)) return;
+            try {
+              route.options.onError?.(error);
+            } catch (onErrorError) {
+              error = onErrorError;
+              if (handleIfRedirect(onErrorError)) return;
+            }
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              error,
+              status: 'error',
+              isFetching: false,
+              updatedAt: Date.now()
+            }));
+          }
+        };
+        let loadPromise;
+        this.__store.batch(() => {
+          this.setRouteMatch(match.id, s => ({
+            ...s,
+            // status: s.status !== 'success' ? 'pending' : s.status,
+            isFetching: true,
+            fetchedAt,
+            invalid: false
+          }));
+          loadPromise = load();
+          this.setRouteMatch(match.id, s => ({
+            ...s,
+            loadPromise
+          }));
+        });
+        await loadPromise;
+      })());
+    });
+    await Promise.all(matchPromises);
+  };
+  resolvePath = (from, path$1) => {
+    return path.resolvePath(this.basepath, from, path.cleanPath(path$1));
+  };
+  navigate = async ({
+    from,
+    to = '',
+    ...rest
+  }) => {
+    // If this link simply reloads the current route,
+    // make sure it has a new key so it will trigger a data refresh
+
+    // If this `to` is a valid external URL, return
+    // null for LinkUtils
+    const toString = String(to);
+    const fromString = typeof from === 'undefined' ? from : String(from);
+    let isExternal;
+    try {
+      new URL(`${toString}`);
+      isExternal = true;
+    } catch (e) {}
+    invariant__default["default"](!isExternal, 'Attempting to navigate to external url with this.navigate!');
+    return this.#buildAndCommitLocation({
+      ...rest,
+      from: fromString,
+      to: toString
+    });
+  };
+  matchRoute = (location, opts) => {
+    location = {
+      ...location,
+      to: location.to ? this.resolvePath(location.from ?? '', location.to) : undefined
+    };
+    const next = this.buildLocation(location);
+    if (opts?.pending && this.state.status !== 'pending') {
+      return false;
+    }
+    const baseLocation = opts?.pending ? this.state.location : this.state.resolvedLocation;
+    if (!baseLocation) {
+      return false;
+    }
+    const match = path.matchPathname(this.basepath, baseLocation.pathname, {
+      ...opts,
+      to: next.pathname
+    });
+    if (!match) {
+      return false;
+    }
+    if (opts?.includeSearch ?? true) {
+      return utils.partialDeepEqual(baseLocation.search, next.search) ? match : false;
+    }
+    return match;
+  };
+  buildLink = dest => {
+    // If this link simply reloads the current route,
+    // make sure it has a new key so it will trigger a data refresh
+
+    // If this `to` is a valid external URL, return
+    // null for LinkUtils
+
+    const {
+      to,
+      preload: userPreload,
+      preloadDelay: userPreloadDelay,
+      activeOptions,
+      disabled,
+      target,
+      replace,
+      resetScroll
+    } = dest;
+    try {
+      new URL(`${to}`);
+      return {
+        type: 'external',
+        href: to
+      };
+    } catch (e) {}
+    const nextOpts = dest;
+    const next = this.buildLocation(nextOpts);
+    const preload = userPreload ?? this.options.defaultPreload;
+    const preloadDelay = userPreloadDelay ?? this.options.defaultPreloadDelay ?? 0;
+
+    // Compare path/hash for matches
+    const currentPathSplit = this.state.location.pathname.split('/');
+    const nextPathSplit = next.pathname.split('/');
+    const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+    // Combine the matches based on user options
+    const pathTest = activeOptions?.exact ? this.state.location.pathname === next.pathname : pathIsFuzzyEqual;
+    const hashTest = activeOptions?.includeHash ? this.state.location.hash === next.hash : true;
+    const searchTest = activeOptions?.includeSearch ?? true ? utils.partialDeepEqual(this.state.location.search, next.search) : true;
+
+    // The final "active" test
+    const isActive = pathTest && hashTest && searchTest;
+
+    // The click handler
+    const handleClick = e => {
+      if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+        e.preventDefault();
+
+        // All is well? Navigate!
+        this.#commitLocation({
+          ...next,
+          replace,
+          resetScroll
+        });
+      }
+    };
+
+    // The click handler
+    const handleFocus = e => {
+      if (preload) {
+        this.preloadRoute(nextOpts).catch(err => {
+          console.warn(err);
+          console.warn(preloadWarning);
+        });
+      }
+    };
+    const handleTouchStart = e => {
+      this.preloadRoute(nextOpts).catch(err => {
+        console.warn(err);
+        console.warn(preloadWarning);
+      });
+    };
+    const handleEnter = e => {
+      const target = e.target || {};
+      if (preload) {
+        if (target.preloadTimeout) {
+          return;
+        }
+        target.preloadTimeout = setTimeout(() => {
+          target.preloadTimeout = null;
+          this.preloadRoute(nextOpts).catch(err => {
+            console.warn(err);
+            console.warn(preloadWarning);
+          });
+        }, preloadDelay);
+      }
+    };
+    const handleLeave = e => {
+      const target = e.target || {};
+      if (target.preloadTimeout) {
+        clearTimeout(target.preloadTimeout);
+        target.preloadTimeout = null;
+      }
+    };
+    return {
+      type: 'internal',
+      next,
+      handleFocus,
+      handleClick,
+      handleEnter,
+      handleLeave,
+      handleTouchStart,
+      isActive,
+      disabled
+    };
+  };
+  dehydrate = () => {
+    return {
+      state: {
+        matchIds: this.state.matchIds,
+        dehydratedMatches: this.state.matches.map(d => utils.pick(d, ['fetchedAt', 'invalid', 'preloadMaxAge', 'maxAge', 'id', 'loaderData', 'status', 'updatedAt']))
+      }
+    };
+  };
+  hydrate = async __do_not_use_server_ctx => {
+    let _ctx = __do_not_use_server_ctx;
+    // Client hydrates from window
+    if (typeof document !== 'undefined') {
+      _ctx = window.__TSR_DEHYDRATED__;
+    }
+    invariant__default["default"](_ctx, 'Expected to find a __TSR_DEHYDRATED__ property on window... but we did not. Did you forget to render <DehydrateRouter /> in your app?');
+    const ctx = _ctx;
+    this.dehydratedData = ctx.payload;
+    this.options.hydrate?.(ctx.payload);
+    const dehydratedState = ctx.router.state;
+    let matches = this.matchRoutes(this.state.location.pathname, this.state.location.search).map(match => {
+      const dehydratedMatch = dehydratedState.dehydratedMatches.find(d => d.id === match.id);
+      invariant__default["default"](dehydratedMatch, `Could not find a client-side match for dehydrated match with id: ${match.id}!`);
+      if (dehydratedMatch) {
+        return {
+          ...match,
+          ...dehydratedMatch
+        };
+      }
+      return match;
+    });
+    this.__store.setState(s => {
+      return {
+        ...s,
+        matchIds: dehydratedState.matchIds,
+        matches,
+        matchesById: this.#mergeMatches(s.matchesById, matches)
+      };
+    });
+  };
+  injectedHtml = [];
+  injectHtml = async html => {
+    this.injectedHtml.push(html);
+  };
+  dehydrateData = (key, getData) => {
+    if (typeof document === 'undefined') {
+      const strKey = typeof key === 'string' ? key : JSON.stringify(key);
+      this.injectHtml(async () => {
+        const id = `__TSR_DEHYDRATED__${strKey}`;
+        const data = typeof getData === 'function' ? await getData() : getData;
+        return `<script id='${id}' suppressHydrationWarning>window["__TSR_DEHYDRATED__${escapeJSON(strKey)}"] = ${JSON.stringify(data)}
+        ;(() => {
+          var el = document.getElementById('${id}')
+          el.parentElement.removeChild(el)
+        })()
+        </script>`;
+      });
+      return () => this.hydrateData(key);
+    }
+    return () => undefined;
+  };
+  hydrateData = key => {
+    if (typeof document !== 'undefined') {
+      const strKey = typeof key === 'string' ? key : JSON.stringify(key);
+      return window[`__TSR_DEHYDRATED__${strKey}`];
+    }
+    return undefined;
+  };
+
+  // resolveMatchPromise = (matchId: string, key: string, value: any) => {
+  //   this.state.matches
+  //     .find((d) => d.id === matchId)
+  //     ?.__promisesByKey[key]?.resolve(value)
+  // }
+
+  #processRoutes = routeTree => {
+    this.routeTree = routeTree;
+    this.routesById = {};
+    this.routesByPath = {};
+    this.flatRoutes = [];
+    const recurseRoutes = routes => {
+      routes.forEach((route, i) => {
+        route.init({
+          originalIndex: i,
+          router: this
+        });
+        const existingRoute = this.routesById[route.id];
+        invariant__default["default"](!existingRoute, `Duplicate routes found with id: ${String(route.id)}`);
+        this.routesById[route.id] = route;
+        if (!route.isRoot && route.path) {
+          const trimmedFullPath = path.trimPathRight(route.fullPath);
+          if (!this.routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {
+            this.routesByPath[trimmedFullPath] = route;
+          }
+        }
+        const children = route.children;
+        if (children?.length) {
+          recurseRoutes(children);
+        }
+      });
+    };
+    recurseRoutes([routeTree]);
+    this.flatRoutes = Object.values(this.routesByPath).map((d, i) => {
+      const trimmed = path.trimPath(d.fullPath);
+      const parsed = path.parsePathname(trimmed);
+      while (parsed.length > 1 && parsed[0]?.value === '/') {
+        parsed.shift();
+      }
+      const score = parsed.map(d => {
+        if (d.type === 'param') {
+          return 0.5;
+        }
+        if (d.type === 'wildcard') {
+          return 0.25;
+        }
+        return 1;
+      });
+      return {
+        child: d,
+        trimmed,
+        parsed,
+        index: i,
+        score
+      };
+    }).sort((a, b) => {
+      let isIndex = a.trimmed === '/' ? 1 : b.trimmed === '/' ? -1 : 0;
+      if (isIndex !== 0) return isIndex;
+      const length = Math.min(a.score.length, b.score.length);
+
+      // Sort by length of score
+      if (a.score.length !== b.score.length) {
+        return b.score.length - a.score.length;
+      }
+
+      // Sort by min available score
+      for (let i = 0; i < length; i++) {
+        if (a.score[i] !== b.score[i]) {
+          return b.score[i] - a.score[i];
+        }
+      }
+
+      // Sort by min available parsed value
+      for (let i = 0; i < length; i++) {
+        if (a.parsed[i].value !== b.parsed[i].value) {
+          return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
+        }
+      }
+
+      // Sort by length of trimmed full path
+      if (a.trimmed !== b.trimmed) {
+        return a.trimmed > b.trimmed ? 1 : -1;
+      }
+
+      // Sort by original index
+      return a.index - b.index;
+    }).map((d, i) => {
+      d.child.rank = i;
+      return d.child;
+    });
+  };
+  #parseLocation = previousLocation => {
+    const parse = ({
+      pathname,
+      search,
+      hash,
+      state
+    }) => {
+      const parsedSearch = this.options.parseSearch(search);
+      return {
+        pathname: pathname,
+        searchStr: search,
+        search: utils.replaceEqualDeep(previousLocation?.search, parsedSearch),
+        hash: hash.split('#').reverse()[0] ?? '',
+        href: `${pathname}${search}${hash}`,
+        state: utils.replaceEqualDeep(previousLocation?.state, state)
+      };
+    };
+    const location = parse(this.history.location);
+    let {
+      __tempLocation,
+      __tempKey
+    } = location.state;
+    if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
+      // Sync up the location keys
+      const parsedTempLocation = parse(__tempLocation);
+      parsedTempLocation.state.key = location.state.key;
+      delete parsedTempLocation.state.__tempLocation;
+      return {
+        ...parsedTempLocation,
+        maskedLocation: location
+      };
+    }
+    return location;
+  };
+  buildLocation = (opts = {}) => {
+    const build = (dest = {}, matches) => {
+      const from = this.state.location;
+      const fromPathname = dest.from ?? from.pathname;
+      let pathname = path.resolvePath(this.basepath ?? '/', fromPathname, `${dest.to ?? ''}`);
+      const fromMatches = this.matchRoutes(fromPathname, from.search);
+      const prevParams = {
+        ...utils.last(fromMatches)?.params
+      };
+      let nextParams = (dest.params ?? true) === true ? prevParams : utils.functionalUpdate(dest.params, prevParams);
+      if (nextParams) {
+        matches?.map(d => this.getRoute(d.routeId).options.stringifyParams).filter(Boolean).forEach(fn => {
+          nextParams = {
+            ...nextParams,
+            ...fn(nextParams)
+          };
+        });
+      }
+      pathname = path.interpolatePath(pathname, nextParams ?? {});
+      const preSearchFilters = matches?.map(match => this.getRoute(match.routeId).options.preSearchFilters ?? []).flat().filter(Boolean) ?? [];
+      const postSearchFilters = matches?.map(match => this.getRoute(match.routeId).options.postSearchFilters ?? []).flat().filter(Boolean) ?? [];
+
+      // Pre filters first
+      const preFilteredSearch = preSearchFilters?.length ? preSearchFilters?.reduce((prev, next) => next(prev), from.search) : from.search;
+
+      // Then the link/navigate function
+      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+      : dest.search ? utils.functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
+      : preSearchFilters?.length ? preFilteredSearch // Preserve resolvedFrom filters
+      : {};
+
+      // Then post filters
+      const postFilteredSearch = postSearchFilters?.length ? postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+      const search = utils.replaceEqualDeep(from.search, postFilteredSearch);
+      const searchStr = this.options.stringifySearch(search);
+      const hash = dest.hash === true ? from.hash : dest.hash ? utils.functionalUpdate(dest.hash, from.hash) : from.hash;
+      const hashStr = hash ? `#${hash}` : '';
+      let nextState = dest.state === true ? from.state : dest.state ? utils.functionalUpdate(dest.state, from.state) : from.state;
+      nextState = utils.replaceEqualDeep(from.state, nextState);
+      return {
+        pathname,
+        search,
+        searchStr,
+        state: nextState,
+        hash,
+        href: this.history.createHref(`${pathname}${searchStr}${hashStr}`),
+        unmaskOnReload: dest.unmaskOnReload
+      };
+    };
+    const buildWithMatches = (dest = {}, maskedDest) => {
+      let next = build(dest);
+      let maskedNext = maskedDest ? build(maskedDest) : undefined;
+      if (!maskedNext) {
+        let params = {};
+        let foundMask = this.options.routeMasks?.find(d => {
+          const match = path.matchPathname(this.basepath, next.pathname, {
+            to: d.from,
+            fuzzy: false
+          });
+          if (match) {
+            params = match;
+            return true;
+          }
+          return false;
+        });
+        if (foundMask) {
+          foundMask = {
+            ...foundMask,
+            from: path.interpolatePath(foundMask.from, params)
+          };
+          maskedDest = foundMask;
+          maskedNext = build(maskedDest);
+        }
+      }
+      const nextMatches = this.matchRoutes(next.pathname, next.search);
+      const maskedMatches = maskedNext ? this.matchRoutes(maskedNext.pathname, maskedNext.search) : undefined;
+      const maskedFinal = maskedNext ? build(maskedDest, maskedMatches) : undefined;
+      const final = build(dest, nextMatches);
+      if (maskedFinal) {
+        final.maskedLocation = maskedFinal;
+      }
+      return final;
+    };
+    if (opts.mask) {
+      return buildWithMatches(opts, {
+        ...utils.pick(opts, ['from']),
+        ...opts.mask
+      });
+    }
+    return buildWithMatches(opts);
+  };
+  #buildAndCommitLocation = ({
+    replace,
+    resetScroll,
+    ...rest
+  } = {}) => {
+    const location = this.buildLocation(rest);
+    return this.#commitLocation({
+      ...location,
+      replace,
+      resetScroll
+    });
+  };
+  #commitLocation = async next => {
+    if (this.navigateTimeout) clearTimeout(this.navigateTimeout);
+    const isSameUrl = this.state.location.href === next.href;
+
+    // If the next urls are the same and we're not replacing,
+    // do nothing
+    if (isSameUrl && !next.replace) {
+      return;
+    }
+    let {
+      maskedLocation,
+      ...nextHistory
+    } = next;
+    if (maskedLocation) {
+      nextHistory = {
+        ...maskedLocation,
+        state: {
+          ...maskedLocation.state,
+          __tempKey: undefined,
+          __tempLocation: {
+            ...nextHistory,
+            search: nextHistory.searchStr,
+            state: {
+              ...nextHistory.state,
+              __tempKey: undefined,
+              __tempLocation: undefined,
+              key: undefined
+            }
+          }
+        }
+      };
+      if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
+        nextHistory.state.__tempKey = this.tempLocationKey;
+      }
+    }
+    this.history[next.replace ? 'replace' : 'push'](nextHistory.href, nextHistory.state);
+    this.resetNextScroll = next.resetScroll ?? true;
+    return this.latestLoadPromise;
+  };
+  getRouteMatch = id => {
+    return this.state.matchesById[id];
+  };
+  setRouteMatch = (id, updater) => {
+    this.__store.setState(prev => {
+      if (!prev.matchesById[id]) {
+        return prev;
+      }
+      return {
+        ...prev,
+        matchesById: {
+          ...prev.matchesById,
+          [id]: updater(prev.matchesById[id])
+        }
+      };
+    });
+  };
+  setRouteMatchData = (id, updater, opts) => {
+    const match = this.getRouteMatch(id);
+    if (!match) return;
+    const route = this.getRoute(match.routeId);
+    const updatedAt = opts?.updatedAt ?? Date.now();
+    const preloadMaxAge = opts?.maxAge ?? route.options.preloadMaxAge ?? this.options.defaultPreloadMaxAge ?? 5000;
+    const maxAge = opts?.maxAge ?? route.options.maxAge ?? this.options.defaultMaxAge ?? -1;
+    this.setRouteMatch(id, s => ({
+      ...s,
+      error: undefined,
+      status: 'success',
+      isFetching: false,
+      updatedAt: updatedAt,
+      loaderData: utils.functionalUpdate(updater, s.loaderData),
+      preloadMaxAge,
+      maxAge
+    }));
+  };
+  invalidate = async opts => {
+    if (opts?.matchId) {
+      this.setRouteMatch(opts.matchId, s => ({
+        ...s,
+        invalid: true
+      }));
+      const matchIndex = this.state.matches.findIndex(d => d.id === opts.matchId);
+      const childMatch = this.state.matches[matchIndex + 1];
+      if (childMatch) {
+        return this.invalidate({
+          matchId: childMatch.id,
+          reload: false,
+          __fromFocus: opts.__fromFocus
+        });
+      }
+    } else {
+      this.__store.batch(() => {
+        Object.values(this.state.matchesById).forEach(match => {
+          const route = this.getRoute(match.routeId);
+          const shouldInvalidate = opts?.__fromFocus ? route.options.reloadOnWindowFocus ?? true : true;
+          if (shouldInvalidate) {
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              invalid: true
+            }));
+          }
+        });
+      });
+    }
+    if (opts?.reload ?? true) {
+      return this.load();
+    }
+  };
+}
+
+// Detect if we're in the DOM
+const isServer = typeof window === 'undefined' || !window.document.createElement;
+function getInitialRouterState() {
+  return {
+    status: 'idle',
+    isFetching: false,
+    resolvedLocation: null,
+    location: null,
+    matchesById: {},
+    matchIds: [],
+    pendingMatchIds: [],
+    matches: [],
+    pendingMatches: [],
+    renderedMatchIds: [],
+    renderedMatches: [],
+    lastUpdated: Date.now()
+  };
+}
+function isCtrlEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+function redirect(opts) {
+  opts.isRedirect = true;
+  return opts;
+}
+function isRedirect(obj) {
+  return !!obj?.isRedirect;
+}
+class SearchParamError extends Error {}
+class PathParamError extends Error {}
+function escapeJSON(jsonString) {
+  return jsonString.replace(/\\/g, '\\\\') // Escape backslashes
+  .replace(/'/g, "\\'") // Escape single quotes
+  .replace(/"/g, '\\"'); // Escape double quotes
+}
+
+// A function that takes an import() argument which is a function and returns a new function that will
+// proxy arguments from the caller to the imported function, retaining all type
+// information along the way
+function lazyFn(fn, key) {
+  return async (...args) => {
+    const imported = await fn();
+    return imported[key || 'default'](...args);
+  };
+}
+function isMatchInvalid(match, opts) {
+  const now = Date.now();
+  if (match.invalid) {
+    return true;
+  }
+  if (opts?.preload) {
+    return match.preloadMaxAge < 0 ? false : match.updatedAt + match.preloadMaxAge < now;
+  }
+  return match.maxAge < 0 ? false : match.updatedAt + match.maxAge < now;
+}
+
+exports.PathParamError = PathParamError;
+exports.Router = Router;
+exports.SearchParamError = SearchParamError;
+exports.componentTypes = componentTypes;
+exports.isMatchInvalid = isMatchInvalid;
+exports.isRedirect = isRedirect;
+exports.lazyFn = lazyFn;
+exports.redirect = redirect;
+//# sourceMappingURL=router.js.map