reroute-js 0.0.1

package/react/index.js

@@ -0,0 +1,1152 @@
+// packages/react/src/components/ContentRoute.tsx
+import {
+  isValidElement,
+  useEffect as useEffect4,
+  useMemo as useMemo5,
+  useState as useState4
+} from "react";
+
+// packages/react/src/hooks/useContent.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo2, useState as useState2 } from "react";
+
+// packages/react/src/providers/ContentProvider.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState
+} from "react";
+
+// packages/react/src/utils/content.ts
+function parseContentHref(href) {
+  try {
+    const url = new URL(href, "http://local");
+    const [collection, name] = url.pathname.split("/").filter(Boolean);
+    if (!collection || !name)
+      return;
+    return { collection, name };
+  } catch {
+    return;
+  }
+}
+function createResolverFromGetEntry(getEntry) {
+  return (href) => {
+    const parsed = parseContentHref(href);
+    if (!parsed)
+      return;
+    try {
+      const entry = getEntry(parsed.collection, parsed.name);
+      if (!entry)
+        return parsed;
+      const moduleUrl = entry?.module;
+      return moduleUrl ? { ...parsed, module: moduleUrl } : parsed;
+    } catch {
+      return parsed;
+    }
+  };
+}
+
+// packages/react/src/providers/ContentProvider.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var ContentRegistryContext = createContext(null);
+var ContentIndexContext = createContext(null);
+var ContentGetEntryContext = createContext(null);
+var ContentLoadCollectionContext = createContext(null);
+function ContentProvider({
+  children,
+  resolveByHref,
+  getEntry,
+  byCollection,
+  loadCollection
+}) {
+  const [idx, setIdx] = useState(() => {
+    const seededClient = (() => {
+      try {
+        if (typeof window !== "undefined") {
+          const w = window;
+          return w.__REROUTE_COLLECTIONS__ || {};
+        }
+      } catch {}
+      return {};
+    })();
+    const seededServer = (() => {
+      try {
+        if (typeof window === "undefined") {
+          const g = globalThis;
+          return g.__REROUTE_COLLECTIONS__ || {};
+        }
+      } catch {}
+      return {};
+    })();
+    return {
+      ...byCollection || {},
+      ...seededServer,
+      ...seededClient
+    };
+  });
+  const entryFn = getEntry || null;
+  const resolver = useMemo(() => {
+    if (typeof resolveByHref === "function")
+      return resolveByHref;
+    if (typeof getEntry === "function")
+      return createResolverFromGetEntry(getEntry);
+    return (href) => {
+      const parsed = parseContentHref(href);
+      if (!parsed)
+        return;
+      try {
+        const list = idx?.[parsed.collection];
+        if (Array.isArray(list)) {
+          const found = list.find((e) => e?.name === parsed.name);
+          if (found && typeof found.module === "string") {
+            return { ...parsed, module: found.module };
+          }
+        }
+      } catch {}
+      return parsed;
+    };
+  }, [resolveByHref, getEntry, idx]);
+  const ensureCollection = useCallback(async (collection) => {
+    try {
+      const existing = idx[collection];
+      if (Array.isArray(existing) && existing.length)
+        return existing;
+      if (!loadCollection)
+        return existing;
+      const mod = await loadCollection(collection);
+      const items = mod.items || mod.list || [];
+      if (Array.isArray(items)) {
+        setIdx((prev) => ({ ...prev || {}, [collection]: items }));
+        return items;
+      }
+      return existing;
+    } catch {
+      return;
+    }
+  }, [idx, loadCollection]);
+  return /* @__PURE__ */ jsxDEV(ContentRegistryContext.Provider, {
+    value: resolver,
+    children: /* @__PURE__ */ jsxDEV(ContentIndexContext.Provider, {
+      value: idx,
+      children: /* @__PURE__ */ jsxDEV(ContentGetEntryContext.Provider, {
+        value: entryFn,
+        children: /* @__PURE__ */ jsxDEV(ContentLoadCollectionContext.Provider, {
+          value: ensureCollection,
+          children
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function useContentResolver() {
+  return useContext(ContentRegistryContext);
+}
+function useContentIndex() {
+  return useContext(ContentIndexContext);
+}
+function useContentGetEntry() {
+  return useContext(ContentGetEntryContext);
+}
+function useContentLoadCollection() {
+  return useContext(ContentLoadCollectionContext);
+}
+
+// packages/react/src/hooks/useContent.ts
+function sortByDate(order) {
+  return (a, b) => {
+    const da = a?.meta && a.meta?.date ? Date.parse(String(a.meta.date)) : 0;
+    const db = b?.meta && b.meta?.date ? Date.parse(String(b.meta.date)) : 0;
+    return order === "asc" ? da - db : db - da;
+  };
+}
+function prefetchContent(entry) {
+  if (typeof window === "undefined")
+    return;
+  const modUrl = entry?.module;
+  if (!modUrl || typeof modUrl !== "string")
+    return;
+  try {
+    const key = `${entry.collection}:${entry.name}`;
+    const w = window;
+    if (!w.__REROUTE_MODULES__)
+      w.__REROUTE_MODULES__ = {};
+    const store = w.__REROUTE_MODULES__;
+    if (store[key])
+      return;
+    import(modUrl).then((m) => {
+      const C = m.default || m;
+      store[key] = C;
+    }).catch(() => {});
+  } catch {}
+}
+function useContent(params) {
+  const { collection, sort = { date: "desc" }, limit } = params;
+  try {
+    if (typeof window === "undefined") {
+      const g = globalThis;
+      if (!g.__REROUTE_SSR_ACCESSED__) {
+        g.__REROUTE_SSR_ACCESSED__ = {};
+      }
+      const rec = g.__REROUTE_SSR_ACCESSED__;
+      const existing = rec[collection] || {};
+      const isCustomSort = typeof sort === "function";
+      const sortKey = isCustomSort ? "custom" : sort === false ? "none" : typeof sort === "string" ? sort === "date-asc" ? "date-asc" : "date-desc" : typeof sort === "object" && sort && sort.date === "asc" ? "date-asc" : "date-desc";
+      existing.sort = existing.sort && existing.sort !== sortKey ? "custom" : existing.sort || sortKey;
+      const requested = typeof limit === "number" && limit > 0 ? limit : Infinity;
+      existing.limit = Math.max(existing.limit || 0, requested);
+      rec[collection] = existing;
+    }
+  } catch {}
+  const index = useContentIndex();
+  const loadCollection = useContentLoadCollection();
+  const [_ready, setReady] = useState2(false);
+  useEffect(() => {
+    let cancelled = false;
+    async function ensure() {
+      try {
+        const have = index?.[collection];
+        const w = typeof window !== "undefined" ? window : undefined;
+        const partial = Boolean(w?.__REROUTE_COLLECTIONS_PARTIAL__?.[collection]);
+        if (!have || partial && (!limit || typeof limit === "number" && have.length < limit)) {
+          if (loadCollection)
+            await loadCollection(collection);
+        }
+      } finally {
+        if (!cancelled)
+          setReady(true);
+      }
+    }
+    ensure();
+    return () => {
+      cancelled = true;
+    };
+  }, [collection, index, loadCollection, limit]);
+  const items = useMemo2(() => {
+    const source = index || {};
+    const list = source?.[collection];
+    if (!Array.isArray(list) || list.length === 0)
+      return [];
+    let cloned = [...list];
+    if (typeof sort === "function")
+      cloned = cloned.sort(sort);
+    else if (typeof sort === "string") {
+      cloned = cloned.sort(sortByDate(sort === "date-asc" ? "asc" : "desc"));
+    } else if (sort && typeof sort === "object" && sort.date) {
+      cloned = cloned.sort(sortByDate(sort.date === "asc" ? "asc" : "desc"));
+    }
+    if (typeof limit === "number" && limit >= 0)
+      cloned = cloned.slice(0, limit);
+    return cloned;
+  }, [index, collection, sort, limit]);
+  const prefetch = useCallback2((entry) => prefetchContent(entry), []);
+  return { items, prefetch };
+}
+// packages/react/src/hooks/useData.ts
+import { useEffect as useEffect3, useMemo as useMemo4, useState as useState3 } from "react";
+
+// packages/react/src/hooks/useRouter.tsx
+import { useContext as useContext2 } from "react";
+// packages/react/src/providers/RouterProvider.tsx
+import React, {
+  createContext as createContext2,
+  useCallback as useCallback3,
+  useEffect as useEffect2,
+  useMemo as useMemo3,
+  useSyncExternalStore
+} from "react";
+import { flushSync } from "react-dom";
+
+// packages/react/src/utils/head.ts
+var HEAD_ATTR = "data-reroute-ssr-head";
+var HEAD_ATTR_ROUTE = "data-reroute-route-head";
+function isBrowser() {
+  return typeof document !== "undefined" && typeof window !== "undefined";
+}
+function applyPageMeta(meta) {
+  if (!isBrowser() || !meta || typeof meta !== "object")
+    return;
+  try {
+    const title = typeof meta.title === "string" ? meta.title : undefined;
+    const description = typeof meta.description === "string" ? meta.description : typeof meta.excerpt === "string" ? meta.excerpt : undefined;
+    if (title)
+      document.title = title;
+    if (description) {
+      let tag = document.head.querySelector('meta[name="description"]');
+      if (!tag) {
+        tag = document.createElement("meta");
+        tag.setAttribute("name", "description");
+        document.head.appendChild(tag);
+      }
+      tag.setAttribute("content", description);
+    }
+  } catch {}
+}
+function applyLang(lang) {
+  if (!isBrowser())
+    return;
+  if (typeof lang === "string" && lang.trim()) {
+    try {
+      document.documentElement.lang = lang.trim();
+    } catch {}
+  }
+}
+function applySsrHead(head) {
+  if (!isBrowser())
+    return;
+  try {
+    document.querySelectorAll(`[${HEAD_ATTR}]`).forEach((n) => {
+      n.parentElement?.removeChild(n);
+    });
+    if (!head)
+      return;
+    const parts = Array.isArray(head) ? head.map((x) => String(x)) : [String(head)];
+    const html = parts.map((p) => typeof p === "string" ? p : String(p)).join(`
+`);
+    if (!html.trim())
+      return;
+    const tpl = document.createElement("template");
+    tpl.innerHTML = html;
+    const nodes = Array.from(tpl.content.childNodes);
+    for (const node of nodes) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        node.setAttribute(HEAD_ATTR, "");
+        document.head.appendChild(node);
+      }
+    }
+  } catch {}
+}
+function applyRouteHead(head) {
+  if (!isBrowser())
+    return;
+  try {
+    document.querySelectorAll(`[${HEAD_ATTR_ROUTE}]`).forEach((n) => {
+      n.parentElement?.removeChild(n);
+    });
+    if (!head)
+      return;
+    const parts = Array.isArray(head) ? head.map((x) => String(x)) : [String(head)];
+    const html = parts.map((p) => typeof p === "string" ? p : String(p)).join(`
+`);
+    if (!html.trim())
+      return;
+    const tpl = document.createElement("template");
+    tpl.innerHTML = html;
+    const nodes = Array.from(tpl.content.childNodes);
+    for (const node of nodes) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        node.setAttribute(HEAD_ATTR_ROUTE, "");
+        document.head.appendChild(node);
+      }
+    }
+  } catch {}
+}
+
+// packages/react/src/providers/RouterProvider.tsx
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
+var OutletContext = createContext2(null);
+var RouterContext = createContext2(null);
+var listeners = [];
+var currentLocation = isBrowser2 ? {
+  pathname: window.location.pathname,
+  search: window.location.search,
+  hash: window.location.hash
+} : { pathname: "/", search: "", hash: "" };
+function subscribe(listener) {
+  if (!isBrowser2)
+    return () => {};
+  listeners.push(listener);
+  return () => {
+    listeners = listeners.filter((l) => l !== listener);
+  };
+}
+function getSnapshot() {
+  return currentLocation;
+}
+function emitChange() {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+var supportsViewTransitions = typeof document !== "undefined" && "startViewTransition" in document;
+var viewTransitionsEnabled = false;
+function setViewTransitionsEnabled(enabled) {
+  viewTransitionsEnabled = enabled && supportsViewTransitions;
+}
+var scrollRestorationEnabled = true;
+function setScrollRestorationEnabled(enabled) {
+  scrollRestorationEnabled = enabled;
+}
+var scrollPositions = new Map;
+function navigateInternal(to, options = {}) {
+  if (!isBrowser2)
+    return;
+  const url = new URL(to, window.location.origin);
+  if (url.origin !== window.location.origin) {
+    window.location.href = to;
+    return;
+  }
+  const newPath = url.pathname + url.search + url.hash;
+  const currentPath = window.location.pathname + window.location.search + window.location.hash;
+  if (newPath === currentPath)
+    return;
+  if (scrollRestorationEnabled) {
+    scrollPositions.set(currentPath, {
+      x: window.scrollX,
+      y: window.scrollY
+    });
+  }
+  if (options.replace) {
+    window.history.replaceState(options.state || null, "", to);
+  } else {
+    window.history.pushState(options.state || null, "", to);
+  }
+  const updateState = () => {
+    currentLocation = {
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash
+    };
+    emitChange();
+  };
+  if (viewTransitionsEnabled) {
+    document.startViewTransition(() => {
+      flushSync(() => {
+        updateState();
+      });
+    });
+  } else {
+    updateState();
+  }
+  if (url.hash) {
+    const element = document.querySelector(url.hash);
+    if (element) {
+      element.scrollIntoView({ behavior: "smooth" });
+    }
+  } else {
+    window.scrollTo({ top: 0, behavior: "instant" });
+  }
+}
+function RouterProvider({
+  children,
+  layouts = [],
+  matchRoute,
+  notFoundRoutes = [],
+  notFound: NotFound,
+  pathname = "/",
+  viewTransitions = true,
+  scrollRestoration = true
+}) {
+  useEffect2(() => {
+    setViewTransitionsEnabled(viewTransitions);
+    setScrollRestorationEnabled(scrollRestoration);
+  }, [viewTransitions, scrollRestoration]);
+  const serverSnapshotRef = React.useRef(null);
+  if (!serverSnapshotRef.current) {
+    if (isBrowser2) {
+      serverSnapshotRef.current = currentLocation;
+    } else {
+      serverSnapshotRef.current = { pathname, search: "", hash: "" };
+    }
+  }
+  const getServerSnapshot = useCallback3(() => serverSnapshotRef.current, []);
+  const location = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) || currentLocation;
+  useEffect2(() => {
+    if (!isBrowser2)
+      return;
+    const next = {
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash
+    };
+    if (currentLocation.pathname !== next.pathname || currentLocation.search !== next.search || currentLocation.hash !== next.hash) {
+      currentLocation = next;
+      emitChange();
+    }
+  }, []);
+  const target = useMemo3(() => matchRoute(location.pathname), [location.pathname, matchRoute]);
+  const params = target?.params || {};
+  const searchParams = useMemo3(() => new URLSearchParams(location.search), [location.search]);
+  const navigate = useCallback3((to, options = {}) => {
+    navigateInternal(to, options);
+  }, []);
+  useEffect2(() => {
+    if (!isBrowser2)
+      return;
+    const handlePopState = () => {
+      const next = {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+      };
+      try {
+        const w = window;
+        w.__REROUTE_DATA__ = w.__REROUTE_DATA__ || {};
+        const have = w.__REROUTE_DATA__[next.pathname];
+        const isDynamic = !!matchRoute?.(next.pathname)?.route?.isDynamic;
+        if (isDynamic && have === undefined) {
+          let updated = false;
+          const fallback = setTimeout(() => {
+            if (updated)
+              return;
+            updated = true;
+            currentLocation = next;
+            emitChange();
+          }, 250);
+          fetch(`/__reroute_data?path=${encodeURIComponent(next.pathname)}`, {
+            headers: { Accept: "application/json" },
+            credentials: "same-origin"
+          }).then((r) => r.ok ? r.json() : null).then((j) => {
+            try {
+              const payload = j ? j.data ?? j : undefined;
+              if (payload !== undefined)
+                w.__REROUTE_DATA__[next.pathname] = payload;
+              try {
+                w.dispatchEvent(new CustomEvent("__reroute_data__", {
+                  detail: { key: next.pathname }
+                }));
+              } catch {}
+            } catch {}
+          }).catch(() => {}).finally(() => {
+            if (!updated) {
+              clearTimeout(fallback);
+              updated = true;
+              currentLocation = next;
+              emitChange();
+            }
+          });
+          return;
+        }
+      } catch {}
+      const updateState = () => {
+        currentLocation = next;
+        emitChange();
+      };
+      if (viewTransitionsEnabled) {
+        document.startViewTransition(() => {
+          flushSync(() => {
+            updateState();
+          });
+        });
+      } else {
+        updateState();
+      }
+      if (scrollRestorationEnabled) {
+        const nextPath = next.pathname + next.search + next.hash;
+        const savedPosition = scrollPositions.get(nextPath);
+        setTimeout(() => {
+          if (next.hash) {
+            const element = document.querySelector(next.hash);
+            if (element) {
+              element.scrollIntoView({ behavior: "smooth" });
+            }
+          } else if (savedPosition) {
+            window.scrollTo({
+              top: savedPosition.y,
+              left: savedPosition.x,
+              behavior: "instant"
+            });
+          }
+        }, viewTransitionsEnabled ? 50 : 0);
+      }
+    };
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, [matchRoute]);
+  useEffect2(() => {
+    if (!isBrowser2)
+      return;
+    const handleClick = (e) => {
+      const target2 = e.target.closest("a");
+      if (!target2)
+        return;
+      const href = target2.getAttribute("href");
+      if (!href)
+        return;
+      if (target2.target === "_blank" || target2.hasAttribute("download") || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey) {
+        return;
+      }
+      const url = new URL(href, window.location.origin);
+      if (url.origin !== window.location.origin)
+        return;
+      const match = matchRoute(url.pathname);
+      if (!match)
+        return;
+      e.preventDefault();
+      navigate(href);
+    };
+    document.addEventListener("click", handleClick);
+    return () => document.removeEventListener("click", handleClick);
+  }, [navigate, matchRoute]);
+  useEffect2(() => {
+    const route = target?.route;
+    if (!route)
+      return;
+    try {
+      if (route.meta)
+        applyPageMeta(route.meta);
+    } catch {}
+    try {
+      const ssr = route.ssr;
+      if (ssr?.head)
+        applyRouteHead(ssr.head);
+      if (ssr?.lang)
+        applyLang(ssr.lang);
+    } catch {}
+    return () => {
+      applyRouteHead(undefined);
+    };
+  }, [target]);
+  const notFoundResolver = useCallback3((pathname2) => {
+    try {
+      const list = Array.isArray(notFoundRoutes) ? notFoundRoutes : [];
+      let chosen;
+      let bestLen = -1;
+      for (const nf of list) {
+        const pat = String(nf?.pattern || "/");
+        if (!pathname2.startsWith(pat))
+          continue;
+        const len = pat.split("/").filter(Boolean).length;
+        if (len >= bestLen) {
+          bestLen = len;
+          chosen = nf;
+        }
+      }
+      return chosen?.component;
+    } catch {
+      return;
+    }
+  }, [notFoundRoutes]);
+  const contextValue = useMemo3(() => ({
+    pathname: location.pathname,
+    params,
+    searchParams,
+    navigate,
+    target,
+    matchRoute,
+    notFoundResolver
+  }), [
+    location.pathname,
+    params,
+    searchParams,
+    navigate,
+    target,
+    matchRoute,
+    notFoundResolver
+  ]);
+  const matchingLayouts = useMemo3(() => {
+    return layouts.filter((layout) => {
+      if (layout.pattern === "/")
+        return true;
+      return location.pathname.startsWith(layout.pattern);
+    }).sort((a, b) => {
+      return b.pattern.split("/").length - a.pattern.split("/").length;
+    });
+  }, [layouts, location.pathname]);
+  let content;
+  if (target) {
+    const Component = target.route.component;
+    let outletContent = /* @__PURE__ */ jsxDEV2(Component, {}, undefined, false, undefined, this);
+    for (let i = matchingLayouts.length - 1;i >= 0; i--) {
+      const Layout = matchingLayouts[i].component;
+      const currentOutlet = outletContent;
+      outletContent = /* @__PURE__ */ jsxDEV2(OutletContext.Provider, {
+        value: currentOutlet,
+        children: /* @__PURE__ */ jsxDEV2(Layout, {}, undefined, false, undefined, this)
+      }, undefined, false, undefined, this);
+    }
+    content = outletContent;
+  } else {
+    const Fallback = notFoundResolver(location.pathname) || NotFound;
+    if (Fallback) {
+      content = /* @__PURE__ */ jsxDEV2(Fallback, {}, undefined, false, undefined, this);
+    } else {
+      content = /* @__PURE__ */ jsxDEV2("div", {
+        style: { padding: "2rem", textAlign: "center" },
+        children: [
+          /* @__PURE__ */ jsxDEV2("h1", {
+            children: "404 - Page Not Found"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV2("p", {
+            children: [
+              "The page ",
+              location.pathname,
+              " could not be found."
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV2("a", {
+            href: "/",
+            children: "Go Home"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+  }
+  return /* @__PURE__ */ jsxDEV2(RouterContext.Provider, {
+    value: contextValue,
+    children: children || content
+  }, undefined, false, undefined, this);
+}
+
+// packages/react/src/providers/RerouteProvider.tsx
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+function RerouteProvider({
+  from,
+  children
+}) {
+  const {
+    byCollection,
+    getContentEntry,
+    loadContent,
+    contentBaseUrl,
+    layouts = [],
+    matchRoute,
+    notFoundRoutes,
+    notFound,
+    pathname,
+    viewTransitions,
+    scrollRestoration
+  } = from;
+  const loader = loadContent || (contentBaseUrl ? (c) => import(`${contentBaseUrl}/${c}.js`) : undefined);
+  return /* @__PURE__ */ jsxDEV3(ContentProvider, {
+    getEntry: getContentEntry,
+    byCollection: byCollection || null,
+    loadCollection: loader,
+    children: /* @__PURE__ */ jsxDEV3(RouterProvider, {
+      layouts,
+      matchRoute,
+      notFoundRoutes,
+      notFound,
+      pathname,
+      viewTransitions,
+      scrollRestoration,
+      children
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+// packages/react/src/hooks/useRouter.tsx
+function useRouter() {
+  const context = useContext2(RouterContext);
+  if (!context) {
+    throw new Error("useRouter must be used within a RouterProvider");
+  }
+  return context;
+}
+
+// packages/react/src/hooks/useData.ts
+function useData(key) {
+  const { pathname } = useRouter();
+  const k = key || pathname;
+  const [_tick, setTick] = useState3(0);
+  useEffect3(() => {
+    if (typeof window === "undefined")
+      return;
+    const handler = (e) => {
+      try {
+        const detail = e.detail;
+        if (detail?.key && detail.key !== k)
+          return;
+        setTick((x) => x + 1);
+      } catch {}
+    };
+    window.addEventListener("__reroute_data__", handler);
+    return () => {
+      try {
+        window.removeEventListener("__reroute_data__", handler);
+      } catch {}
+    };
+  }, [k]);
+  useEffect3(() => {
+    if (typeof window === "undefined")
+      return;
+    try {
+      const w = window;
+      w.__REROUTE_DATA__ = w.__REROUTE_DATA__ || {};
+      if (w.__REROUTE_DATA__[k] !== undefined)
+        return;
+      w.__REROUTE_DATA_PENDING__ = w.__REROUTE_DATA_PENDING__ || {};
+      const pending = w.__REROUTE_DATA_PENDING__;
+      if (pending[k])
+        return;
+      pending[k] = true;
+      fetch(`/__reroute_data?path=${encodeURIComponent(k)}`, {
+        headers: { Accept: "application/json" },
+        credentials: "same-origin"
+      }).then((r) => r.ok ? r.json() : null).then((j) => {
+        if (!j)
+          return;
+        w.__REROUTE_DATA__[k] = j.data ?? j;
+        try {
+          setTick((x) => x + 1);
+        } catch {}
+        try {
+          w.dispatchEvent(new CustomEvent("__reroute_data__", {
+            detail: { key: k }
+          }));
+        } catch {}
+      }).catch(() => {}).finally(() => {
+        try {
+          delete w.__REROUTE_DATA_PENDING__[k];
+        } catch {}
+      });
+    } catch {}
+  }, [k]);
+  return useMemo4(() => {
+    try {
+      if (typeof window === "undefined") {
+        const g = globalThis;
+        return g.__REROUTE_DATA__?.[k];
+      }
+      const w = window;
+      return w.__REROUTE_DATA__?.[k];
+    } catch {
+      return;
+    }
+  }, [k]);
+}
+// packages/react/src/hooks/useNavigate.tsx
+function useNavigate() {
+  const { navigate } = useRouter();
+  return navigate;
+}
+// packages/react/src/hooks/useParams.tsx
+function useParams() {
+  const { params } = useRouter();
+  return params;
+}
+// packages/react/src/hooks/useSearchParams.tsx
+function useSearchParams() {
+  const { searchParams } = useRouter();
+  return searchParams;
+}
+// packages/react/src/components/ContentRoute.tsx
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+function toComponent(x) {
+  if (typeof x === "function")
+    return x;
+  if (isValidElement(x))
+    return () => x;
+  return () => null;
+}
+function ContentRoute({
+  collection,
+  name,
+  getEntry
+}) {
+  const params = useParams();
+  const { pathname, notFoundResolver } = useRouter();
+  const inferredName = name || params.slug || params.name || (() => {
+    try {
+      const parts = String(pathname || "").split("/").filter(Boolean);
+      return parts.length >= 2 ? parts[1] : undefined;
+    } catch {
+      return;
+    }
+  })();
+  const key = inferredName ? `${collection}:${inferredName}` : `${collection}:`;
+  const ctxGetEntry = useContentGetEntry();
+  const idx = useContentIndex();
+  const resolveEntry = getEntry || ctxGetEntry || ((c, n) => {
+    try {
+      const list = idx?.[c];
+      if (!Array.isArray(list))
+        return;
+      const found = list.find((e) => e?.name === n);
+      if (!found)
+        return;
+      return { module: found.module, meta: found.meta };
+    } catch {
+      return;
+    }
+  });
+  const entry = inferredName && resolveEntry ? resolveEntry(collection, inferredName) : undefined;
+  const initialComp = useMemo5(() => {
+    try {
+      const g = globalThis;
+      const C = g.__REROUTE_SSR_MODULES__?.[key];
+      if (C)
+        return toComponent(C);
+    } catch {}
+    if (typeof window !== "undefined") {
+      const store = window.__REROUTE_MODULES__ || {};
+      if (store[key])
+        return toComponent(store[key]);
+    }
+    if (entry?.component)
+      return toComponent(entry.component);
+    try {
+      const nf = typeof notFoundResolver === "function" ? notFoundResolver(pathname) : undefined;
+      if (nf)
+        return toComponent(nf);
+    } catch {}
+    return () => null;
+  }, [key, entry]);
+  const [Comp, setComp] = useState4(() => initialComp);
+  useEffect4(() => {
+    let cancelled = false;
+    if (entry?.module && typeof window !== "undefined") {
+      import(entry.module).then((m) => {
+        if (cancelled)
+          return;
+        const C = m.default || m;
+        const K = toComponent(C);
+        setComp(() => K);
+        const w = window;
+        w.__REROUTE_MODULES__ ||= {};
+        w.__REROUTE_MODULES__[key] = C;
+        try {
+          const meta = m.meta || m.frontmatter;
+          if (meta)
+            applyPageMeta(meta);
+        } catch {}
+        try {
+          const ssr = m.ssr;
+          if (ssr?.head)
+            applySsrHead(ssr.head);
+          if (ssr?.lang)
+            applyLang(ssr.lang);
+        } catch {}
+      }).catch(() => {});
+    }
+    return () => {
+      cancelled = true;
+      applySsrHead(undefined);
+    };
+  }, [entry?.module, key]);
+  useEffect4(() => {
+    try {
+      if (entry && entry.meta)
+        applyPageMeta(entry.meta);
+    } catch {}
+  }, [entry]);
+  return /* @__PURE__ */ jsxDEV4(Comp, {}, undefined, false, undefined, this);
+}
+// packages/react/src/components/Link.tsx
+import { useCallback as useCallback4, useMemo as useMemo6 } from "react";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function Link({
+  to,
+  replace,
+  state,
+  prefetch = true,
+  onClick,
+  onMouseEnter,
+  onFocus,
+  ...props
+}) {
+  const { navigate, matchRoute } = useRouter();
+  const resolver = useContentResolver();
+  const contentIndex = useContentIndex();
+  const ensureCollection = useContentLoadCollection();
+  const inferred = useMemo6(() => resolver ? resolver(String(to)) : undefined, [resolver, to]);
+  const handleClick = useCallback4(async (e) => {
+    if (onClick) {
+      onClick(e);
+    }
+    if (e.defaultPrevented || e.button !== 0 || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey || props.target === "_blank") {
+      return;
+    }
+    e.preventDefault();
+    if (prefetch) {
+      try {
+        if (typeof window !== "undefined") {
+          const url = new URL(String(to), window.location.origin);
+          if (url.origin === window.location.origin) {
+            const path = url.pathname;
+            const isDynamic = !!matchRoute?.(path)?.route?.isDynamic;
+            const w = window;
+            w.__REROUTE_DATA__ = w.__REROUTE_DATA__ || {};
+            if (isDynamic && (!inferred || !inferred.module) && w.__REROUTE_DATA__[path] === undefined) {
+              const ctl = new AbortController;
+              const timer = setTimeout(() => ctl.abort(), 350);
+              try {
+                const r = await fetch(`/__reroute_data?path=${encodeURIComponent(path)}`, {
+                  headers: { Accept: "application/json" },
+                  credentials: "same-origin",
+                  signal: ctl.signal
+                }).catch(() => null);
+                if (r?.ok) {
+                  const j = await r.json().catch(() => null);
+                  if (j) {
+                    w.__REROUTE_DATA__[path] = j.data ?? j;
+                    try {
+                      w.dispatchEvent(new CustomEvent("__reroute_data__", {
+                        detail: { key: path }
+                      }));
+                    } catch {}
+                  }
+                }
+              } catch {}
+              clearTimeout(timer);
+            }
+          }
+        }
+      } catch {}
+    }
+    navigate(to, { replace, state });
+  }, [
+    navigate,
+    to,
+    replace,
+    state,
+    onClick,
+    props.target,
+    prefetch,
+    inferred,
+    matchRoute
+  ]);
+  const handleMouseEnter = useCallback4((e) => {
+    if (prefetch && inferred && inferred.module)
+      prefetchContent(inferred);
+    else if (prefetch) {
+      try {
+        if (typeof window !== "undefined") {
+          const url = new URL(String(to), window.location.origin);
+          if (url.origin === window.location.origin) {
+            const path = url.pathname;
+            const isDynamic = !!matchRoute?.(path)?.route?.isDynamic;
+            const known = !!(contentIndex && inferred && (inferred.collection in contentIndex));
+            if (inferred && !inferred.module && ensureCollection && known) {
+              (async () => {
+                try {
+                  const items = await ensureCollection(inferred.collection);
+                  const found = (items || []).find((e2) => e2?.name === inferred.name);
+                  const mod = found?.module;
+                  if (mod)
+                    prefetchContent({ ...inferred, module: mod });
+                } catch {}
+              })();
+            }
+            const w = window;
+            w.__REROUTE_DATA__ = w.__REROUTE_DATA__ || {};
+            if (isDynamic && (!inferred || !inferred.module) && w.__REROUTE_DATA__[path] === undefined) {
+              fetch(`/__reroute_data?path=${encodeURIComponent(path)}`, {
+                headers: { Accept: "application/json" },
+                credentials: "same-origin"
+              }).then((r) => r.ok ? r.json() : null).then((j) => {
+                if (!j)
+                  return;
+                w.__REROUTE_DATA__[path] = j.data ?? j;
+                try {
+                  w.dispatchEvent(new CustomEvent("__reroute_data__", {
+                    detail: { key: path }
+                  }));
+                } catch {}
+              }).catch(() => {});
+            }
+          }
+        }
+      } catch {}
+    }
+    if (onMouseEnter)
+      onMouseEnter(e);
+  }, [
+    prefetch,
+    inferred,
+    onMouseEnter,
+    to,
+    contentIndex,
+    ensureCollection,
+    matchRoute
+  ]);
+  const handleFocus = useCallback4((e) => {
+    if (prefetch && inferred && inferred.module)
+      prefetchContent(inferred);
+    else if (prefetch) {
+      try {
+        if (typeof window !== "undefined") {
+          const url = new URL(String(to), window.location.origin);
+          if (url.origin === window.location.origin) {
+            const path = url.pathname;
+            const isDynamic = !!matchRoute?.(path)?.route?.isDynamic;
+            const known2 = !!(contentIndex && inferred && (inferred.collection in contentIndex));
+            if (inferred && !inferred.module && ensureCollection && known2) {
+              (async () => {
+                try {
+                  const items = await ensureCollection(inferred.collection);
+                  const found = (items || []).find((e2) => e2?.name === inferred.name);
+                  const mod = found?.module;
+                  if (mod)
+                    prefetchContent({ ...inferred, module: mod });
+                } catch {}
+              })();
+            }
+            const w = window;
+            w.__REROUTE_DATA__ = w.__REROUTE_DATA__ || {};
+            if (isDynamic && (!inferred || !inferred.module) && w.__REROUTE_DATA__[path] === undefined) {
+              fetch(`/__reroute_data?path=${encodeURIComponent(path)}`, {
+                headers: { Accept: "application/json" },
+                credentials: "same-origin"
+              }).then((r) => r.ok ? r.json() : null).then((j) => {
+                if (!j)
+                  return;
+                w.__REROUTE_DATA__[path] = j.data ?? j;
+                try {
+                  w.dispatchEvent(new CustomEvent("__reroute_data__", {
+                    detail: { key: path }
+                  }));
+                } catch {}
+              }).catch(() => {});
+            }
+          }
+        }
+      } catch {}
+    }
+    if (onFocus)
+      onFocus(e);
+  }, [
+    prefetch,
+    inferred,
+    onFocus,
+    to,
+    contentIndex,
+    ensureCollection,
+    matchRoute
+  ]);
+  return /* @__PURE__ */ jsxDEV5("a", {
+    href: to,
+    onClick: handleClick,
+    onMouseEnter: handleMouseEnter,
+    onFocus: handleFocus,
+    ...props
+  }, undefined, false, undefined, this);
+}
+// packages/react/src/components/Outlet.tsx
+import { useContext as useContext3 } from "react";
+import { jsxDEV as jsxDEV6, Fragment } from "react/jsx-dev-runtime";
+function Outlet() {
+  const outletContent = useContext3(OutletContext);
+  return /* @__PURE__ */ jsxDEV6(Fragment, {
+    children: outletContent
+  }, undefined, false, undefined, this);
+}
+export {
+  useSearchParams,
+  useRouter,
+  useParams,
+  useNavigate,
+  useData,
+  useContentResolver,
+  useContentLoadCollection,
+  useContentIndex,
+  useContentGetEntry,
+  useContent,
+  prefetchContent,
+  parseContentHref,
+  createResolverFromGetEntry,
+  applySsrHead,
+  applyRouteHead,
+  applyPageMeta,
+  applyLang,
+  RouterProvider,
+  RouterContext,
+  RerouteProvider,
+  OutletContext,
+  Outlet,
+  Link,
+  ContentRoute,
+  ContentProvider
+};
+
+//# debugId=BD66EE46EA6F55AE64756E2164756E21