one/dist/cjs/router/router.js

One is a new React Framework that makes Vite serve both native and web.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
var router_exports = {};
__export(router_exports, {
  canDismiss: () => canDismiss,
  canGoBack: () => canGoBack,
  cleanup: () => cleanup,
  dismiss: () => dismiss,
  dismissAll: () => dismissAll,
  getPreloadHistory: () => getPreloadHistory,
  getSortedRoutes: () => getSortedRoutes,
  getValidationState: () => getValidationState,
  goBack: () => goBack,
  hasAttemptedToHideSplash: () => hasAttemptedToHideSplash,
  initClientMatches: () => initClientMatches,
  initialState: () => initialState,
  initialize: () => initialize,
  isRouteProtected: () => isRouteProtected,
  linkTo: () => linkTo,
  navigate: () => navigate,
  navigationRef: () => navigationRef,
  preloadRoute: () => preloadRoute,
  preloadedLoaderData: () => preloadedLoaderData,
  preloadingLoader: () => preloadingLoader,
  push: () => push,
  registerProtectedRoutes: () => registerProtectedRoutes,
  replace: () => replace,
  rootComponent: () => rootComponent,
  rootState: () => rootState,
  rootStateSnapshot: () => rootStateSnapshot,
  routeInfo: () => routeInfo,
  routeInfoSnapshot: () => routeInfoSnapshot,
  routeNode: () => routeNode,
  setLoadingState: () => setLoadingState,
  setParams: () => setParams,
  setValidationState: () => setValidationState,
  snapshot: () => snapshot,
  subscribeToLoadingState: () => subscribeToLoadingState,
  subscribeToRootState: () => subscribeToRootState,
  subscribeToStore: () => subscribeToStore,
  subscribeToValidationState: () => subscribeToValidationState,
  unregisterProtectedRoutes: () => unregisterProtectedRoutes,
  updateState: () => updateState,
  useOneRouter: () => useOneRouter,
  useStoreRootState: () => useStoreRootState,
  useStoreRouteInfo: () => useStoreRouteInfo,
  useValidationState: () => useValidationState
});
module.exports = __toCommonJS(router_exports);
var import_native = require("@react-navigation/native"), import_react = require("react"), import_react_native = require("react-native-web"), import_registry = require("../devtools/registry"), import_href = require("../link/href"), import_openExternalURL = require("../link/openExternalURL"), import_path = require("../link/path"), import_useBlocker = require("../useBlocker"), import_assertIsReady = require("../utils/assertIsReady"), import_cleanUrl = require("../utils/cleanUrl"), import_dynamicImport = require("../utils/dynamicImport"), import_skewProtection = require("../skewProtection"), import_url = require("../utils/url"), import_validateParams = require("../validateParams"), import_findRouteNode = require("./findRouteNode"), import_getRouteInfo = require("./getRouteInfo"), import_getRoutes = require("./getRoutes"), import_lastAction = require("./lastAction"), import_linkingConfig = require("./linkingConfig"), import_sortRoutes = require("./sortRoutes"), import_useScreens = require("./useScreens"), import_useViteRoutes = require("./useViteRoutes"), import_getNavigateAction = require("./utils/getNavigateAction"), import_useMatches = require("../useMatches"), import_interceptRoutes = require("./interceptRoutes"), import_Navigator = require("../views/Navigator"), import_notFoundState = require("../notFoundState");
let routeNode = null, rootComponent;
const protectedRouteRegistry = /* @__PURE__ */ new Map();
function registerProtectedRoutes(contextKey, protectedScreens) {
  protectedScreens.size === 0 ? protectedRouteRegistry.delete(contextKey) : protectedRouteRegistry.set(contextKey, protectedScreens);
}
function unregisterProtectedRoutes(contextKey) {
  protectedRouteRegistry.delete(contextKey);
}
function isRouteProtected(href) {
  const normalizedHref = href.replace(/^\/+|\/+$/g, "");
  for (const [contextKey, protectedScreens] of protectedRouteRegistry) {
    const normalizedContextKey = contextKey.replace(/^\/+|\/+$/g, "");
    if (normalizedHref.startsWith(normalizedContextKey)) {
      const routeName = normalizedHref.slice(normalizedContextKey.length).replace(/^\//, "").split("/")[0] || "index";
      if (protectedScreens.has(routeName))
        return !0;
    }
  }
  return !1;
}
let hasAttemptedToHideSplash = !1, initialState, rootState, nextState, routeInfo, splashScreenAnimationFrame, navigationRef = null, navigationRefSubscription;
const rootStateSubscribers = /* @__PURE__ */ new Set(), loadingStateSubscribers = /* @__PURE__ */ new Set(), storeSubscribers = /* @__PURE__ */ new Set();
let currentMatches = [], validationState = { status: "idle" };
const validationStateSubscribers = /* @__PURE__ */ new Set();
function subscribeToValidationState(subscriber) {
  return validationStateSubscribers.add(subscriber), () => validationStateSubscribers.delete(subscriber);
}
function setValidationState(state) {
  validationState = state;
  for (const subscriber of validationStateSubscribers)
    subscriber(state);
  state.status === "error" && state.error && window.dispatchEvent(
    new CustomEvent("one-validation-error", {
      detail: {
        error: {
          message: state.error.message,
          name: state.error.name,
          stack: state.error.stack
        },
        href: state.lastValidatedHref,
        timestamp: Date.now()
      }
    })
  );
}
function getValidationState() {
  return validationState;
}
function useValidationState() {
  return (0, import_react.useSyncExternalStore)(
    subscribeToValidationState,
    getValidationState,
    getValidationState
  );
}
function initialize(context, ref, initialLocation) {
  if (cleanUpState(), routeNode = (0, import_getRoutes.getRoutes)(context, {
    ignoreEntryPoints: !0,
    platform: import_react_native.Platform.OS
  }), rootComponent = routeNode ? (0, import_useScreens.getQualifiedRouteComponent)(routeNode) : import_react.Fragment, !routeNode && process.env.NODE_ENV === "production")
    throw new Error("No routes found");
  if (process.env.ONE_DEBUG_ROUTER && routeNode) {
    const formatRouteTree = (node, indent = "", isLast = !0) => {
      const prefix = indent + (isLast ? "\u2514\u2500 " : "\u251C\u2500 "), childIndent = indent + (isLast ? "   " : "\u2502  "), dynamicBadge = node.dynamic ? ` [${node.dynamic.map((d) => d.name).join(", ")}]` : "", typeBadge = node.type !== "layout" ? ` (${node.type})` : "", slotsBadge = node.slots?.size ? ` {@${Array.from(node.slots.keys()).join(", @")}}` : "", routeName = node.route || "/";
      let line = `${prefix}${routeName}${dynamicBadge}${typeBadge}${slotsBadge}`;
      const visibleChildren = node.children.filter((child) => !child.internal);
      for (let i = 0; i < visibleChildren.length; i++) {
        const child = visibleChildren[i], childIsLast = i === visibleChildren.length - 1;
        line += `
` + formatRouteTree(child, childIndent, childIsLast);
      }
      return line;
    };
    if (console.info(`[one] \u{1F4CD} Route structure:
${formatRouteTree(routeNode)}`), routeNode.slots?.size) {
      console.info("[one] \u{1F4E6} Slots on root layout:");
      for (const [slotName, slotConfig] of routeNode.slots)
        console.info(`  @${slotName}:`, {
          defaultRoute: slotConfig.defaultRoute?.route,
          interceptRoutes: slotConfig.interceptRoutes.map((r) => ({
            route: r.route,
            intercept: r.intercept
          }))
        });
    }
  }
  navigationRef = ref, setupLinkingAndRouteInfo(initialLocation), subscribeToNavigationChanges();
}
function cleanUpState() {
  initialState = void 0, rootState = void 0, nextState = void 0, routeInfo = void 0, (0, import_linkingConfig.resetLinking)(), navigationRefSubscription?.(), rootStateSubscribers.clear(), storeSubscribers.clear();
}
function setupLinkingAndRouteInfo(initialLocation) {
  initialState = (0, import_linkingConfig.setupLinking)(routeNode, initialLocation), initialState ? (rootState = initialState, routeInfo = (0, import_getRouteInfo.getRouteInfo)(initialState)) : routeInfo = {
    unstable_globalHref: "",
    pathname: "",
    isIndex: !1,
    params: {},
    segments: []
  };
}
function subscribeToNavigationChanges() {
  navigationRefSubscription = navigationRef.addListener("state", (data) => {
    let state = { ...data.data.state };
    state.key && hashes[state.key] && (state.hash = hashes[state.key], delete hashes[state.key]), hasAttemptedToHideSplash || (hasAttemptedToHideSplash = !0, splashScreenAnimationFrame = requestAnimationFrame(() => {
    })), nextOptions && (state = { ...state, linkOptions: nextOptions }, nextOptions = null);
    let shouldUpdateSubscribers = nextState === state;
    nextState = void 0, state && state !== rootState && (updateState(state, void 0), shouldUpdateSubscribers = !0), shouldUpdateSubscribers && (0, import_react.startTransition)(() => {
      for (const subscriber of rootStateSubscribers)
        subscriber(state);
    });
  }), (0, import_react.startTransition)(() => {
    updateSnapshot();
    for (const subscriber of storeSubscribers)
      subscriber();
  });
}
function navigate(url, options) {
  return linkTo((0, import_href.resolveHref)(url), "NAVIGATE", options);
}
function push(url, options) {
  return linkTo((0, import_href.resolveHref)(url), "PUSH", options);
}
function dismiss(count) {
  process.env.ONE_DEBUG_ROUTER && console.info(`[one] \u{1F519} dismiss${count ? ` (${count})` : ""}`), navigationRef?.dispatch(import_native.StackActions.pop(count));
}
function replace(url, options) {
  return linkTo((0, import_href.resolveHref)(url), "REPLACE", options);
}
function setParams(params = {}) {
  return (0, import_assertIsReady.assertIsReady)(navigationRef), navigationRef?.current?.setParams(
    // @ts-expect-error
    params
  );
}
function dismissAll() {
  process.env.ONE_DEBUG_ROUTER && console.info("[one] \u{1F519} dismissAll"), navigationRef?.dispatch(import_native.StackActions.popToTop());
}
function goBack() {
  process.env.ONE_DEBUG_ROUTER && console.info("[one] \u{1F519} goBack"), (0, import_assertIsReady.assertIsReady)(navigationRef), navigationRef?.current?.goBack();
}
function canGoBack() {
  return navigationRef.isReady() ? navigationRef?.current?.canGoBack() ?? !1 : !1;
}
function canDismiss() {
  let state = rootState;
  for (; state; ) {
    if (state.type === "stack" && state.routes.length > 1)
      return !0;
    if (state.index === void 0)
      return !1;
    state = state.routes?.[state.index]?.state;
  }
  return !1;
}
function getSortedRoutes() {
  if (!routeNode)
    throw new Error("No routes");
  return routeNode.children.filter((route) => !route.internal).sort(import_sortRoutes.sortRoutes);
}
function updateState(state, nextStateParam = state) {
  rootState = state, nextState = nextStateParam;
  const nextRouteInfo = (0, import_getRouteInfo.getRouteInfo)(state);
  if (!deepEqual(routeInfo, nextRouteInfo)) {
    if (process.env.ONE_DEBUG_ROUTER) {
      const from = routeInfo?.pathname || "(initial)", to = nextRouteInfo.pathname, params = Object.keys(nextRouteInfo.params || {}).length ? nextRouteInfo.params : void 0;
      console.info(`[one] \u{1F9ED} ${from} \u2192 ${to}`, params ? { params } : "");
    }
    routeInfo = nextRouteInfo;
  }
  process.env.NODE_ENV === "development" && typeof window < "u" && (window.__oneDevtools = {
    routeInfo: nextRouteInfo,
    rootState: state,
    routeNode,
    getRoutes: () => routeNode?.children || [],
    getLoaderTimingHistory: () => import_registry.devtoolsRegistry.getLoaderTimingHistory?.() ?? [],
    getPreloadHistory
  }, window.dispatchEvent(new CustomEvent("one-route-change", { detail: nextRouteInfo })));
}
function subscribeToRootState(subscriber) {
  return rootStateSubscribers.add(subscriber), () => {
    rootStateSubscribers.delete(subscriber);
  };
}
function subscribeToStore(subscriber) {
  return storeSubscribers.add(subscriber), () => {
    storeSubscribers.delete(subscriber);
  };
}
function subscribeToLoadingState(subscriber) {
  return loadingStateSubscribers.add(subscriber), () => {
    loadingStateSubscribers.delete(subscriber);
  };
}
function setLoadingState(state) {
  (0, import_react.startTransition)(() => {
    for (const listener of loadingStateSubscribers)
      listener(state);
  });
}
let currentSnapshot = null;
function updateSnapshot() {
  currentSnapshot = getSnapshot();
}
function snapshot() {
  return currentSnapshot;
}
function getSnapshot() {
  return {
    linkTo,
    routeNode,
    rootComponent,
    linking: (0, import_linkingConfig.getLinking)(),
    hasAttemptedToHideSplash,
    initialState,
    rootState,
    nextState,
    routeInfo,
    splashScreenAnimationFrame,
    navigationRef,
    navigationRefSubscription,
    rootStateSubscribers,
    storeSubscribers
  };
}
function rootStateSnapshot() {
  return rootState;
}
function routeInfoSnapshot() {
  return routeInfo;
}
function useOneRouter() {
  const state = (0, import_react.useSyncExternalStore)(subscribeToStore, snapshot, snapshot);
  return (0, import_react.useDeferredValue)(state);
}
function syncStoreRootState() {
  if (!navigationRef)
    throw new Error("No navigationRef, possible duplicate One dep");
  if (navigationRef.isReady()) {
    const currentState = navigationRef.getRootState();
    rootState !== currentState && updateState(currentState);
  }
}
function useStoreRootState() {
  syncStoreRootState();
  const state = (0, import_react.useSyncExternalStore)(
    subscribeToRootState,
    rootStateSnapshot,
    rootStateSnapshot
  );
  return (0, import_react.useDeferredValue)(state);
}
function useStoreRouteInfo() {
  return syncStoreRootState(), (0, import_react.useSyncExternalStore)(
    subscribeToRootState,
    routeInfoSnapshot,
    routeInfoSnapshot
  );
}
function cleanup() {
  splashScreenAnimationFrame && cancelAnimationFrame(splashScreenAnimationFrame);
}
const preloadingLoader = {};
async function doPreloadDev(href) {
  if (process.env.NODE_ENV === "development") {
    const startTime = performance.now(), normalizedPath = normalizeLoaderPath(href);
    try {
      const loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(href, !0), moduleLoadStart = performance.now(), modulePromise = (0, import_dynamicImport.dynamicImport)(loaderJSUrl);
      if (!modulePromise)
        return null;
      const module2 = await modulePromise.catch(() => null), moduleLoadTime = performance.now() - moduleLoadStart;
      if (!module2?.loader)
        return null;
      const executionStart = performance.now(), result = await module2.loader(), executionTime = performance.now() - executionStart, totalTime = performance.now() - startTime;
      return result?.__oneRedirect ? result : (import_registry.devtoolsRegistry.recordLoaderTiming?.({
        path: normalizedPath,
        startTime,
        moduleLoadTime,
        executionTime,
        totalTime,
        source: "preload"
      }), result ?? null);
    } catch (err) {
      const totalTime = performance.now() - startTime;
      return import_registry.devtoolsRegistry.recordLoaderTiming?.({
        path: normalizedPath,
        startTime,
        totalTime,
        error: err instanceof Error ? err.message : String(err),
        source: "preload"
      }), process.env.ONE_DEBUG_ROUTER && console.warn(`[one] dev preload failed for ${href}:`, err), null;
    }
  }
}
async function doPreload(href) {
  const preloadPath = (0, import_cleanUrl.getPreloadPath)(href), loaderPath = (0, import_cleanUrl.getLoaderPath)(href), cssPreloadPath = (0, import_cleanUrl.getPreloadCSSPath)(href);
  recordPreloadStart(href);
  try {
    const [_preload, cssPreloadModule, loader] = await Promise.all([
      (0, import_dynamicImport.dynamicImport)(preloadPath)?.catch((err) => (recordPreloadError(href, err instanceof Error ? err.message : String(err)), null)),
      (0, import_dynamicImport.dynamicImport)(cssPreloadPath)?.catch(() => null) ?? Promise.resolve(null),
      (0, import_dynamicImport.dynamicImport)(loaderPath)?.catch(() => null) ?? Promise.resolve(null),
      (0, import_useViteRoutes.preloadRouteModules)(href)
    ]), hasCss = !!cssPreloadModule?.injectCSS;
    if (hasCss && (cssInjectFunctions[href] = cssPreloadModule.injectCSS), !!!loader?.loader)
      return recordPreloadComplete(href, !1, hasCss), null;
    const result = await loader.loader();
    return result?.__oneRedirect ? result : (recordPreloadComplete(href, !0, hasCss), result ?? null);
  } catch (err) {
    const errorMessage = err instanceof Error ? err.message : String(err);
    return console.error(`[one] preload error for ${href}:`, err), recordPreloadError(href, errorMessage), null;
  }
}
const preloadedLoaderData = {}, cssInjectFunctions = {}, preloadHistory = [], MAX_PRELOAD_HISTORY = 30;
function recordPreloadStart(href) {
  if (process.env.NODE_ENV !== "development") return;
  const existing = preloadHistory.find((p) => p.href === href);
  if (existing) {
    existing.status = "loading", existing.startTime = performance.now();
    return;
  }
  preloadHistory.unshift({
    href,
    status: "loading",
    startTime: performance.now(),
    hasLoader: !1,
    hasCss: !1
  }), preloadHistory.length > MAX_PRELOAD_HISTORY && preloadHistory.pop(), dispatchPreloadEvent();
}
function recordPreloadComplete(href, hasLoader, hasCss) {
  if (process.env.NODE_ENV !== "development") return;
  const entry = preloadHistory.find((p) => p.href === href);
  entry && (entry.status = "loaded", entry.endTime = performance.now(), entry.hasLoader = hasLoader, entry.hasCss = hasCss), dispatchPreloadEvent();
}
function recordPreloadError(href, error) {
  if (process.env.NODE_ENV !== "development") return;
  const entry = preloadHistory.find((p) => p.href === href);
  entry && (entry.status = "error", entry.endTime = performance.now(), entry.error = error), dispatchPreloadEvent();
}
function dispatchPreloadEvent() {
  window.dispatchEvent(new CustomEvent("one-preload-update"));
}
function getPreloadHistory() {
  return preloadHistory;
}
function preloadRoute(href, injectCSS = !1) {
  if (process.env.NODE_ENV === "development") {
    const normalizedHref = normalizeLoaderPath(href);
    return preloadingLoader[normalizedHref] || (preloadingLoader[normalizedHref] = doPreloadDev(href).then((data) => (preloadedLoaderData[normalizedHref] = data, data))), preloadingLoader[normalizedHref];
  }
  return preloadingLoader[href] || (preloadingLoader[href] = doPreload(href).then((data) => (preloadedLoaderData[href] = data, data))), injectCSS ? preloadingLoader[href]?.then(async (data) => {
    const inject = cssInjectFunctions[href];
    return inject && await Promise.race([inject(), new Promise((r) => setTimeout(r, 800))]), data;
  }) : preloadingLoader[href];
}
function normalizeLoaderPath(href) {
  return new URL(href, "http://example.com").pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
}
function buildClientMatches(href, matchingNode, params, loaderData) {
  const pathname = (0, import_findRouteNode.extractPathnameFromHref)(href), routeId = matchingNode?.contextKey || pathname, layoutMatches = currentMatches.filter((m) => m.routeId.includes("_layout")), pageMatch = {
    routeId,
    pathname,
    params,
    loaderData
  };
  return [...layoutMatches, pageMatch];
}
function initClientMatches(matches) {
  currentMatches = matches, (0, import_useMatches.setClientMatches)(matches);
}
async function linkTo(href, event, options) {
  if (process.env.ONE_DEBUG_ROUTER && console.info(`[one] \u{1F517} ${event || "NAVIGATE"} ${href}`), (0, import_interceptRoutes.setNavigationType)("soft"), (0, import_notFoundState.clearNotFoundState)(), href[0] === "#")
    return;
  if ((0, import_url.shouldLinkExternally)(href)) {
    (0, import_openExternalURL.openExternalURL)(href);
    return;
  }
  if ((0, import_skewProtection.isVersionStale)()) {
    window.location.href = href;
    return;
  }
  if ((0, import_useBlocker.checkBlocker)(href, event === "REPLACE" ? "replace" : "push") || isRouteProtected(href))
    return;
  const currentLayoutNode = routeNode, currentPath = routeInfo?.pathname || "/", interceptResult = (0, import_interceptRoutes.findInterceptRoute)(href, currentLayoutNode, currentPath);
  if (interceptResult) {
    const { interceptRoute, slotName, layoutContextKey, params: params2 } = interceptResult, scopedSlotKey = `${layoutContextKey}:${slotName}`;
    (0, import_interceptRoutes.storeInterceptState)(scopedSlotKey, interceptRoute, params2), (0, import_interceptRoutes.updateURLWithoutNavigation)(href), (0, import_Navigator.setSlotState)(scopedSlotKey, {
      activeRouteKey: interceptRoute.contextKey,
      activeRouteNode: interceptRoute,
      params: params2,
      isIntercepted: !0
    });
    return;
  }
  (0, import_assertIsReady.assertIsReady)(navigationRef);
  const current = navigationRef.current;
  if (current == null)
    throw new Error(
      "Couldn't find a navigation object. Is your component inside NavigationContainer?"
    );
  const linking = (0, import_linkingConfig.getLinking)();
  if (!linking)
    throw new Error("Attempted to link to route when no routes are present");
  if ((0, import_lastAction.setLastAction)(), href === ".." || href === "../") {
    current.goBack();
    return;
  }
  if (href.startsWith(".")) {
    let base = routeInfo?.segments?.map((segment) => {
      if (!segment.startsWith("[")) return segment;
      if (segment.startsWith("[...")) {
        segment = segment.slice(4, -1);
        const params2 = routeInfo?.params?.[segment];
        return Array.isArray(params2) ? params2.join("/") : params2?.split(",")?.join("/") ?? "";
      }
      return segment = segment.slice(1, -1), routeInfo?.params?.[segment];
    }).filter(Boolean).join("/") ?? "/";
    routeInfo?.isIndex || (base += "/.."), href = (0, import_path.resolve)(base, href);
  }
  const state = linking.getStateFromPath(href, linking.config);
  if (!state || state.routes.length === 0) {
    console.error(
      "Could not generate a valid navigation state for the given path: " + href
    ), console.error("linking.config", linking.config), console.error("routes", getSortedRoutes());
    return;
  }
  setLoadingState("loading");
  const normalizedPreloadPath = normalizeLoaderPath(href);
  if (!(normalizedPreloadPath in preloadedLoaderData) && !(href in preloadedLoaderData))
    await preloadRoute(href, !0);
  else if (process.env.NODE_ENV !== "development") {
    const inject = cssInjectFunctions[href];
    inject && inject().catch(() => {
    });
  }
  const preloadResult = preloadedLoaderData[normalizedPreloadPath];
  if (preloadResult?.__oneRedirect) {
    const redirectTarget = preloadResult.__oneRedirect;
    delete preloadedLoaderData[normalizedPreloadPath], delete preloadingLoader[normalizedPreloadPath], delete preloadedLoaderData[href], delete preloadingLoader[href], setLoadingState("loaded"), linkTo(redirectTarget, "REPLACE");
    return;
  }
  if (preloadResult?.__oneError === 404) {
    delete preloadedLoaderData[normalizedPreloadPath], delete preloadingLoader[normalizedPreloadPath], delete preloadedLoaderData[href], delete preloadingLoader[href], setLoadingState("loaded");
    const notFoundRoute = (0, import_notFoundState.findNearestNotFoundRoute)(href, routeNode);
    (0, import_notFoundState.setNotFoundState)({
      notFoundPath: preloadResult.__oneNotFoundPath || "/+not-found",
      notFoundRouteNode: notFoundRoute || void 0,
      originalPath: href
    });
    return;
  }
  const matchingRouteNode = (0, import_findRouteNode.findRouteNodeFromState)(state, routeNode);
  if (matchingRouteNode?.loadRoute) {
    setValidationState({ status: "validating", lastValidatedHref: href });
    try {
      const loadedRoute = matchingRouteNode.loadRoute(), params2 = (0, import_findRouteNode.extractParamsFromState)(state), search = (0, import_findRouteNode.extractSearchFromHref)(href), pathname = (0, import_findRouteNode.extractPathnameFromHref)(href);
      if (loadedRoute.validateParams && (0, import_validateParams.validateParams)(loadedRoute.validateParams, params2), loadedRoute.validateRoute) {
        const validationResult = await loadedRoute.validateRoute({
          params: params2,
          search,
          pathname,
          href
        });
        if (validationResult && !validationResult.valid) {
          const error = new import_validateParams.RouteValidationError(
            validationResult.error || "Route validation failed",
            validationResult.details
          );
          throw setValidationState({ status: "error", error, lastValidatedHref: href }), error;
        }
      }
      setValidationState({ status: "valid", lastValidatedHref: href });
    } catch (error) {
      if (error && typeof error.then == "function")
        await error.catch(() => {
        }), setValidationState({ status: "valid", lastValidatedHref: href });
      else throw (error instanceof import_validateParams.ParamValidationError || error instanceof import_validateParams.RouteValidationError) && setValidationState({ status: "error", error, lastValidatedHref: href }), error;
    }
  }
  const normalizedPath = normalizeLoaderPath(href), loaderData = preloadedLoaderData[normalizedPath], params = (0, import_findRouteNode.extractParamsFromState)(state), newMatches = buildClientMatches(href, matchingRouteNode, params, loaderData);
  currentMatches = newMatches, (0, import_useMatches.setClientMatches)(newMatches);
  const rootState2 = navigationRef.getRootState(), hash = href.indexOf("#");
  rootState2.key && hash > 0 && (hashes[rootState2.key] = href.slice(hash)), nextOptions = options ?? null, (0, import_react.startTransition)(() => {
    const action = (0, import_getNavigateAction.getNavigateAction)(state, rootState2, event), current2 = navigationRef.getCurrentRoute();
    navigationRef.dispatch(action);
    let warningTm;
    const interval = setInterval(() => {
      const next = navigationRef.getCurrentRoute();
      current2 !== next && setTimeout(() => {
        setLoadingState("loaded");
      }), clearTimeout(warningTm), clearTimeout(interval);
    }, 16);
    process.env.NODE_ENV === "development" && (warningTm = setTimeout(() => {
      console.warn("Routing took more than 8 seconds");
    }, 1e3));
  });
}
const hashes = {};
let nextOptions = null;
function deepEqual(a, b) {
  if (a === b)
    return !0;
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length)
      return !1;
    for (let i = 0; i < a.length; i++)
      if (!deepEqual(a[i], b[i]))
        return !1;
    return !0;
  }
  if (typeof a == "object" && typeof b == "object") {
    const keysA = Object.keys(a), keysB = Object.keys(b);
    if (keysA.length !== keysB.length)
      return !1;
    for (const key of keysA)
      if (!deepEqual(a[key], b[key]))
        return !1;
    return !0;
  }
  return !1;
}
//# sourceMappingURL=router.js.map