@solidjs/router 0.4.3 → 0.5.1

package/dist/index.js

@@ -1,15 +1,13 @@
-import { isServer, delegateEvents, createComponent as createComponent$1, mergeProps as mergeProps$1, spread, insert, effect, setAttribute, template } from 'solid-js/web';
-import { createSignal, onCleanup, runWithOwner, createMemo, getOwner, createContext, useContext, untrack, useTransition, on, resetErrorBoundaries, createRenderEffect, createComponent, children, createRoot, Show, mergeProps, splitProps } from 'solid-js';
+import { isServer, delegateEvents, createComponent as createComponent$1, spread, mergeProps as mergeProps$1, template } from 'solid-js/web';
+import { createSignal, onCleanup, getOwner, runWithOwner, createMemo, createContext, useContext, untrack, createRenderEffect, createComponent, on, startTransition, resetErrorBoundaries, children, createRoot, Show, mergeProps, splitProps } from 'solid-js';
 
 function bindEvent(target, type, handler) {
   target.addEventListener(type, handler);
   return () => target.removeEventListener(type, handler);
 }
-
 function intercept([value, setValue], get, set) {
   return [get ? () => get(value()) : value, set ? v => setValue(set(v)) : setValue];
 }
-
 function querySelector(selector) {
   // Guard against selector being an invalid CSS selector
   try {
@@ -18,24 +16,19 @@ function querySelector(selector) {
     return null;
   }
 }
-
 function scrollToHash(hash, fallbackTop) {
   const el = querySelector(`#${hash}`);
-
   if (el) {
     el.scrollIntoView();
   } else if (fallbackTop) {
     window.scrollTo(0, 0);
   }
 }
-
 function createIntegration(get, set, init, utils) {
   let ignore = false;
-
   const wrap = value => typeof value === "string" ? {
     value
   } : value;
-
   const signal = intercept(createSignal(wrap(get()), {
     equals: (a, b) => a.value === b.value
   }), undefined, next => {
@@ -64,7 +57,6 @@ function normalizeIntegration(integration) {
       signal: integration
     };
   }
-
   return integration;
 }
 function staticIntegration(obj) {
@@ -87,7 +79,6 @@ function pathIntegration() {
     } else {
       window.history.pushState(state, "", value);
     }
-
     scrollToHash(window.location.hash.slice(1), scroll);
   }, notify => bindEvent(window, "popstate", () => notify()), {
     go: delta => window.history.go(delta)
@@ -105,7 +96,6 @@ function hashIntegration() {
     } else {
       window.location.hash = value;
     }
-
     const hashIndex = value.indexOf("#");
     const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
     scrollToHash(hash, scroll);
@@ -113,37 +103,63 @@ function hashIntegration() {
     go: delta => window.history.go(delta),
     renderPath: path => `#${path}`,
     parsePath: str => {
-      const to = str.replace(/^.*?#/, ""); // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
+      const to = str.replace(/^.*?#/, "");
+      // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
       // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
       // to the current path so we can handle these in-page anchors correctly.
-
       if (!to.startsWith("/")) {
         const [, path = "/"] = window.location.hash.split("#", 2);
         return `${path}#${to}`;
       }
-
       return to;
     }
   });
 }
 
+function createBeforeLeave() {
+  let listeners = new Set();
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  let ignore = false;
+  function confirm(to, options) {
+    if (ignore) return !(ignore = false);
+    const e = {
+      to,
+      options,
+      defaultPrevented: false,
+      preventDefault: () => e.defaultPrevented = true
+    };
+    for (const l of listeners) l.listener({
+      ...e,
+      from: l.location,
+      retry: force => {
+        force && (ignore = true);
+        l.navigate(to, options);
+      }
+    });
+    return !e.defaultPrevented;
+  }
+  return {
+    subscribe,
+    confirm
+  };
+}
+
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
 const trimPathRegex = /^\/+|\/+$/g;
-
-function normalize(path, omitSlash = false) {
+function normalizePath(path, omitSlash = false) {
   const s = path.replace(trimPathRegex, "");
   return s ? omitSlash || /^[?#]/.test(s) ? s : "/" + s : "";
 }
-
 function resolvePath(base, path, from) {
   if (hasSchemeRegex.test(path)) {
     return undefined;
   }
-
-  const basePath = normalize(base);
-  const fromPath = from && normalize(from);
+  const basePath = normalizePath(base);
+  const fromPath = from && normalizePath(from);
   let result = "";
-
   if (!fromPath || path.startsWith("/")) {
     result = basePath;
   } else if (fromPath.toLowerCase().indexOf(basePath.toLowerCase()) !== 0) {
@@ -151,18 +167,16 @@ function resolvePath(base, path, from) {
   } else {
     result = fromPath;
   }
-
-  return (result || "/") + normalize(path, !result);
+  return (result || "/") + normalizePath(path, !result);
 }
 function invariant(value, message) {
   if (value == null) {
     throw new Error(message);
   }
-
   return value;
 }
 function joinPaths(from, to) {
-  return normalize(from).replace(/\/*(\*.*)?$/g, "") + normalize(to);
+  return normalizePath(from).replace(/\/*(\*.*)?$/g, "") + normalizePath(to);
 }
 function extractSearchParams(url) {
   const params = {};
@@ -181,20 +195,16 @@ function createMatcher(path, partial) {
   return location => {
     const locSegments = location.split("/").filter(Boolean);
     const lenDiff = locSegments.length - len;
-
     if (lenDiff < 0 || lenDiff > 0 && splat === undefined && !partial) {
       return null;
     }
-
     const match = {
       path: len ? "" : "/",
       params: {}
     };
-
     for (let i = 0; i < len; i++) {
       const segment = segments[i];
       const locSegment = locSegments[i];
-
       if (segment[0] === ":") {
         match.params[segment.slice(1)] = locSegment;
       } else if (segment.localeCompare(locSegment, undefined, {
@@ -202,14 +212,11 @@ function createMatcher(path, partial) {
       }) !== 0) {
         return null;
       }
-
       match.path += `/${locSegment}`;
     }
-
     if (splat) {
       match.params[splat] = lenDiff ? locSegments.slice(-lenDiff).join("/") : "";
     }
-
     return match;
   };
 }
@@ -226,21 +233,17 @@ function createMemoObject(fn) {
       if (!map.has(property)) {
         runWithOwner(owner, () => map.set(property, createMemo(() => fn()[property])));
       }
-
       return map.get(property)();
     },
-
     getOwnPropertyDescriptor() {
       return {
         enumerable: true,
         configurable: true
       };
     },
-
     ownKeys() {
       return Reflect.ownKeys(fn());
     }
-
   });
 }
 function mergeSearchString(search, params) {
@@ -260,17 +263,17 @@ function expandOptionals(pattern) {
   if (!match) return [pattern];
   let prefix = pattern.slice(0, match.index);
   let suffix = pattern.slice(match.index + match[0].length);
-  const prefixes = [prefix, prefix += match[1]]; // This section handles adjacent optional params. We don't actually want all permuations since
+  const prefixes = [prefix, prefix += match[1]];
+
+  // This section handles adjacent optional params. We don't actually want all permuations since
   // that will lead to equivalent routes which have the same number of params. For example
   // `/:a?/:b?/:c`? only has the unique expansion: `/`, `/:a`, `/:a/:b`, `/:a/:b/:c` and we can
   // discard `/:b`, `/:c`, `/:b/:c` by building them up in order and not recursing. This also helps
   // ensure predictability where earlier params have precidence.
-
   while (match = /^(\/\:[^\/]+)\?/.exec(suffix)) {
     prefixes.push(prefix += match[1]);
     suffix = suffix.slice(match[0].length);
   }
-
   return expandOptionals(suffix).reduce((results, expansion) => [...results, ...prefixes.map(p => p + expansion)], []);
 }
 
@@ -304,18 +307,24 @@ const useRouteData = () => useRoute().data;
 const useSearchParams = () => {
   const location = useLocation();
   const navigate = useNavigate();
-
   const setSearchParams = (params, options) => {
     const searchString = untrack(() => mergeSearchString(location.search, params));
-    navigate(searchString, {
+    navigate(location.pathname + searchString + location.hash, {
       scroll: false,
-      ...options,
-      resolve: true
+      resolve: false,
+      ...options
     });
   };
-
   return [location.query, setSearchParams];
 };
+const useBeforeLeave = listener => {
+  const s = useRouter().beforeLeave.subscribe({
+    listener,
+    location: useLocation(),
+    navigate: useNavigate()
+  });
+  onCleanup(s);
+};
 function createRoutes(routeDef, base = "", fallback) {
   const {
     component,
@@ -338,13 +347,13 @@ function createRoutes(routeDef, base = "", fallback) {
     for (const originalPath of expandOptionals(path)) {
       const path = joinPaths(base, originalPath);
       const pattern = isLeaf ? path : path.split("/*", 1)[0];
-      acc.push({ ...shared,
+      acc.push({
+        ...shared,
         originalPath,
         pattern,
         matcher: createMatcher(pattern, !isLeaf)
       });
     }
-
     return acc;
   }, []);
 }
@@ -352,76 +361,62 @@ function createBranch(routes, index = 0) {
   return {
     routes,
     score: scoreRoute(routes[routes.length - 1]) * 10000 - index,
-
     matcher(location) {
       const matches = [];
-
       for (let i = routes.length - 1; i >= 0; i--) {
         const route = routes[i];
         const match = route.matcher(location);
-
         if (!match) {
           return null;
         }
-
-        matches.unshift({ ...match,
+        matches.unshift({
+          ...match,
           route
         });
       }
-
       return matches;
     }
-
   };
 }
-
 function asArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-
 function createBranches(routeDef, base = "", fallback, stack = [], branches = []) {
   const routeDefs = asArray(routeDef);
-
   for (let i = 0, len = routeDefs.length; i < len; i++) {
     const def = routeDefs[i];
-
     if (def && typeof def === "object" && def.hasOwnProperty("path")) {
       const routes = createRoutes(def, base, fallback);
-
       for (const route of routes) {
         stack.push(route);
-
-        if (def.children) {
+        const isEmptyArray = Array.isArray(def.children) && def.children.length === 0;
+        if (def.children && !isEmptyArray) {
           createBranches(def.children, route.pattern, fallback, stack, branches);
         } else {
           const branch = createBranch([...stack], branches.length);
           branches.push(branch);
         }
-
         stack.pop();
       }
     }
-  } // Stack will be empty on final return
-
+  }
 
+  // Stack will be empty on final return
   return stack.length ? branches : branches.sort((a, b) => b.score - a.score);
 }
 function getRouteMatches(branches, location) {
   for (let i = 0, len = branches.length; i < len; i++) {
     const match = branches[i].matcher(location);
-
     if (match) {
       return match;
     }
   }
-
   return [];
 }
 function createLocation(path, state) {
   const origin = new URL("http://sar");
   const url = createMemo(prev => {
     const path_ = path();
-
     try {
       return new URL(path_, origin);
     } catch (err) {
@@ -439,23 +434,18 @@ function createLocation(path, state) {
     get pathname() {
       return pathname();
     },
-
     get search() {
       return search();
     },
-
     get hash() {
       return hash();
     },
-
     get state() {
       return state();
     },
-
     get key() {
       return key();
     },
-
     query: createMemoObject(on(search, () => extractSearchParams(url())))
   };
 }
@@ -464,17 +454,14 @@ function createRouterContext(integration, base = "", data, out) {
     signal: [source, setSource],
     utils = {}
   } = normalizeIntegration(integration);
-
   const parsePath = utils.parsePath || (p => p);
-
   const renderPath = utils.renderPath || (p => p);
-
+  const beforeLeave = utils.beforeLeave || createBeforeLeave();
   const basePath = resolvePath("", base);
   const output = isServer && out ? Object.assign(out, {
     matches: [],
     url: undefined
   }) : undefined;
-
   if (basePath === undefined) {
     throw new Error(`${basePath} is not a valid base path`);
   } else if (basePath && !source().value) {
@@ -484,8 +471,15 @@ function createRouterContext(integration, base = "", data, out) {
       scroll: false
     });
   }
-
-  const [isRouting, start] = useTransition();
+  const [isRouting, setIsRouting] = createSignal(false);
+  const start = async callback => {
+    setIsRouting(true);
+    try {
+      await startTransition(callback);
+    } finally {
+      setIsRouting(false);
+    }
+  };
   const [reference, setReference] = createSignal(source().value);
   const [state, setState] = createSignal(source().state);
   const location = createLocation(reference, state);
@@ -495,13 +489,10 @@ function createRouterContext(integration, base = "", data, out) {
     params: {},
     path: () => basePath,
     outlet: () => null,
-
     resolvePath(to) {
       return resolvePath(basePath, to);
     }
-
   };
-
   if (data) {
     try {
       TempRoute = baseRoute;
@@ -515,20 +506,17 @@ function createRouterContext(integration, base = "", data, out) {
       TempRoute = undefined;
     }
   }
-
   function navigateFromRoute(route, to, options) {
     // Untrack in case someone navigates in an effect - don't want to track `reference` or route paths
     untrack(() => {
       if (typeof to === "number") {
         if (!to) ; else if (utils.go) {
-          utils.go(to);
+          beforeLeave.confirm(to, options) && utils.go(to);
         } else {
           console.warn("Router integration does not support relative routing");
         }
-
         return;
       }
-
       const {
         replace,
         resolve,
@@ -541,28 +529,24 @@ function createRouterContext(integration, base = "", data, out) {
         ...options
       };
       const resolvedTo = resolve ? route.resolvePath(to) : resolvePath("", to);
-
       if (resolvedTo === undefined) {
         throw new Error(`Path '${to}' is not a routable path`);
       } else if (referrers.length >= MAX_REDIRECTS) {
         throw new Error("Too many redirects");
       }
-
       const current = reference();
-
       if (resolvedTo !== current || nextState !== state()) {
         if (isServer) {
           if (output) {
             output.url = resolvedTo;
           }
-
           setSource({
             value: resolvedTo,
             replace,
             scroll,
             state: nextState
           });
-        } else {
+        } else if (beforeLeave.confirm(resolvedTo, options)) {
           const len = referrers.push({
             value: current,
             replace,
@@ -585,34 +569,30 @@ function createRouterContext(integration, base = "", data, out) {
       }
     });
   }
-
   function navigatorFactory(route) {
     // Workaround for vite issue (https://github.com/vitejs/vite/issues/3803)
     route = route || useContext(RouteContextObj) || baseRoute;
     return (to, options) => navigateFromRoute(route, to, options);
   }
-
   function navigateEnd(next) {
     const first = referrers[0];
-
     if (first) {
       if (next.value !== first.value || next.state !== first.state) {
-        setSource({ ...next,
+        setSource({
+          ...next,
           replace: first.replace,
           scroll: first.scroll
         });
       }
-
       referrers.length = 0;
     }
   }
-
   createRenderEffect(() => {
     const {
       value,
       state
-    } = source(); // Untrack this whole block so `start` doesn't cause Solid's Listener to be preserved
-
+    } = source();
+    // Untrack this whole block so `start` doesn't cause Solid's Listener to be preserved
     untrack(() => {
       if (value !== reference()) {
         start(() => {
@@ -622,26 +602,19 @@ function createRouterContext(integration, base = "", data, out) {
       }
     });
   });
-
   if (!isServer) {
-    function isSvg(el) {
-      return el.namespaceURI === "http://www.w3.org/2000/svg";
-    }
-
     function handleAnchorClick(evt) {
       if (evt.defaultPrevented || evt.button !== 0 || evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey) return;
       const a = evt.composedPath().find(el => el instanceof Node && el.nodeName.toUpperCase() === "A");
-      if (!a) return;
-      const svg = isSvg(a);
-      const href = svg ? a.href.baseVal : a.href;
-      const target = svg ? a.target.baseVal : a.target;
-      if (target || !href && !a.hasAttribute("state")) return;
+      if (!a || !a.hasAttribute("link")) return;
+      const href = a.href;
+      if (a.target || !href && !a.hasAttribute("state")) return;
       const rel = (a.getAttribute("rel") || "").split(/\s+/);
       if (a.hasAttribute("download") || rel && rel.includes("external")) return;
-      const url = svg ? new URL(href, document.baseURI) : new URL(href);
+      const url = new URL(href);
       const pathname = urlDecode(url.pathname);
       if (url.origin !== window.location.origin || basePath && pathname && !pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
-      const to = parsePath(pathname + urlDecode(url.search, true) + urlDecode(url.hash));
+      const to = parsePath(url.pathname + url.search + url.hash);
       const state = a.getAttribute("state");
       evt.preventDefault();
       navigateFromRoute(baseRoute, to, {
@@ -650,14 +623,13 @@ function createRouterContext(integration, base = "", data, out) {
         scroll: !a.hasAttribute("noscroll"),
         state: state && JSON.parse(state)
       });
-    } // ensure delegated events run first
-
+    }
 
+    // ensure delegated events run first
     delegateEvents(["click"]);
     document.addEventListener("click", handleAnchorClick);
     onCleanup(() => document.removeEventListener("click", handleAnchorClick));
   }
-
   return {
     base: baseRoute,
     out: output,
@@ -665,7 +637,8 @@ function createRouterContext(integration, base = "", data, out) {
     isRouting,
     renderPath,
     parsePath,
-    navigatorFactory
+    navigatorFactory,
+    beforeLeave
   };
 }
 function createRouteContext(router, parent, child, match) {
@@ -686,22 +659,17 @@ function createRouteContext(router, parent, child, match) {
   const route = {
     parent,
     pattern,
-
     get child() {
       return child();
     },
-
     path,
     params,
     data: parent.data,
     outlet,
-
     resolvePath(to) {
       return resolvePath(base.path(), to, path());
     }
-
   };
-
   if (data) {
     try {
       TempRoute = route;
@@ -715,11 +683,10 @@ function createRouteContext(router, parent, child, match) {
       TempRoute = undefined;
     }
   }
-
   return route;
 }
 
-const _tmpl$ = /*#__PURE__*/template(`<a></a>`, 2);
+const _tmpl$ = /*#__PURE__*/template(`<a link></a>`, 2);
 const Router = props => {
   const {
     source,
@@ -734,11 +701,9 @@ const Router = props => {
   const routerState = createRouterContext(integration, base, data, out);
   return createComponent$1(RouterContextObj.Provider, {
     value: routerState,
-
     get children() {
       return props.children;
     }
-
   });
 };
 const Routes = props => {
@@ -747,7 +712,6 @@ const Routes = props => {
   const routeDefs = children(() => props.children);
   const branches = createMemo(() => createBranches(routeDefs(), joinPaths(parentRoute.pattern, props.base || ""), Outlet));
   const matches = createMemo(() => getRouteMatches(branches(), router.location.pathname));
-
   if (router.out) {
     router.out.matches.push(matches().map(({
       route,
@@ -760,39 +724,31 @@ const Routes = props => {
       params
     })));
   }
-
   const disposers = [];
   let root;
   const routeStates = createMemo(on(matches, (nextMatches, prevMatches, prev) => {
     let equal = prevMatches && nextMatches.length === prevMatches.length;
     const next = [];
-
     for (let i = 0, len = nextMatches.length; i < len; i++) {
       const prevMatch = prevMatches && prevMatches[i];
       const nextMatch = nextMatches[i];
-
       if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
         next[i] = prev[i];
       } else {
         equal = false;
-
         if (disposers[i]) {
           disposers[i]();
         }
-
         createRoot(dispose => {
           disposers[i] = dispose;
           next[i] = createRouteContext(router, next[i - 1] || parentRoute, () => routeStates()[i + 1], () => matches()[i]);
         });
       }
     }
-
     disposers.splice(nextMatches.length).forEach(dispose => dispose());
-
     if (prev && equal) {
       return prev;
     }
-
     root = next[0];
     return next;
   }));
@@ -800,14 +756,11 @@ const Routes = props => {
     get when() {
       return routeStates() && root;
     },
-
     children: route => createComponent$1(RouteContextObj.Provider, {
       value: route,
-
       get children() {
         return route.outlet();
       }
-
     })
   });
 };
@@ -823,7 +776,6 @@ const Route = props => {
     get children() {
       return childRoutes();
     }
-
   });
 };
 const Outlet = () => {
@@ -832,90 +784,55 @@ const Outlet = () => {
     get when() {
       return route.child;
     },
-
     children: child => createComponent$1(RouteContextObj.Provider, {
       value: child,
-
       get children() {
         return child.outlet();
       }
-
     })
   });
 };
-
-function LinkBase(props) {
-  const [, rest] = splitProps(props, ["children", "to", "href", "state"]);
-  const href = useHref(() => props.to);
-  return (() => {
-    const _el$ = _tmpl$.cloneNode(true);
-
-    spread(_el$, rest, false, true);
-
-    insert(_el$, () => props.children);
-
-    effect(_p$ => {
-      const _v$ = href() || props.href,
-            _v$2 = JSON.stringify(props.state);
-
-      _v$ !== _p$._v$ && setAttribute(_el$, "href", _p$._v$ = _v$);
-      _v$2 !== _p$._v$2 && setAttribute(_el$, "state", _p$._v$2 = _v$2);
-      return _p$;
-    }, {
-      _v$: undefined,
-      _v$2: undefined
-    });
-
-    return _el$;
-  })();
-}
-
-function Link(props) {
-  const to = useResolvedPath(() => props.href);
-  return createComponent$1(LinkBase, mergeProps$1(props, {
-    get to() {
-      return to();
-    }
-
-  }));
-}
-function NavLink(props) {
+function A(props) {
   props = mergeProps({
     inactiveClass: "inactive",
     activeClass: "active"
   }, props);
-  const [, rest] = splitProps(props, ["activeClass", "inactiveClass", "end"]);
-  const location = useLocation();
+  const [, rest] = splitProps(props, ["href", "state", "class", "activeClass", "inactiveClass", "end"]);
   const to = useResolvedPath(() => props.href);
+  const href = useHref(to);
+  const location = useLocation();
   const isActive = createMemo(() => {
     const to_ = to();
-
-    if (to_ === undefined) {
-      return false;
-    }
-
-    const path = to_.split(/[?#]/, 1)[0].toLowerCase();
-    const loc = location.pathname.toLowerCase();
+    if (to_ === undefined) return false;
+    const path = normalizePath(to_.split(/[?#]/, 1)[0]).toLowerCase();
+    const loc = normalizePath(location.pathname).toLowerCase();
     return props.end ? path === loc : loc.startsWith(path);
   });
-  return createComponent$1(LinkBase, mergeProps$1(rest, {
-    get to() {
-      return to();
-    },
-
-    get classList() {
-      return {
-        [props.inactiveClass]: !isActive(),
-        [props.activeClass]: isActive(),
-        ...rest.classList
-      };
-    },
-
-    get ["aria-current"]() {
-      return isActive() ? "page" : undefined;
-    }
-
-  }));
+  return (() => {
+    const _el$ = _tmpl$.cloneNode(true);
+    spread(_el$, mergeProps$1(rest, {
+      get href() {
+        return href() || props.href;
+      },
+      get state() {
+        return JSON.stringify(props.state);
+      },
+      get classList() {
+        return {
+          ...(props.class && {
+            [props.class]: true
+          }),
+          [props.inactiveClass]: !isActive(),
+          [props.activeClass]: isActive(),
+          ...rest.classList
+        };
+      },
+      get ["aria-current"]() {
+        return isActive() ? "page" : undefined;
+      }
+    }), false, false);
+    return _el$;
+  })();
 }
 function Navigate(props) {
   const navigate = useNavigate();
@@ -935,4 +852,4 @@ function Navigate(props) {
   return null;
 }
 
-export { Link, NavLink, Navigate, Outlet, Route, Router, Routes, mergeSearchString as _mergeSearchString, createIntegration, hashIntegration, normalizeIntegration, pathIntegration, staticIntegration, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useRouteData, useRoutes, useSearchParams };
+export { A, A as Link, A as NavLink, Navigate, Outlet, Route, Router, Routes, mergeSearchString as _mergeSearchString, createBeforeLeave, createIntegration, hashIntegration, normalizeIntegration, pathIntegration, staticIntegration, useBeforeLeave, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useRouteData, useRoutes, useSearchParams };