one 1.14.4 → 1.15.0

package/dist/esm/router/router.mjs

@@ -25,11 +25,15 @@ import { setClientMatches } from "../useMatches.mjs";
 import { findInterceptRoute, setNavigationType, updateURLWithoutNavigation, storeInterceptState } from "./interceptRoutes.mjs";
 import { setSlotState } from "../views/Navigator.mjs";
 import { clearNotFoundState, findNearestNotFoundRoute, setNotFoundState } from "../notFoundState.mjs";
-let routeNode = null,
-  rootComponent;
+let routeNode = null;
+let rootComponent;
 const protectedRouteRegistry = /* @__PURE__ */new Map();
 function registerProtectedRoutes(contextKey, protectedScreens) {
-  protectedScreens.size === 0 ? protectedRouteRegistry.delete(contextKey) : protectedRouteRegistry.set(contextKey, protectedScreens);
+  if (protectedScreens.size === 0) {
+    protectedRouteRegistry.delete(contextKey);
+  } else {
+    protectedRouteRegistry.set(contextKey, protectedScreens);
+  }
 }
 function unregisterProtectedRoutes(contextKey) {
   protectedRouteRegistry.delete(contextKey);
@@ -39,46 +43,54 @@ function isRouteProtected(href) {
   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",
-        normalizedRouteName = routeName.replace(/\/index$/, "");
-      if (protectedScreens.has(routeName) || protectedScreens.has(normalizedRouteName)) return !0;
+      const relativePath = normalizedHref.slice(normalizedContextKey.length).replace(/^\//, "");
+      const routeName = relativePath.split("/")[0] || "index";
+      const normalizedRouteName = routeName.replace(/\/index$/, "");
+      if (protectedScreens.has(routeName) || protectedScreens.has(normalizedRouteName)) {
+        return true;
+      }
     }
   }
-  return !1;
-}
-let hasAttemptedToHideSplash = !1,
-  initialState,
-  rootState,
-  initialPathname,
-  nextState,
-  routeInfo,
-  splashScreenAnimationFrame,
-  navigationRef = null;
-const rootStateSubscribers = /* @__PURE__ */new Set(),
-  loadingStateSubscribers = /* @__PURE__ */new Set(),
-  storeSubscribers = /* @__PURE__ */new Set();
-let currentMatches = [],
-  validationState = {
-    status: "idle"
-  };
+  return false;
+}
+let hasAttemptedToHideSplash = false;
+let initialState;
+let rootState;
+let initialPathname;
+let nextState;
+let routeInfo;
+let splashScreenAnimationFrame;
+let navigationRef = null;
+const rootStateSubscribers = /* @__PURE__ */new Set();
+const loadingStateSubscribers = /* @__PURE__ */new Set();
+const storeSubscribers = /* @__PURE__ */new Set();
+let currentMatches = [];
+let validationState = {
+  status: "idle"
+};
 const validationStateSubscribers = /* @__PURE__ */new Set();
 function subscribeToValidationState(subscriber) {
-  return validationStateSubscribers.add(subscriber), () => validationStateSubscribers.delete(subscriber);
+  validationStateSubscribers.add(subscriber);
+  return () => 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()
-    }
-  }));
+  for (const subscriber of validationStateSubscribers) {
+    subscriber(state);
+  }
+  if (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;
@@ -86,76 +98,128 @@ function getValidationState() {
 function useValidationState() {
   return useSyncExternalStore(subscribeToValidationState, getValidationState, getValidationState);
 }
-let cachedRouteNode = null,
-  cachedRootComponent = null,
-  cachedContext = null;
+let cachedRouteNode = null;
+let cachedRootComponent = null;
+let cachedContext = null;
 function initialize(context, ref, initialLocation) {
-  if (cleanUpState(), (context !== cachedContext || !cachedRouteNode) && (cachedRouteNode = getRoutes(context, {
-    ignoreEntryPoints: !0,
-    platform: Platform.OS
-  }), cachedRootComponent = cachedRouteNode ? getQualifiedRouteComponent(cachedRouteNode) : Fragment, cachedContext = context), routeNode = cachedRouteNode, rootComponent = cachedRootComponent || Fragment, !routeNode && process.env.NODE_ENV === "production") throw new Error("No routes found");
+  cleanUpState();
+  if (context !== cachedContext || !cachedRouteNode) {
+    cachedRouteNode = getRoutes(context, {
+      ignoreEntryPoints: true,
+      platform: Platform.OS
+    });
+    cachedRootComponent = cachedRouteNode ? getQualifiedRouteComponent(cachedRouteNode) : Fragment;
+    cachedContext = context;
+  }
+  routeNode = cachedRouteNode;
+  rootComponent = cachedRootComponent || Fragment;
+  if (!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 || "/";
+    const formatRouteTree = (node, indent = "", isLast = true) => {
+      const prefix = indent + (isLast ? "\u2514\u2500 " : "\u251C\u2500 ");
+      const childIndent = indent + (isLast ? "   " : "\u2502  ");
+      const dynamicBadge = node.dynamic ? ` [${node.dynamic.map(d => d.name).join(", ")}]` : "";
+      const typeBadge = node.type !== "layout" ? ` (${node.type})` : "";
+      const slotsBadge = node.slots?.size ? ` {@${Array.from(node.slots.keys()).join(", @")}}` : "";
+      const 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);
+        const child = visibleChildren[i];
+        const childIsLast = i === visibleChildren.length - 1;
+        line += "\n" + 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
-        }))
-      });
+    console.info(`[one] \u{1F4CD} Route structure:
+${formatRouteTree(routeNode)}`);
+    if (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();
+  navigationRef = ref;
+  setupLinkingAndRouteInfo(initialLocation);
+  subscribeToNavigationChanges();
 }
 function cleanUpState() {
-  initialState = void 0, initialPathname = void 0, rootState = void 0, nextState = void 0, routeInfo = void 0, resetLinking(), rootStateSubscribers.clear(), storeSubscribers.clear();
+  initialState = void 0;
+  initialPathname = void 0;
+  rootState = void 0;
+  nextState = void 0;
+  routeInfo = void 0;
+  resetLinking();
+  rootStateSubscribers.clear();
+  storeSubscribers.clear();
 }
 function setupLinkingAndRouteInfo(initialLocation) {
-  initialState = setupLinking(routeNode, initialLocation), initialPathname = initialLocation?.pathname ?? (typeof window < "u" ? window.location.pathname : void 0), initialState ? (rootState = initialState, routeInfo = getRouteInfo(initialState)) : routeInfo = {
-    unstable_globalHref: "",
-    pathname: "",
-    isIndex: !1,
-    params: {},
-    segments: []
-  };
+  initialState = setupLinking(routeNode, initialLocation);
+  initialPathname = initialLocation?.pathname ?? (typeof window !== "undefined" ? window.location.pathname : void 0);
+  if (initialState) {
+    rootState = initialState;
+    routeInfo = getRouteInfo(initialState);
+  } else {
+    routeInfo = {
+      unstable_globalHref: "",
+      pathname: "",
+      isIndex: false,
+      params: {},
+      segments: []
+    };
+  }
 }
 function handleNavigationContainerStateChange(navState) {
   if (!navState) return;
   let state = {
     ...navState
   };
-  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);
+  if (state.key) {
+    if (hashes[state.key]) {
+      state.hash = hashes[state.key];
+      delete hashes[state.key];
+    }
+  }
+  if (!hasAttemptedToHideSplash) {
+    hasAttemptedToHideSplash = true;
+    splashScreenAnimationFrame = requestAnimationFrame(() => {});
+  }
+  if (nextOptions) {
+    state = {
+      ...state,
+      linkOptions: nextOptions
+    };
+    nextOptions = null;
+  }
   let shouldUpdateSubscribers = nextState === state;
-  nextState = void 0, state && state !== rootState && (updateState(state, void 0), shouldUpdateSubscribers = !0), shouldUpdateSubscribers && startTransition(() => {
-    for (const subscriber of rootStateSubscribers) subscriber(state);
-  });
+  nextState = void 0;
+  if (state && state !== rootState) {
+    updateState(state, void 0);
+    shouldUpdateSubscribers = true;
+  }
+  if (shouldUpdateSubscribers) {
+    startTransition(() => {
+      for (const subscriber of rootStateSubscribers) {
+        subscriber(state);
+      }
+    });
+  }
 }
 function subscribeToNavigationChanges() {
   startTransition(() => {
     updateSnapshot();
-    for (const subscriber of storeSubscribers) subscriber();
+    for (const subscriber of storeSubscribers) {
+      subscriber();
+    }
   });
 }
 function navigate(url, options) {
@@ -165,81 +229,119 @@ function push(url, options) {
   return linkTo(resolveHref(url), "PUSH", options);
 }
 function dismiss(count) {
-  process.env.ONE_DEBUG_ROUTER && console.info(`[one] \u{1F519} dismiss${count ? ` (${count})` : ""}`), navigationRef?.dispatch(StackActions.pop(count));
+  if (process.env.ONE_DEBUG_ROUTER) {
+    console.info(`[one] \u{1F519} dismiss${count ? ` (${count})` : ""}`);
+  }
+  navigationRef?.dispatch(StackActions.pop(count));
 }
 function replace(url, options) {
   return linkTo(resolveHref(url), "REPLACE", options);
 }
 function setParams(params = {}) {
-  return assertIsReady(navigationRef), navigationRef?.current?.setParams(
+  assertIsReady(navigationRef);
+  return navigationRef?.current?.setParams(
   // @ts-expect-error
   params);
 }
 function dismissAll() {
-  process.env.ONE_DEBUG_ROUTER && console.info("[one] \u{1F519} dismissAll"), navigationRef?.dispatch(StackActions.popToTop());
+  if (process.env.ONE_DEBUG_ROUTER) {
+    console.info(`[one] \u{1F519} dismissAll`);
+  }
+  navigationRef?.dispatch(StackActions.popToTop());
 }
 function goBack() {
-  process.env.ONE_DEBUG_ROUTER && console.info("[one] \u{1F519} goBack"), assertIsReady(navigationRef), navigationRef?.current?.goBack();
+  if (process.env.ONE_DEBUG_ROUTER) {
+    console.info(`[one] \u{1F519} goBack`);
+  }
+  assertIsReady(navigationRef);
+  navigationRef?.current?.goBack();
 }
 function canGoBack() {
-  return navigationRef.isReady() ? navigationRef?.current?.canGoBack() ?? !1 : !1;
+  if (!navigationRef.isReady()) {
+    return false;
+  }
+  return navigationRef?.current?.canGoBack() ?? false;
 }
 function canDismiss() {
   let state = rootState;
-  for (; state;) {
-    if (state.type === "stack" && state.routes.length > 1) return !0;
-    if (state.index === void 0) return !1;
+  while (state) {
+    if (state.type === "stack" && state.routes.length > 1) {
+      return true;
+    }
+    if (state.index === void 0) {
+      return false;
+    }
     state = state.routes?.[state.index]?.state;
   }
-  return !1;
+  return false;
 }
 function getSortedRoutes() {
-  if (!routeNode) throw new Error("No routes");
+  if (!routeNode) {
+    throw new Error("No routes");
+  }
   return routeNode.children.filter(route => !route.internal).sort(sortRoutes);
 }
 function updateState(state, nextStateParam = state) {
-  rootState = state, nextState = nextStateParam;
+  rootState = state;
+  nextState = nextStateParam;
   const nextRouteInfo = 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;
+      const from = routeInfo?.pathname || "(initial)";
+      const to = nextRouteInfo.pathname;
+      const params = Object.keys(nextRouteInfo.params || {}).length ? nextRouteInfo.params : void 0;
       console.info(`[one] \u{1F9ED} ${from} \u2192 ${to}`, params ? {
         params
       } : "");
     }
     routeInfo = nextRouteInfo;
+    if (false) {
+      const params = extractParamsFromState(state);
+      const newMatches = buildNativeMatches(state, nextRouteInfo.pathname, params);
+      currentMatches = newMatches;
+      setClientMatches(newMatches);
+    }
+  }
+  if (process.env.NODE_ENV === "development" && typeof window !== "undefined") {
+    ;
+    window.__oneDevtools = {
+      routeInfo: nextRouteInfo,
+      rootState: state,
+      routeNode,
+      getRoutes: () => routeNode?.children || [],
+      getLoaderTimingHistory: () => devtoolsRegistry.getLoaderTimingHistory?.() ?? [],
+      getPreloadHistory
+    };
+    if (true) {
+      window.dispatchEvent(new CustomEvent("one-route-change", {
+        detail: nextRouteInfo
+      }));
+    }
   }
-  process.env.NODE_ENV === "development" && typeof window < "u" && (window.__oneDevtools = {
-    routeInfo: nextRouteInfo,
-    rootState: state,
-    routeNode,
-    getRoutes: () => routeNode?.children || [],
-    getLoaderTimingHistory: () => devtoolsRegistry.getLoaderTimingHistory?.() ?? [],
-    getPreloadHistory
-  }, window.dispatchEvent(new CustomEvent("one-route-change", {
-    detail: nextRouteInfo
-  })));
 }
 function subscribeToRootState(subscriber) {
-  return rootStateSubscribers.add(subscriber), () => {
+  rootStateSubscribers.add(subscriber);
+  return () => {
     rootStateSubscribers.delete(subscriber);
   };
 }
 function subscribeToStore(subscriber) {
-  return storeSubscribers.add(subscriber), () => {
+  storeSubscribers.add(subscriber);
+  return () => {
     storeSubscribers.delete(subscriber);
   };
 }
 function subscribeToLoadingState(subscriber) {
-  return loadingStateSubscribers.add(subscriber), () => {
+  loadingStateSubscribers.add(subscriber);
+  return () => {
     loadingStateSubscribers.delete(subscriber);
   };
 }
 function setLoadingState(state) {
   startTransition(() => {
-    for (const listener of loadingStateSubscribers) listener(state);
+    for (const listener of loadingStateSubscribers) {
+      listener(state);
+    }
   });
 }
 let currentSnapshot = null;
@@ -277,13 +379,18 @@ function useOneRouter() {
   return useDeferredValue(state);
 }
 function syncStoreRootState() {
-  if (!navigationRef) throw new Error("No navigationRef, possible duplicate One dep");
+  if (!navigationRef) {
+    throw new Error(`No navigationRef, possible duplicate One dep`);
+  }
   if (navigationRef.isReady()) {
     const currentState = navigationRef.getRootState();
     if (rootState !== currentState) {
-      if (initialState && routeInfo?.pathname && getRouteInfo(currentState).pathname !== routeInfo.pathname) {
-        rootState = currentState;
-        return;
+      if (initialState && routeInfo?.pathname) {
+        const nextRouteInfo = getRouteInfo(currentState);
+        if (nextRouteInfo.pathname !== routeInfo.pathname) {
+          rootState = currentState;
+          return;
+        }
       }
       updateState(currentState);
     }
@@ -295,129 +402,208 @@ function useStoreRootState() {
   return useDeferredValue(state);
 }
 function useStoreRouteInfo() {
-  return syncStoreRootState(), useSyncExternalStore(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot);
+  syncStoreRootState();
+  const state = useSyncExternalStore(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot);
+  return state;
 }
 function cleanup() {
-  splashScreenAnimationFrame && cancelAnimationFrame(splashScreenAnimationFrame);
+  if (splashScreenAnimationFrame) {
+    cancelAnimationFrame(splashScreenAnimationFrame);
+  }
 }
 const preloadingLoader = {};
 async function doPreloadDev(href) {
   if (process.env.NODE_ENV === "development") {
-    const startTime = performance.now(),
-      normalizedPath = normalizeLoaderPath(href);
+    const startTime = performance.now();
+    const normalizedPath = normalizeLoaderPath(href);
     try {
-      const loaderJSUrl = getLoaderPath(href, !0),
-        moduleLoadStart = performance.now(),
-        modulePromise = dynamicImport(loaderJSUrl);
-      if (!modulePromise) return null;
-      const module = await modulePromise.catch(() => null),
-        moduleLoadTime = performance.now() - moduleLoadStart;
-      if (!module?.loader) return null;
-      const executionStart = performance.now(),
-        result = await module.loader(),
-        executionTime = performance.now() - executionStart,
-        totalTime = performance.now() - startTime;
-      return result?.__oneRedirect ? result : (devtoolsRegistry.recordLoaderTiming?.({
+      const loaderJSUrl = getLoaderPath(href, true);
+      const moduleLoadStart = performance.now();
+      const modulePromise = dynamicImport(loaderJSUrl);
+      if (!modulePromise) {
+        return null;
+      }
+      const module = await modulePromise.catch(() => null);
+      const moduleLoadTime = performance.now() - moduleLoadStart;
+      if (!module?.loader) {
+        return null;
+      }
+      const executionStart = performance.now();
+      const result = await module.loader();
+      const executionTime = performance.now() - executionStart;
+      const totalTime = performance.now() - startTime;
+      if (result?.__oneRedirect) {
+        return result;
+      }
+      devtoolsRegistry.recordLoaderTiming?.({
         path: normalizedPath,
         startTime,
         moduleLoadTime,
         executionTime,
         totalTime,
         source: "preload"
-      }), result ?? null);
+      });
+      return result ?? null;
     } catch (err) {
       const totalTime = performance.now() - startTime;
-      return devtoolsRegistry.recordLoaderTiming?.({
+      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;
+      });
+      if (process.env.ONE_DEBUG_ROUTER) {
+        console.warn(`[one] dev preload failed for ${href}:`, err);
+      }
+      return null;
     }
   }
 }
 async function doPreload(href) {
-  const preloadPath = getPreloadPath(href),
-    loaderPath = getLoaderPath(href),
-    cssPreloadPath = getPreloadCSSPath(href);
+  const preloadPath = getPreloadPath(href);
+  const loaderPath = getLoaderPath(href);
+  const cssPreloadPath = getPreloadCSSPath(href);
   recordPreloadStart(href);
   try {
-    const [_preload, cssPreloadModule, loader] = await Promise.all([dynamicImport(preloadPath)?.catch(err => (recordPreloadError(href, err instanceof Error ? err.message : String(err)), null)), dynamicImport(cssPreloadPath)?.catch(() => null) ?? Promise.resolve(null), dynamicImport(loaderPath)?.catch(() => null) ?? Promise.resolve(null), preloadRouteModules(href)]),
-      hasCss = !!cssPreloadModule?.injectCSS;
-    if (hasCss && (cssInjectFunctions[href] = cssPreloadModule.injectCSS), !!!loader?.loader) return recordPreloadComplete(href, !1, hasCss), null;
+    const [_preload, cssPreloadModule, loader] = await Promise.all([dynamicImport(preloadPath)?.catch(err => {
+      recordPreloadError(href, err instanceof Error ? err.message : String(err));
+      return null;
+    }), dynamicImport(cssPreloadPath)?.catch(() => null) ?? Promise.resolve(null), dynamicImport(loaderPath)?.catch(() => null) ?? Promise.resolve(null), preloadRouteModules(href)]);
+    const hasCss = !!cssPreloadModule?.injectCSS;
+    if (hasCss) {
+      cssInjectFunctions[href] = cssPreloadModule.injectCSS;
+    }
+    const hasLoader = !!loader?.loader;
+    if (!hasLoader) {
+      recordPreloadComplete(href, false, hasCss);
+      return null;
+    }
     const result = await loader.loader();
-    return result?.__oneRedirect ? result : (recordPreloadComplete(href, !0, hasCss), result ?? null);
+    if (result?.__oneRedirect) {
+      return result;
+    }
+    recordPreloadComplete(href, true, hasCss);
+    return 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;
+    console.error(`[one] preload error for ${href}:`, err);
+    recordPreloadError(href, errorMessage);
+    return null;
   }
 }
-const preloadedLoaderData = {},
-  cssInjectFunctions = {},
-  preloadHistory = [],
-  MAX_PRELOAD_HISTORY = 30;
+const preloadedLoaderData = {};
+const cssInjectFunctions = {};
+const preloadHistory = [];
+const 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();
+    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();
+    hasLoader: false,
+    hasCss: false
+  });
+  if (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();
+  if (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();
+  if (entry) {
+    entry.status = "error";
+    entry.endTime = performance.now();
+    entry.error = error;
+  }
+  dispatchPreloadEvent();
 }
 function dispatchPreloadEvent() {
-  window.dispatchEvent(new CustomEvent("one-preload-update"));
+  if (true) {
+    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];
+function preloadRoute(href, injectCSS = false) {
+  if (true) {
+    if (process.env.NODE_ENV === "development") {
+      const normalizedHref = normalizeLoaderPath(href);
+      if (!preloadingLoader[normalizedHref]) {
+        preloadingLoader[normalizedHref] = doPreloadDev(href).then(data => {
+          preloadedLoaderData[normalizedHref] = data;
+          return data;
+        });
+      }
+      return preloadingLoader[normalizedHref];
+    }
+    if (!preloadingLoader[href]) {
+      preloadingLoader[href] = doPreload(href).then(data => {
+        preloadedLoaderData[href] = data;
+        return data;
+      });
+    }
+    if (injectCSS) {
+      return preloadingLoader[href]?.then(async data => {
+        const inject = cssInjectFunctions[href];
+        if (inject) {
+          await Promise.race([inject(), new Promise(r => setTimeout(r, 800))]);
+        }
+        return data;
+      });
+    }
+    return preloadingLoader[href];
   }
-  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(/\/$/, "") || "/";
+  const url = new URL(href, "http://example.com");
+  return url.pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
 }
 function buildClientMatches(href, matchingNode, params, loaderData) {
-  const pathname = extractPathnameFromHref(href),
-    routeId = matchingNode?.contextKey || pathname,
-    layoutMatches = currentMatches.filter(m => m.routeId.includes("_layout")),
-    pageMatch = {
-      routeId,
-      pathname,
-      params,
-      loaderData
-    };
+  const pathname = extractPathnameFromHref(href);
+  const routeId = matchingNode?.contextKey || pathname;
+  const layoutMatches = currentMatches.filter(m => m.routeId.includes("_layout"));
+  const pageMatch = {
+    routeId,
+    pathname,
+    params,
+    loaderData
+  };
   return [...layoutMatches, pageMatch];
 }
 function initClientMatches(matches) {
-  currentMatches = matches, setClientMatches(matches);
+  currentMatches = matches;
+  setClientMatches(matches);
 }
 async function linkTo(href, event, options) {
-  if (process.env.ONE_DEBUG_ROUTER && console.info(`[one] \u{1F517} ${event || "NAVIGATE"} ${href}`), setNavigationType("soft"), clearNotFoundState(), href[0] === "#") return;
+  if (process.env.ONE_DEBUG_ROUTER) {
+    console.info(`[one] \u{1F517} ${event || "NAVIGATE"} ${href}`);
+  }
+  setNavigationType("soft");
+  clearNotFoundState();
+  if (href[0] === "#") {
+    return;
+  }
   if (shouldLinkExternally(href)) {
     openExternalURL(href);
     return;
@@ -426,32 +612,44 @@ async function linkTo(href, event, options) {
     window.location.href = href;
     return;
   }
-  if (checkBlocker(href, event === "REPLACE" ? "replace" : "push") || isRouteProtected(href)) return;
-  const currentLayoutNode = routeNode,
-    currentPath = routeInfo?.pathname || "/",
-    interceptResult = findInterceptRoute(href, currentLayoutNode, currentPath);
+  if (checkBlocker(href, event === "REPLACE" ? "replace" : "push")) {
+    return;
+  }
+  if (isRouteProtected(href)) {
+    return;
+  }
+  const currentLayoutNode = routeNode;
+  const currentPath = routeInfo?.pathname || "/";
+  const interceptResult = findInterceptRoute(href, currentLayoutNode, currentPath);
   if (interceptResult) {
     const {
-        interceptRoute,
-        slotName,
-        layoutContextKey,
-        params: params2
-      } = interceptResult,
-      scopedSlotKey = `${layoutContextKey}:${slotName}`;
-    storeInterceptState(scopedSlotKey, interceptRoute, params2), updateURLWithoutNavigation(href), setSlotState(scopedSlotKey, {
+      interceptRoute,
+      slotName,
+      layoutContextKey,
+      params: params2
+    } = interceptResult;
+    const scopedSlotKey = `${layoutContextKey}:${slotName}`;
+    storeInterceptState(scopedSlotKey, interceptRoute, params2);
+    updateURLWithoutNavigation(href);
+    setSlotState(scopedSlotKey, {
       activeRouteKey: interceptRoute.contextKey,
       activeRouteNode: interceptRoute,
       params: params2,
-      isIntercepted: !0
+      isIntercepted: true
     });
     return;
   }
   assertIsReady(navigationRef);
   const current = navigationRef.current;
-  if (current == null) throw new Error("Couldn't find a navigation object. Is your component inside NavigationContainer?");
+  if (current == null) {
+    throw new Error("Couldn't find a navigation object. Is your component inside NavigationContainer?");
+  }
   const linking = getLinking();
-  if (!linking) throw new Error("Attempted to link to route when no routes are present");
-  if (setLastAction(), href === ".." || href === "../") {
+  if (!linking) {
+    throw new Error("Attempted to link to route when no routes are present");
+  }
+  setLastAction();
+  if (href === ".." || href === "../") {
     current.goBack();
     return;
   }
@@ -461,31 +659,53 @@ async function linkTo(href, event, options) {
       if (segment.startsWith("[...")) {
         segment = segment.slice(4, -1);
         const params2 = routeInfo?.params?.[segment];
-        return Array.isArray(params2) ? params2.join("/") : params2?.split(",")?.join("/") ?? "";
+        if (Array.isArray(params2)) {
+          return params2.join("/");
+        }
+        return params2?.split(",")?.join("/") ?? "";
       }
-      return segment = segment.slice(1, -1), routeInfo?.params?.[segment];
+      segment = segment.slice(1, -1);
+      return routeInfo?.params?.[segment];
     }).filter(Boolean).join("/") ?? "/";
-    routeInfo?.isIndex || (base += "/.."), href = resolve(base, href);
+    if (!routeInfo?.isIndex) {
+      base += "/..";
+    }
+    href = 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());
+    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") {
+  if (!(normalizedPreloadPath in preloadedLoaderData) && !(href in preloadedLoaderData)) {
+    await preloadRoute(href, true);
+  } else if (process.env.NODE_ENV !== "development") {
     const inject = cssInjectFunctions[href];
-    inject && inject().catch(() => {});
+    if (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");
+    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");
+    delete preloadedLoaderData[normalizedPreloadPath];
+    delete preloadingLoader[normalizedPreloadPath];
+    delete preloadedLoaderData[href];
+    delete preloadingLoader[href];
+    setLoadingState("loaded");
     const notFoundRoute = findNearestNotFoundRoute(href, routeNode);
     setNotFoundState({
       notFoundPath: preloadResult.__oneNotFoundPath || "/+not-found",
@@ -501,11 +721,14 @@ async function linkTo(href, event, options) {
       lastValidatedHref: href
     });
     try {
-      const loadedRoute = matchingRouteNode.loadRoute(),
-        params2 = extractParamsFromState(state),
-        search = extractSearchFromHref(href),
-        pathname = extractPathnameFromHref(href);
-      if (loadedRoute.validateParams && runValidateParams(loadedRoute.validateParams, params2), loadedRoute.validateRoute) {
+      const loadedRoute = matchingRouteNode.loadRoute();
+      const params2 = extractParamsFromState(state);
+      const search = extractSearchFromHref(href);
+      const pathname = extractPathnameFromHref(href);
+      if (loadedRoute.validateParams) {
+        runValidateParams(loadedRoute.validateParams, params2);
+      }
+      if (loadedRoute.validateRoute) {
         const validationResult = await loadedRoute.validateRoute({
           params: params2,
           search,
@@ -514,11 +737,12 @@ async function linkTo(href, event, options) {
         });
         if (validationResult && !validationResult.valid) {
           const error = new RouteValidationError(validationResult.error || "Route validation failed", validationResult.details);
-          throw setValidationState({
+          setValidationState({
             status: "error",
             error,
             lastValidatedHref: href
-          }), error;
+          });
+          throw error;
         }
       }
       setValidationState({
@@ -526,72 +750,107 @@ async function linkTo(href, event, options) {
         lastValidatedHref: href
       });
     } catch (error) {
-      if (error && typeof error.then == "function") await error.catch(() => {}), setValidationState({
-        status: "valid",
-        lastValidatedHref: href
-      });else throw (error instanceof ParamValidationError || error instanceof RouteValidationError) && setValidationState({
-        status: "error",
-        error,
-        lastValidatedHref: href
-      }), error;
+      if (error && typeof error.then === "function") {
+        await error.catch(() => {});
+        setValidationState({
+          status: "valid",
+          lastValidatedHref: href
+        });
+      } else if (error instanceof ParamValidationError || error instanceof RouteValidationError) {
+        setValidationState({
+          status: "error",
+          error,
+          lastValidatedHref: href
+        });
+        throw error;
+      } else {
+        throw error;
+      }
     }
   }
-  const normalizedPath = normalizeLoaderPath(href),
-    loaderData = preloadedLoaderData[normalizedPath],
-    params = extractParamsFromState(state),
-    newMatches = buildClientMatches(href, matchingRouteNode, params, loaderData);
-  currentMatches = newMatches, setClientMatches(newMatches);
-  const currentRootState = navigationRef.getRootState(),
-    hash = href.indexOf("#");
-  currentRootState.key && hash > 0 && (hashes[currentRootState.key] = href.slice(hash)), nextOptions = options ?? null, startTransition(() => {
-    const freshRootState = navigationRef.getRootState(),
-      action = getNavigateAction(state, freshRootState, event),
-      current2 = navigationRef.getCurrentRoute(),
-      targetName = action.payload?.name,
-      isGroupTarget = typeof targetName == "string" && targetName.startsWith("(") && targetName.endsWith(")"),
-      hasFreshRootState = freshRootState.type === "stack",
-      currentFocusedName = freshRootState.routes[freshRootState.index]?.name;
+  const normalizedPath = normalizeLoaderPath(href);
+  const loaderData = preloadedLoaderData[normalizedPath];
+  const params = extractParamsFromState(state);
+  const newMatches = buildClientMatches(href, matchingRouteNode, params, loaderData);
+  currentMatches = newMatches;
+  setClientMatches(newMatches);
+  const currentRootState = navigationRef.getRootState();
+  const hash = href.indexOf("#");
+  if (currentRootState.key && hash > 0) {
+    hashes[currentRootState.key] = href.slice(hash);
+  }
+  nextOptions = options ?? null;
+  startTransition(() => {
+    const freshRootState = navigationRef.getRootState();
+    const action = getNavigateAction(state, freshRootState, event);
+    const current2 = navigationRef.getCurrentRoute();
+    const targetName = action.payload?.name;
+    const isGroupTarget = typeof targetName === "string" && targetName.startsWith("(") && targetName.endsWith(")");
+    const hasFreshRootState = freshRootState.type === "stack";
+    const currentFocusedName = freshRootState.routes[freshRootState.index]?.name;
     if (isGroupTarget && hasFreshRootState && currentFocusedName !== targetName) {
-      const existingRoutes = freshRootState.routes.filter(r => r.name !== targetName),
-        targetRoute = {
-          ...state.routes[state.routes.length - 1],
-          key: `${targetName}-${freshRootState.key}`
-        };
+      const existingRoutes = freshRootState.routes.filter(r => r.name !== targetName);
+      const targetRoute = {
+        ...state.routes[state.routes.length - 1],
+        key: `${targetName}-${freshRootState.key}`
+      };
       navigationRef.resetRoot({
         ...freshRootState,
         routes: [...existingRoutes, targetRoute],
         index: existingRoutes.length
       });
-    } else navigationRef.dispatch(action);
+    } else {
+      navigationRef.dispatch(action);
+    }
     let warningTm;
     const interval = setInterval(() => {
       const next = navigationRef.getCurrentRoute();
-      current2 !== next && setTimeout(() => {
-        setLoadingState("loaded");
-      }), clearTimeout(warningTm), clearTimeout(interval);
+      if (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));
+    if (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 (a === b) {
+    return true;
+  }
   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;
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (const key of keysA) {
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }
 export { canDismiss, canGoBack, cleanup, dismiss, dismissAll, getPreloadHistory, getSortedRoutes, getValidationState, goBack, handleNavigationContainerStateChange, hasAttemptedToHideSplash, initClientMatches, initialPathname, initialState, initialize, isRouteProtected, linkTo, navigate, navigationRef, preloadRoute, preloadedLoaderData, preloadingLoader, push, registerProtectedRoutes, replace, rootComponent, rootState, rootStateSnapshot, routeInfo, routeInfoSnapshot, routeNode, setLoadingState, setParams, setValidationState, snapshot, subscribeToLoadingState, subscribeToRootState, subscribeToStore, subscribeToValidationState, unregisterProtectedRoutes, updateState, useOneRouter, useStoreRootState, useStoreRouteInfo, useValidationState };
 //# sourceMappingURL=router.mjs.map