@pyreon/router 0.1.0

package/lib/types/index.d.ts

@@ -0,0 +1,690 @@
+import { createContext, createRef, h, onUnmount, popContext, pushContext, useContext } from "@pyreon/core";
+import { computed, signal } from "@pyreon/reactivity";
+
+//#region src/loader.ts
+/**
+* Context frame that holds the loader data for the currently rendered route record.
+* Pushed by RouterView's withLoaderData wrapper before invoking the route component.
+*/
+
+/**
+* Returns the data resolved by the current route's `loader` function.
+* Must be called inside a route component rendered by <RouterView />.
+*
+* @example
+* const routes = [{ path: "/users", component: Users, loader: fetchUsers }]
+*
+* function Users() {
+*   const users = useLoaderData<User[]>()
+*   return h("ul", null, users.map(u => h("li", null, u.name)))
+* }
+*/
+function useLoaderData() {
+  return useContext(LoaderDataContext);
+}
+/**
+* SSR helper: pre-run all loaders for the given path before rendering.
+* Call this before `renderToString` so route components can read data via `useLoaderData()`.
+*
+* @example
+* const router = createRouter({ routes, url: req.url })
+* await prefetchLoaderData(router, req.url)
+* const html = await renderToString(h(App, { router }))
+*/
+async function prefetchLoaderData(router, path) {
+  const route = router._resolve(path);
+  const ac = new AbortController();
+  router._abortController = ac;
+  await Promise.all(route.matched.filter(r => r.loader).map(async r => {
+    const data = await r.loader?.({
+      params: route.params,
+      query: route.query,
+      signal: ac.signal
+    });
+    router._loaderData.set(r, data);
+  }));
+}
+/**
+* Serialize loader data to a JSON-safe plain object for embedding in SSR HTML.
+* Keys are route path patterns (stable across server and client).
+*
+* @example — SSR handler:
+* await prefetchLoaderData(router, req.url)
+* const { html, head } = await renderWithHead(h(App, null))
+* const page = `...${head}
+*   <script>window.__PYREON_LOADER_DATA__=${JSON.stringify(serializeLoaderData(router))}<\/script>
+*   ...${html}...`
+*/
+function serializeLoaderData(router) {
+  const result = {};
+  for (const [record, data] of router._loaderData) result[record.path] = data;
+  return result;
+}
+/**
+* Hydrate loader data from a serialized object (e.g. `window.__PYREON_LOADER_DATA__`).
+* Populates the router's internal `_loaderData` map so the initial render uses
+* server-fetched data without re-running loaders on the client.
+*
+* Call this before `mount()`, after `createRouter()`.
+*
+* @example — client entry:
+* import { hydrateLoaderData } from "@pyreon/router"
+* const router = createRouter({ routes })
+* hydrateLoaderData(router, window.__PYREON_LOADER_DATA__ ?? {})
+* mount(h(App, null), document.getElementById("app")!)
+*/
+function hydrateLoaderData(router, serialized) {
+  if (!serialized || typeof serialized !== "object") return;
+  const route = router._resolve(router.currentRoute().path);
+  for (const record of route.matched) if (Object.hasOwn(serialized, record.path)) router._loaderData.set(record, serialized[record.path]);
+}
+
+//#endregion
+//#region src/match.ts
+/**
+* Parse a query string into key-value pairs. Duplicate keys are overwritten
+* (last value wins). Use `parseQueryMulti` to preserve duplicates as arrays.
+*/
+function parseQuery(qs) {
+  if (!qs) return {};
+  const result = {};
+  for (const part of qs.split("&")) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx < 0) {
+      const key = decodeURIComponent(part);
+      if (key) result[key] = "";
+    } else {
+      const key = decodeURIComponent(part.slice(0, eqIdx));
+      const val = decodeURIComponent(part.slice(eqIdx + 1));
+      if (key) result[key] = val;
+    }
+  }
+  return result;
+}
+/**
+* Parse a query string preserving duplicate keys as arrays.
+*
+* @example
+* parseQueryMulti("color=red&color=blue&size=lg")
+* // → { color: ["red", "blue"], size: "lg" }
+*/
+function parseQueryMulti(qs) {
+  if (!qs) return {};
+  const result = {};
+  for (const part of qs.split("&")) {
+    const eqIdx = part.indexOf("=");
+    let key;
+    let val;
+    if (eqIdx < 0) {
+      key = decodeURIComponent(part);
+      val = "";
+    } else {
+      key = decodeURIComponent(part.slice(0, eqIdx));
+      val = decodeURIComponent(part.slice(eqIdx + 1));
+    }
+    if (!key) continue;
+    const existing = result[key];
+    if (existing === void 0) result[key] = val;else if (Array.isArray(existing)) existing.push(val);else result[key] = [existing, val];
+  }
+  return result;
+}
+function stringifyQuery(query) {
+  const parts = [];
+  for (const [k, v] of Object.entries(query)) parts.push(v ? `${encodeURIComponent(k)}=${encodeURIComponent(v)}` : encodeURIComponent(k));
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+/**
+* Match a single route pattern against a path segment.
+* Returns extracted params or null if no match.
+*
+* Supports:
+*   - Exact segments: "/about"
+*   - Param segments: "/user/:id"
+*   - Wildcard: "(.*)" matches everything
+*/
+function matchPath(pattern, path) {
+  if (pattern === "(.*)" || pattern === "*") return {};
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = path.split("/").filter(Boolean);
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    const pt = pathParts[i];
+    if (pp.endsWith("*") && pp.startsWith(":")) {
+      const paramName = pp.slice(1, -1);
+      params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
+      return params;
+    }
+    if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);else if (pp !== pt) return null;
+  }
+  if (patternParts.length !== pathParts.length) return null;
+  return params;
+}
+/**
+* Check if a path starts with a route's prefix (for nested route matching).
+* Returns the remaining path suffix, or null if no match.
+*/
+function matchPrefix(pattern, path) {
+  if (pattern === "(.*)" || pattern === "*") return {
+    params: {},
+    rest: path
+  };
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = path.split("/").filter(Boolean);
+  if (pathParts.length < patternParts.length) return null;
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    const pt = pathParts[i];
+    if (pp.endsWith("*") && pp.startsWith(":")) {
+      const paramName = pp.slice(1, -1);
+      params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
+      return {
+        params,
+        rest: "/"
+      };
+    }
+    if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);else if (pp !== pt) return null;
+  }
+  return {
+    params,
+    rest: `/${pathParts.slice(patternParts.length).join("/")}`
+  };
+}
+/**
+* Resolve a raw path (including query string and hash) against the route tree.
+* Handles nested routes recursively.
+*/
+function resolveRoute(rawPath, routes) {
+  const qIdx = rawPath.indexOf("?");
+  const pathAndHash = qIdx >= 0 ? rawPath.slice(0, qIdx) : rawPath;
+  const queryPart = qIdx >= 0 ? rawPath.slice(qIdx + 1) : "";
+  const hIdx = pathAndHash.indexOf("#");
+  const cleanPath = hIdx >= 0 ? pathAndHash.slice(0, hIdx) : pathAndHash;
+  const hash = hIdx >= 0 ? pathAndHash.slice(hIdx + 1) : "";
+  const query = parseQuery(queryPart);
+  const match = matchRoutes(cleanPath, routes, []);
+  if (match) return {
+    path: cleanPath,
+    params: match.params,
+    query,
+    hash,
+    matched: match.matched,
+    meta: mergeMeta(match.matched)
+  };
+  return {
+    path: cleanPath,
+    params: {},
+    query,
+    hash,
+    matched: [],
+    meta: {}
+  };
+}
+function matchRoutes(path, routes, parentMatched, parentParams = {}) {
+  for (const route of routes) {
+    const result = matchSingleRoute(path, route, parentMatched, parentParams);
+    if (result) return result;
+  }
+  return null;
+}
+function matchSingleRoute(path, route, parentMatched, parentParams) {
+  if (!route.children || route.children.length === 0) {
+    const params = matchPath(route.path, path);
+    if (params === null) return null;
+    return {
+      params: {
+        ...parentParams,
+        ...params
+      },
+      matched: [...parentMatched, route]
+    };
+  }
+  const prefix = matchPrefix(route.path, path);
+  if (prefix === null) return null;
+  const allParams = {
+    ...parentParams,
+    ...prefix.params
+  };
+  const matched = [...parentMatched, route];
+  const childMatch = matchRoutes(prefix.rest, route.children, matched, allParams);
+  if (childMatch) return childMatch;
+  const exactParams = matchPath(route.path, path);
+  if (exactParams === null) return null;
+  return {
+    params: {
+      ...parentParams,
+      ...exactParams
+    },
+    matched
+  };
+}
+/** Merge meta from matched routes (leaf takes precedence) */
+function mergeMeta(matched) {
+  const meta = {};
+  for (const record of matched) if (record.meta) Object.assign(meta, record.meta);
+  return meta;
+}
+/** Build a path string from a named route's pattern and params */
+function buildPath(pattern, params) {
+  return pattern.replace(/:([^/]+)\*?/g, (match, key) => {
+    const val = params[key] ?? "";
+    if (match.endsWith("*")) return val.split("/").map(encodeURIComponent).join("/");
+    return encodeURIComponent(val);
+  });
+}
+/** Find a route record by name (recursive, O(n)). Prefer buildNameIndex for repeated lookups. */
+function findRouteByName(name, routes) {
+  for (const route of routes) {
+    if (route.name === name) return route;
+    if (route.children) {
+      const found = findRouteByName(name, route.children);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+/**
+* Pre-build a name → RouteRecord index from a route tree for O(1) named navigation.
+* Called once at router creation time; avoids O(n) depth-first search per push({ name }).
+*/
+function buildNameIndex(routes) {
+  const index = /* @__PURE__ */new Map();
+  function walk(list) {
+    for (const route of list) {
+      if (route.name) index.set(route.name, route);
+      if (route.children) walk(route.children);
+    }
+  }
+  walk(routes);
+  return index;
+}
+
+//#endregion
+//#region src/scroll.ts
+/**
+* Scroll restoration manager.
+*
+* Saves scroll position before each navigation and restores it when
+* navigating back to a previously visited path.
+*/
+
+function lazy(loader, options) {
+  return {
+    [LAZY_SYMBOL]: true,
+    loader,
+    ...(options?.loading ? {
+      loadingComponent: options.loading
+    } : {}),
+    ...(options?.error ? {
+      errorComponent: options.error
+    } : {})
+  };
+}
+function isLazy(c) {
+  return typeof c === "object" && c !== null && c[LAZY_SYMBOL] === true;
+}
+
+//#endregion
+//#region src/router.ts
+
+function setActiveRouter(router) {
+  if (router) router._viewDepth = 0;
+  _activeRouter = router;
+}
+function useRouter() {
+  const router = useContext(RouterContext) ?? _activeRouter;
+  if (!router) throw new Error("[pyreon-router] No router installed. Wrap your app in <RouterProvider router={router}>.");
+  return router;
+}
+function useRoute() {
+  const router = useContext(RouterContext) ?? _activeRouter;
+  if (!router) throw new Error("[pyreon-router] No router installed. Wrap your app in <RouterProvider router={router}>.");
+  return router.currentRoute;
+}
+function createRouter(options) {
+  const opts = Array.isArray(options) ? {
+    routes: options
+  } : options;
+  const {
+    routes,
+    mode = "hash",
+    scrollBehavior,
+    onError,
+    maxCacheSize = 100
+  } = opts;
+  const nameIndex = buildNameIndex(routes);
+  const guards = [];
+  const afterHooks = [];
+  const scrollManager = new ScrollManager(scrollBehavior);
+  let _navGen = 0;
+  const getInitialLocation = () => {
+    if (opts.url) return opts.url;
+    if (!_isBrowser) return "/";
+    if (mode === "history") return window.location.pathname + window.location.search;
+    const hash = window.location.hash;
+    return hash.startsWith("#") ? hash.slice(1) || "/" : "/";
+  };
+  const getCurrentLocation = () => {
+    if (!_isBrowser) return currentPath();
+    if (mode === "history") return window.location.pathname + window.location.search;
+    const hash = window.location.hash;
+    return hash.startsWith("#") ? hash.slice(1) || "/" : "/";
+  };
+  const currentPath = signal(getInitialLocation());
+  const currentRoute = computed(() => resolveRoute(currentPath(), routes));
+  let _popstateHandler = null;
+  let _hashchangeHandler = null;
+  if (_isBrowser) if (mode === "history") {
+    _popstateHandler = () => currentPath.set(getCurrentLocation());
+    window.addEventListener("popstate", _popstateHandler);
+  } else {
+    _hashchangeHandler = () => currentPath.set(getCurrentLocation());
+    window.addEventListener("hashchange", _hashchangeHandler);
+  }
+  const componentCache = /* @__PURE__ */new Map();
+  const loadingSignal = signal(0);
+  async function evaluateGuard(guard, to, from, gen) {
+    const result = await runGuard(guard, to, from);
+    if (gen !== _navGen) return {
+      action: "cancel"
+    };
+    if (result === false) return {
+      action: "cancel"
+    };
+    if (typeof result === "string") return {
+      action: "redirect",
+      target: result
+    };
+    return {
+      action: "continue"
+    };
+  }
+  async function runRouteGuards(records, guardKey, to, from, gen) {
+    for (const record of records) {
+      const raw = record[guardKey];
+      if (!raw) continue;
+      const routeGuards = Array.isArray(raw) ? raw : [raw];
+      for (const guard of routeGuards) {
+        const outcome = await evaluateGuard(guard, to, from, gen);
+        if (outcome.action !== "continue") return outcome;
+      }
+    }
+    return {
+      action: "continue"
+    };
+  }
+  async function runGlobalGuards(globalGuards, to, from, gen) {
+    for (const guard of globalGuards) {
+      const outcome = await evaluateGuard(guard, to, from, gen);
+      if (outcome.action !== "continue") return outcome;
+    }
+    return {
+      action: "continue"
+    };
+  }
+  function processLoaderResult(result, record, ac, to) {
+    if (result.status === "fulfilled") {
+      router._loaderData.set(record, result.value);
+      return true;
+    }
+    if (ac.signal.aborted) return true;
+    if (router._onError) {
+      if (router._onError(result.reason, to) === false) return false;
+    }
+    router._loaderData.set(record, void 0);
+    return true;
+  }
+  function syncBrowserUrl(path, replace) {
+    if (!_isBrowser) return;
+    const url = mode === "history" ? path : `#${path}`;
+    if (replace) window.history.replaceState(null, "", url);else window.history.pushState(null, "", url);
+  }
+  function resolveRedirect(to) {
+    const leaf = to.matched[to.matched.length - 1];
+    if (!leaf?.redirect) return null;
+    return sanitizePath(typeof leaf.redirect === "function" ? leaf.redirect(to) : leaf.redirect);
+  }
+  async function runAllGuards(to, from, gen) {
+    const leaveOutcome = await runRouteGuards(from.matched, "beforeLeave", to, from, gen);
+    if (leaveOutcome.action !== "continue") return leaveOutcome;
+    const enterOutcome = await runRouteGuards(to.matched, "beforeEnter", to, from, gen);
+    if (enterOutcome.action !== "continue") return enterOutcome;
+    return runGlobalGuards(guards, to, from, gen);
+  }
+  async function runLoaders(to, gen, ac) {
+    const loadableRecords = to.matched.filter(r => r.loader);
+    if (loadableRecords.length === 0) return true;
+    const loaderCtx = {
+      params: to.params,
+      query: to.query,
+      signal: ac.signal
+    };
+    const results = await Promise.allSettled(loadableRecords.map(r => {
+      if (!r.loader) return Promise.resolve(void 0);
+      return r.loader(loaderCtx);
+    }));
+    if (gen !== _navGen) return false;
+    for (let i = 0; i < loadableRecords.length; i++) {
+      const result = results[i];
+      const record = loadableRecords[i];
+      if (!result || !record) continue;
+      if (!processLoaderResult(result, record, ac, to)) return false;
+    }
+    return true;
+  }
+  function commitNavigation(path, replace, to, from) {
+    scrollManager.save(from.path);
+    currentPath.set(path);
+    syncBrowserUrl(path, replace);
+    if (_isBrowser && to.meta.title) document.title = to.meta.title;
+    for (const record of router._loaderData.keys()) if (!to.matched.includes(record)) router._loaderData.delete(record);
+    for (const hook of afterHooks) try {
+      hook(to, from);
+    } catch (_err) {}
+    if (_isBrowser) queueMicrotask(() => scrollManager.restore(to, from));
+  }
+  async function navigate(path, replace, redirectDepth = 0) {
+    if (redirectDepth > 10) return;
+    const gen = ++_navGen;
+    loadingSignal.update(n => n + 1);
+    const to = resolveRoute(path, routes);
+    const from = currentRoute();
+    const redirectTarget = resolveRedirect(to);
+    if (redirectTarget !== null) {
+      loadingSignal.update(n => n - 1);
+      return navigate(redirectTarget, replace, redirectDepth + 1);
+    }
+    const guardOutcome = await runAllGuards(to, from, gen);
+    if (guardOutcome.action !== "continue") {
+      loadingSignal.update(n => n - 1);
+      if (guardOutcome.action === "redirect") return navigate(sanitizePath(guardOutcome.target), replace, redirectDepth + 1);
+      return;
+    }
+    router._abortController?.abort();
+    const ac = new AbortController();
+    router._abortController = ac;
+    if (!(await runLoaders(to, gen, ac))) {
+      loadingSignal.update(n => n - 1);
+      return;
+    }
+    commitNavigation(path, replace, to, from);
+    loadingSignal.update(n => n - 1);
+  }
+  const router = {
+    routes,
+    mode,
+    currentRoute,
+    _currentPath: currentPath,
+    _currentRoute: currentRoute,
+    _componentCache: componentCache,
+    _loadingSignal: loadingSignal,
+    _scrollPositions: /* @__PURE__ */new Map(),
+    _scrollBehavior: scrollBehavior,
+    _viewDepth: 0,
+    _erroredChunks: /* @__PURE__ */new Set(),
+    _loaderData: /* @__PURE__ */new Map(),
+    _abortController: null,
+    _onError: onError,
+    _maxCacheSize: maxCacheSize,
+    async push(location) {
+      if (typeof location === "string") return navigate(sanitizePath(location), false);
+      return navigate(resolveNamedPath(location.name, location.params ?? {}, location.query ?? {}, nameIndex), false);
+    },
+    async replace(path) {
+      return navigate(sanitizePath(path), true);
+    },
+    back() {
+      if (_isBrowser) window.history.back();
+    },
+    beforeEach(guard) {
+      guards.push(guard);
+      return () => {
+        const idx = guards.indexOf(guard);
+        if (idx >= 0) guards.splice(idx, 1);
+      };
+    },
+    afterEach(hook) {
+      afterHooks.push(hook);
+      return () => {
+        const idx = afterHooks.indexOf(hook);
+        if (idx >= 0) afterHooks.splice(idx, 1);
+      };
+    },
+    loading: () => loadingSignal() > 0,
+    destroy() {
+      if (_popstateHandler) {
+        window.removeEventListener("popstate", _popstateHandler);
+        _popstateHandler = null;
+      }
+      if (_hashchangeHandler) {
+        window.removeEventListener("hashchange", _hashchangeHandler);
+        _hashchangeHandler = null;
+      }
+      guards.length = 0;
+      afterHooks.length = 0;
+      componentCache.clear();
+      router._loaderData.clear();
+      router._abortController?.abort();
+      router._abortController = null;
+    },
+    _resolve: rawPath => resolveRoute(rawPath, routes)
+  };
+  return router;
+}
+async function runGuard(guard, to, from) {
+  try {
+    return await guard(to, from);
+  } catch (_err) {
+    return false;
+  }
+}
+function resolveNamedPath(name, params, query, index) {
+  const record = index.get(name);
+  if (!record) return "/";
+  let path = buildPath(record.path, params);
+  const qs = Object.entries(query).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  if (qs) path += `?${qs}`;
+  return path;
+}
+/** Block unsafe navigation targets: javascript/data/vbscript URIs and absolute URLs. */
+function sanitizePath(path) {
+  const trimmed = path.trim();
+  if (/^(?:javascript|data|vbscript):/i.test(trimmed)) return "/";
+  if (/^\/\/|^https?:/i.test(trimmed)) return "/";
+  return path;
+}
+
+//#endregion
+//#region src/components.tsx
+
+/** Prefetch loader data for a route (only once per router + path). */
+function prefetchRoute(router, path) {
+  let set = _prefetched.get(router);
+  if (!set) {
+    set = /* @__PURE__ */new Set();
+    _prefetched.set(router, set);
+  }
+  if (set.has(path)) return;
+  set.add(path);
+  prefetchLoaderData(router, path).catch(() => {
+    set?.delete(path);
+  });
+}
+function renderLazyRoute(router, record, raw) {
+  if (router._erroredChunks.has(record)) return raw.errorComponent ? h(raw.errorComponent, {}) : null;
+  const tryLoad = attempt => raw.loader().then(mod => {
+    cacheSet(router, record, typeof mod === "function" ? mod : mod.default);
+    router._loadingSignal.update(n => n + 1);
+  }).catch(err => {
+    if (attempt < 3) return new Promise(res => setTimeout(res, 500 * 2 ** attempt)).then(() => tryLoad(attempt + 1));
+    if (typeof window !== "undefined" && isStaleChunk(err)) {
+      window.location.reload();
+      return;
+    }
+    router._erroredChunks.add(record);
+    router._loadingSignal.update(n => n + 1);
+  });
+  tryLoad(0);
+  return raw.loadingComponent ? h(raw.loadingComponent, {}) : null;
+}
+/**
+* Wraps the route component with a LoaderDataProvider so `useLoaderData()` works
+* inside the component. If the record has no loader, renders the component directly.
+*/
+function renderWithLoader(router, record, Comp, route) {
+  const routeProps = {
+    params: route.params,
+    query: route.query,
+    meta: route.meta
+  };
+  if (!record.loader) return h(Comp, routeProps);
+  const data = router._loaderData.get(record);
+  if (data === void 0 && record.errorComponent) return h(record.errorComponent, routeProps);
+  return h(LoaderDataProvider, {
+    data,
+    children: h(Comp, routeProps)
+  });
+}
+/**
+* Thin provider component that pushes LoaderDataContext before children mount.
+* Uses Pyreon's context stack so useLoaderData() reads it during child setup.
+*/
+function LoaderDataProvider(props) {
+  pushContext(new Map([[LoaderDataContext.id, props.data]]));
+  onUnmount(() => popContext());
+  return props.children;
+}
+/** Evict oldest cache entries when the component cache exceeds maxCacheSize. */
+function cacheSet(router, record, comp) {
+  router._componentCache.set(record, comp);
+  if (router._componentCache.size > router._maxCacheSize) {
+    const oldest = router._componentCache.keys().next().value;
+    router._componentCache.delete(oldest);
+  }
+}
+/**
+* Segment-aware prefix check for active link matching.
+* `/admin` is a prefix of `/admin/users` but NOT of `/admin-panel`.
+*/
+function isSegmentPrefix(current, target) {
+  if (target === "/") return false;
+  const cs = current.split("/").filter(Boolean);
+  const ts = target.split("/").filter(Boolean);
+  if (ts.length > cs.length) return false;
+  return ts.every((seg, i) => seg === cs[i]);
+}
+/**
+* Detect a stale chunk error — happens post-deploy when the browser requests
+* a hashed filename that no longer exists on the server. Trigger a full reload
+* so the user gets the new bundle instead of a broken loading state.
+*/
+function isStaleChunk(err) {
+  if (err instanceof TypeError && String(err.message).includes("Failed to fetch")) return true;
+  if (err instanceof SyntaxError) return true;
+  return false;
+}
+
+//#endregion
+export { RouterContext, RouterLink, RouterProvider, RouterView, buildPath, createRouter, findRouteByName, hydrateLoaderData, lazy, parseQuery, parseQueryMulti, prefetchLoaderData, resolveRoute, serializeLoaderData, stringifyQuery, useLoaderData, useRoute, useRouter };
+//# sourceMappingURL=index.d.ts.map