reroute-js 1.0.0-alpha.2 → 1.0.0-alpha.21

package/react/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v1.0.0-alpha.2
+ * reroute-js v1.0.0-alpha.21
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
@@ -26,21 +26,21 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // node:path
 var exports_path = {};
 __export(exports_path, {
-  sep: () => sep,
-  resolve: () => resolve,
-  relative: () => relative,
-  posix: () => posix,
-  parse: () => parse,
-  normalize: () => normalize,
-  join: () => join,
-  isAbsolute: () => isAbsolute,
-  format: () => format,
-  extname: () => extname,
-  dirname: () => dirname,
-  delimiter: () => delimiter,
-  default: () => path_default,
+  _makeLong: () => _makeLong,
   basename: () => basename,
-  _makeLong: () => _makeLong
+  default: () => path_default,
+  delimiter: () => delimiter,
+  dirname: () => dirname,
+  extname: () => extname,
+  format: () => format,
+  isAbsolute: () => isAbsolute,
+  join: () => join,
+  normalize: () => normalize,
+  parse: () => parse,
+  posix: () => posix,
+  relative: () => relative,
+  resolve: () => resolve,
+  sep: () => sep
 });
 function assertPath(path) {
   if (typeof path !== "string")
@@ -556,18 +556,7 @@ function getSnapshot() {
   return store.state;
 }
 function getServerSnapshot() {
-  return store.state;
-}
-function setStoreState(partial) {
-  const next = { ...store.state, ...partial };
-  if (sameHydration(store.state, next))
-    return;
-  store.state = next;
-  try {
-    globalThis.__REROUTE_I18N__ = store.state;
-  } catch {}
-  for (const listener of store.listeners)
-    listener();
+  return getSnapshot();
 }
 function seedStore(value) {
   const next = {
@@ -613,18 +602,12 @@ function LocaleProvider({
       return;
     if (!state.locales.includes(next))
       return;
-    writeLocaleCookie(state.cookie, next);
-    setStoreState({ locale: next });
     if (typeof window === "undefined")
       return;
-    const parsed = parseContentPath(window.location.pathname, state.locales, state.collections);
-    if (parsed) {
-      const target = localizeContentHref(parsed.collection, parsed.name, next, state.defaultLocale);
-      const url = `${target}${window.location.search}${window.location.hash}`;
-      window.location.assign(url);
-      return;
-    }
-    window.location.reload();
+    writeLocaleCookie(state.cookie, next);
+    const url = new URL(window.location.href);
+    url.searchParams.set("lang", next);
+    window.location.assign(`${url.pathname}${url.search}${url.hash}`);
   }, [state]);
   const localizePath = useCallback((to) => {
     if (!state.enabled)
@@ -1279,11 +1262,14 @@ function useContent(params) {
         if (!g.__REROUTE_SSR_RESULTS__[collection]) {
           g.__REROUTE_SSR_RESULTS__[collection] = [];
         }
+        const itemKey = (item) => `${item.name || item.slug}\x00${item.locale || ""}`;
         const existing = g.__REROUTE_SSR_RESULTS__[collection];
-        const existingKeys = new Set(existing.map((item) => item.name || item.slug));
+        const existingKeys = new Set(existing.map(itemKey));
         for (const item of cloned) {
-          const key = item.name || item.slug;
-          if (key && !existingKeys.has(key)) {
+          if (!(item.name || item.slug))
+            continue;
+          const key = itemKey(item);
+          if (!existingKeys.has(key)) {
             existing.push(item);
             existingKeys.add(key);
           }
@@ -1342,6 +1328,39 @@ import { useContext as useContext3 } from "react";
 // packages/react/src/providers/RerouteProvider.tsx
 import { useCallback as useCallback6, useMemo as useMemo6 } from "react";
 
+// packages/react/src/lib/bundle.ts
+function readGlobalBundle(key) {
+  try {
+    return globalThis[key];
+  } catch {
+    return;
+  }
+}
+function readServerBundle() {
+  if (typeof window !== "undefined")
+    return;
+  return readGlobalBundle("__REROUTE_SERVER_BUNDLE__");
+}
+function readClientBundle() {
+  if (typeof window === "undefined")
+    return;
+  return readGlobalBundle("__REROUTE_CLIENT_BUNDLE__");
+}
+function readInjectedBundle() {
+  return typeof window === "undefined" ? readServerBundle() : readClientBundle();
+}
+function missingBundleMessage() {
+  const side = typeof window === "undefined" ? "Run reroute gen so the server bundle loads." : "Run reroute gen so the client bundle is included.";
+  return `RerouteProvider: no route bundle found. ${side} Or pass matchRoute and layouts explicitly.`;
+}
+function resolveBundleField(injected, key, prop) {
+  const fromInjected = injected?.[key];
+  if (typeof window === "undefined") {
+    return fromInjected ?? prop;
+  }
+  return prop ?? fromInjected;
+}
+
 // packages/react/src/providers/RouterProvider.tsx
 import React, {
   createContext as createContext3,
@@ -2091,7 +2110,7 @@ function RerouteProvider({
   getContentEntry,
   loadContent,
   contentBaseUrl,
-  layouts = [],
+  layouts,
   matchRoute,
   notFoundRoutes,
   notFound,
@@ -2103,7 +2122,16 @@ function RerouteProvider({
   i18n: i18nProp,
   children
 }) {
-  const loader = loadContent || (contentBaseUrl ? (c) => import(`${contentBaseUrl}/${c}.js`) : undefined);
+  const injected = readInjectedBundle();
+  const resolvedMatchRoute = resolveBundleField(injected, "matchRoute", matchRoute);
+  const resolvedLayouts = resolveBundleField(injected, "layouts", layouts) ?? [];
+  const resolvedNotFoundRoutes = resolveBundleField(injected, "notFoundRoutes", notFoundRoutes);
+  const resolvedContentBaseUrl = resolveBundleField(injected, "contentBaseUrl", contentBaseUrl);
+  const resolvedMarkdownComponents = resolveBundleField(injected, "markdownComponents", markdownComponents);
+  if (!resolvedMatchRoute) {
+    throw new Error(missingBundleMessage());
+  }
+  const loader = loadContent || (resolvedContentBaseUrl ? (c) => import(`${resolvedContentBaseUrl}/${c}.js`) : undefined);
   const i18n = i18nProp?.enabled ? i18nProp : readI18nHydration();
   const locales = i18n?.locales || [];
   const collections = useMemo6(() => {
@@ -2115,23 +2143,23 @@ function RerouteProvider({
   }, [i18n?.collections, byCollection]);
   const matchRouteWithLocale = useCallback6((path) => {
     if (!(i18n?.enabled && locales.length)) {
-      return matchRoute(path);
+      return resolvedMatchRoute(path);
     }
     const parsed = parseContentPath(path, locales, collections);
     const routingPath = parsed?.routingPathname || path;
-    return matchRoute(routingPath);
-  }, [i18n?.enabled, locales, collections, matchRoute]);
+    return resolvedMatchRoute(routingPath);
+  }, [i18n?.enabled, locales, collections, resolvedMatchRoute]);
   return /* @__PURE__ */ jsx5(LocaleProvider, {
     value: i18n,
     children: /* @__PURE__ */ jsx5(ContentProvider, {
       getEntry: getContentEntry,
       byCollection: byCollection || null,
       loadCollection: loader,
-      markdownComponents,
+      markdownComponents: resolvedMarkdownComponents,
       children: /* @__PURE__ */ jsx5(RouterProvider, {
-        layouts,
+        layouts: resolvedLayouts,
         matchRoute: matchRouteWithLocale,
-        notFoundRoutes,
+        notFoundRoutes: resolvedNotFoundRoutes,
         notFound,
         pathname,
         searchParams,
@@ -3728,12 +3756,75 @@ async function collectionSearch(options) {
   }
 }
 // packages/react/src/lib/lazy-route.tsx
+import {
+  createElement,
+  lazy,
+  Suspense,
+  useEffect as useEffect10,
+  useState as useState10
+} from "react";
 var isBrowser3 = typeof window !== "undefined";
-function createLazyRoute(eagerComponent, _lazyImport, _routePattern) {
+function getCapturedRouteHtml() {
+  try {
+    return globalThis.__REROUTE_ROUTE_HTML__ || null;
+  } catch {
+    return null;
+  }
+}
+function isInitialHydration3() {
+  try {
+    return !!globalThis.__REROUTE_INITIAL_HYDRATION__;
+  } catch {
+    return false;
+  }
+}
+function createLazyRoute(lazyImport, routePattern, serverComponent) {
   if (!isBrowser3) {
-    return eagerComponent;
+    let ServerRoute = function(props) {
+      return createElement("div", {
+        "data-reroute-route": "ssr",
+        style: { display: "contents" }
+      }, createElement(Component, props));
+    };
+    if (!serverComponent) {
+      return function MissingServerRoute() {
+        throw new Error(`Missing SSR component for route ${routePattern}`);
+      };
+    }
+    const Component = serverComponent;
+    ServerRoute.displayName = `LazyRoute(${routePattern})`;
+    return ServerRoute;
+  }
+  const LazyComp = lazy(lazyImport);
+  function ClientRoute(props) {
+    const [Resolved, setResolved] = useState10(null);
+    const initialHydration = isInitialHydration3();
+    const capturedHtml = initialHydration ? getCapturedRouteHtml() : null;
+    useEffect10(() => {
+      let alive = true;
+      lazyImport().then((mod) => {
+        if (alive)
+          setResolved(() => mod.default);
+      });
+      return () => {
+        alive = false;
+      };
+    }, []);
+    if (Resolved) {
+      return createElement(Resolved, props);
+    }
+    if (capturedHtml && initialHydration) {
+      return createElement("div", {
+        "data-reroute-route": "ssr",
+        style: { display: "contents" },
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: { __html: capturedHtml }
+      });
+    }
+    return createElement(Suspense, { fallback: null }, createElement(LazyComp, props));
   }
-  return eagerComponent;
+  ClientRoute.displayName = `LazyRoute(${routePattern})`;
+  return ClientRoute;
 }
 async function preloadRoute(lazyImport) {
   try {
@@ -3741,62 +3832,67 @@ async function preloadRoute(lazyImport) {
   } catch {}
 }
 export {
-  useToc,
-  useSearchParams,
-  useSearch,
-  useRouter,
-  useParams,
-  useNavigate,
-  useMarkdownComponents,
-  useLocaleContext,
-  useLocale,
-  useLlms,
-  useLayoutData,
-  useFeed,
-  useData,
-  useContentResolver,
-  useContentLoadCollection,
-  useContentIndex,
-  useContentGetEntry,
-  useContent,
-  t,
-  storeAndDispatchData,
-  shouldSkipInterception,
-  preloadRoute,
-  prefetchRouteDataWithTimeout,
-  prefetchRouteData,
-  prefetchContentModule,
-  prefetchContent,
-  parseLocalUrl,
-  parseContentPath,
-  parseContentHref,
-  needsDataPrefetch,
-  localizeHref,
-  localizeContentHref,
-  isModifiedClick,
-  getRerouteDataStore,
-  fetchRouteData,
-  dispatchDataEvent,
-  createTranslator,
-  createResolverFromGetEntry,
-  createLazyRoute,
-  collectionSearch,
-  applySsrHead,
-  applyRouteHead,
-  applyPageMeta,
-  applyLang,
-  RouterProvider,
-  RouterContext,
-  RerouteProvider,
-  OutletContext,
-  Outlet,
-  Markdown,
-  LocaleProvider,
-  Link,
-  Image,
-  ContentRoute,
+  ClientOnly,
   ContentProvider,
-  ClientOnly
+  ContentRoute,
+  Image,
+  Link,
+  LocaleProvider,
+  Markdown,
+  Outlet,
+  OutletContext,
+  RerouteProvider,
+  RouterContext,
+  RouterProvider,
+  applyLang,
+  applyPageMeta,
+  applyRouteHead,
+  applySsrHead,
+  collectionSearch,
+  createLazyRoute,
+  createResolverFromGetEntry,
+  createTranslator,
+  dispatchDataEvent,
+  fetchRouteData,
+  getRerouteDataStore,
+  isModifiedClick,
+  localizeContentHref,
+  localizeHref,
+  missingBundleMessage,
+  needsDataPrefetch,
+  parseContentHref,
+  parseContentPath,
+  parseLocalUrl,
+  prefetchContent,
+  prefetchContentModule,
+  prefetchRouteData,
+  prefetchRouteDataWithTimeout,
+  preloadRoute,
+  readClientBundle,
+  readInjectedBundle,
+  readServerBundle,
+  resolveBundleField,
+  shouldSkipInterception,
+  storeAndDispatchData,
+  t,
+  useContent,
+  useContentGetEntry,
+  useContentIndex,
+  useContentLoadCollection,
+  useContentResolver,
+  useData,
+  useFeed,
+  useLayoutData,
+  useLlms,
+  useLocale,
+  useLocaleContext,
+  useMarkdownComponents,
+  useNavigate,
+  useParams,
+  useRouter,
+  useSearch,
+  useSearchParams,
+  useToc
 };
 
-//# debugId=ED8D649610B0042464756E2164756E21
+//# debugId=FE3E1397860AC40E64756E2164756E21