reroute-js 0.41.0 → 0.42.0

package/elysia/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.41.0
+ * reroute-js v0.42.0
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
@@ -4061,13 +4061,13 @@ async function discoverSSRDataRoutes2(cwd, staticRoutes, isWatchMode, baseUrl, s
   const ssrDataRoutes = new Map;
   const bundledRoutes = globalThis.__REROUTE_ROUTES__;
   if (bundledRoutes && Array.isArray(bundledRoutes)) {
-    for (const route of staticRoutes) {
+    const routePromises = staticRoutes.map(async (route) => {
       if (sitemapConfig?.excludeDiscovery?.some((excluded) => route.pattern.startsWith(excluded))) {
-        continue;
+        return null;
       }
       const bundledRoute = bundledRoutes.find((r) => r?.pattern === route.pattern);
       if (!bundledRoute)
-        continue;
+        return null;
       const ssr = bundledRoute?.ssr;
       const dataFn = ssr?.data;
       if (typeof dataFn === "function") {
@@ -4080,15 +4080,22 @@ async function discoverSSRDataRoutes2(cwd, staticRoutes, isWatchMode, baseUrl, s
           });
           const entries = extractEntriesFromData(result, route.pattern, baseUrl, sitemapConfig);
           if (entries.length > 0) {
-            ssrDataRoutes.set(route.pattern, entries);
+            return { pattern: route.pattern, entries };
           }
         } catch {}
       }
+      return null;
+    });
+    const results = await Promise.all(routePromises);
+    for (const result of results) {
+      if (result) {
+        ssrDataRoutes.set(result.pattern, result.entries);
+      }
     }
   } else {
-    for (const route of staticRoutes) {
+    const routePromises = staticRoutes.map(async (route) => {
       if (sitemapConfig?.excludeDiscovery?.some((excluded) => route.pattern.startsWith(excluded))) {
-        continue;
+        return null;
       }
       try {
         const routeModulePath = join(cwd, "src", "client", "routes", route.path);
@@ -4104,10 +4111,17 @@ async function discoverSSRDataRoutes2(cwd, staticRoutes, isWatchMode, baseUrl, s
           });
           const entries = extractEntriesFromData(result, route.pattern, baseUrl, sitemapConfig);
           if (entries.length > 0) {
-            ssrDataRoutes.set(route.pattern, entries);
+            return { pattern: route.pattern, entries };
           }
         }
       } catch {}
+      return null;
+    });
+    const results = await Promise.all(routePromises);
+    for (const result of results) {
+      if (result) {
+        ssrDataRoutes.set(result.pattern, result.entries);
+      }
     }
   }
   return ssrDataRoutes;
@@ -4170,6 +4184,8 @@ function extractIdentifierFromItem(item, routePattern, sitemapConfig) {
   if (sitemapConfig?.extractUrl) {
     try {
       const identifier2 = sitemapConfig.extractUrl(item, routePattern);
+      if (identifier2 === false)
+        return null;
       if (identifier2)
         return identifier2;
     } catch (error) {
@@ -4425,6 +4441,8 @@ function extractIdentifier2(item, routePattern, rssConfig) {
   if (rssConfig?.extractUrl) {
     try {
       const identifier = rssConfig.extractUrl(item, routePattern);
+      if (identifier === false)
+        return null;
       if (identifier)
         return String(identifier);
     } catch (error) {
@@ -4483,24 +4501,28 @@ function createRSSItemFromData(item, routePattern, baseUrl, rssConfig) {
 }
 async function discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig) {
   const collectionsMap = new Map;
-  for (const collection of collections2) {
+  const collectionPromises = collections2.map(async (collection) => {
     const items = await discoverCollectionFeedItems(cwd, collection, isWatchMode, baseUrl, rssConfig);
-    if (items.length > 0) {
-      collectionsMap.set(collection, items);
+    return items.length > 0 ? { collection, items } : null;
+  });
+  const collectionResults = await Promise.all(collectionPromises);
+  for (const result of collectionResults) {
+    if (result) {
+      collectionsMap.set(result.collection, result.items);
     }
   }
   const ssrDataFeeds = new Map;
   const bundledRoutes = globalThis.__REROUTE_ROUTES__;
+  const { discoverRoutes: discoverRoutes2 } = await Promise.resolve().then(() => (init_discovery4(), exports_discovery));
+  const { staticRoutes } = await discoverRoutes2(cwd, isWatchMode);
   if (bundledRoutes && Array.isArray(bundledRoutes)) {
-    const { discoverRoutes: discoverRoutes2 } = await Promise.resolve().then(() => (init_discovery4(), exports_discovery));
-    const { staticRoutes } = await discoverRoutes2(cwd, isWatchMode);
-    for (const route of staticRoutes) {
+    const routePromises = staticRoutes.map(async (route) => {
       if (rssConfig?.excludeDiscovery?.some((excluded) => route.pattern.startsWith(excluded))) {
-        continue;
+        return null;
       }
       const bundledRoute = bundledRoutes.find((r) => r?.pattern === route.pattern);
       if (!bundledRoute)
-        continue;
+        return null;
       const ssr = bundledRoute?.ssr;
       const dataFn = ssr?.data;
       if (typeof dataFn === "function") {
@@ -4513,21 +4535,33 @@ async function discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfi
           });
           const items = extractRSSItemsFromData(result, route.pattern, baseUrl, rssConfig);
           if (items.length > 0) {
-            ssrDataFeeds.set(route.pattern, items);
+            return { pattern: route.pattern, items };
           }
         } catch {}
       }
+      return null;
+    });
+    const results = await Promise.all(routePromises);
+    for (const result of results) {
+      if (result) {
+        ssrDataFeeds.set(result.pattern, result.items);
+      }
     }
   } else {
-    const { discoverRoutes: discoverRoutes2 } = await Promise.resolve().then(() => (init_discovery4(), exports_discovery));
-    const { staticRoutes } = await discoverRoutes2(cwd, isWatchMode);
-    for (const route of staticRoutes) {
+    const routePromises = staticRoutes.map(async (route) => {
       if (rssConfig?.excludeDiscovery?.some((excluded) => route.pattern.startsWith(excluded))) {
-        continue;
+        return null;
       }
       const items = await discoverSSRDataFeedItems(cwd, route.pattern, route.path, isWatchMode, baseUrl, rssConfig);
       if (items.length > 0) {
-        ssrDataFeeds.set(route.pattern, items);
+        return { pattern: route.pattern, items };
+      }
+      return null;
+    });
+    const results = await Promise.all(routePromises);
+    for (const result of results) {
+      if (result) {
+        ssrDataFeeds.set(result.pattern, result.items);
       }
     }
   }
@@ -6042,6 +6076,8 @@ let hasConnected = false;
 let wasDisconnected = false;
 let reloadTriggered = false;
 let rebuildNotice = null;
+let reconnectAttempts = 0;
+let isReconnecting = false;
 
 function showRebuildNotice() {
   if (rebuildNotice) return;
@@ -6119,6 +6155,43 @@ function hideRebuildNotice() {
   }
 }
 
+// Check if server is ready before attempting SSE connection
+async function waitForServer() {
+  const maxAttempts = 60; // 30 seconds max
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const res = await fetch('/__reroute_watch.js', { method: 'HEAD' });
+      if (res.ok) return true;
+    } catch {
+      // Server not ready, continue waiting
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  return false;
+}
+
+async function scheduleReconnect() {
+  if (reloadTriggered || isReconnecting) return;
+  isReconnecting = true;
+  
+  // Exponential backoff: 300ms, 600ms, 1200ms, max 2000ms
+  const delay = Math.min(300 * Math.pow(2, reconnectAttempts), 2000);
+  reconnectAttempts++;
+  
+  await new Promise(r => setTimeout(r, delay));
+  
+  // Wait for server to be ready before creating EventSource
+  const ready = await waitForServer();
+  isReconnecting = false;
+  
+  if (ready && !reloadTriggered) {
+    connect();
+  } else if (!reloadTriggered) {
+    // Server still not ready, try again
+    scheduleReconnect();
+  }
+}
+
 function connect() {
   if (reloadTriggered) return;
   
@@ -6126,6 +6199,7 @@ function connect() {
   
   eventSource.addEventListener('message', (e) => {
     if (e.data === 'connected') {
+      reconnectAttempts = 0; // Reset backoff on successful connection
       if (hasConnected && wasDisconnected && !reloadTriggered) {
         console.log('[reroute] ✓ Server restarted, reloading...');
         reloadTriggered = true;
@@ -6149,11 +6223,12 @@ function connect() {
     if (reloadTriggered) return;
     wasDisconnected = true;
     eventSource?.close();
-    if (hasConnected) {
+    if (hasConnected && reconnectAttempts === 0) {
+      // Only log on first disconnect to reduce console spam
       console.log('[reroute] \uD83D\uDD04 Server restarting...');
       showRebuildNotice();
     }
-    setTimeout(connect, 1000);
+    scheduleReconnect();
   });
 }
 
@@ -6776,6 +6851,7 @@ function registerOGRoutes(app, options) {
   const width = ogConfig.width ?? 1200;
   const height = ogConfig.height ?? 630;
   const maxAge = ogConfig.maxAge ?? 3600;
+  const generatingImages = new Set;
   function normalizeOgPathname(urlPathname) {
     let pathname = urlPathname.replace(/^\/__reroute_og/, "").replace(/\.png$/, "");
     if (pathname === "/index" || pathname === "index") {
@@ -6797,7 +6873,7 @@ function registerOGRoutes(app, options) {
     }
     return;
   }
-  async function generateOgImage(pathname, clientDir2, cwd2, isWatchMode2, ogConfig2, width2, height2, set) {
+  async function generateOgImage(pathname, clientDir2, cwd2, isWatchMode2, ogConfig2, width2, height2) {
     const ogPath = await findOGImageForPath(pathname, clientDir2);
     const Component = await loadOgComponent(ogPath, ogConfig2, cwd2, isWatchMode2);
     if (!Component) {
@@ -6867,10 +6943,6 @@ function registerOGRoutes(app, options) {
     if (maxAge > 0) {
       ogCache.set(pathname, { buffer, exp: Date.now() + maxAge * 1000 });
     }
-    set.headers["content-type"] = "image/png";
-    set.headers["cache-control"] = `public, max-age=${maxAge}`;
-    set.headers["Reroute-Cache"] = "MISS";
-    return new Response(buffer);
   }
   app.get("/__reroute_og/*", async ({ request, set }) => {
     try {
@@ -6879,9 +6951,30 @@ function registerOGRoutes(app, options) {
       const cachedResponse = checkOgCache(pathname, set);
       if (cachedResponse)
         return cachedResponse;
-      return await generateOgImage(pathname, clientDir, cwd, isWatchMode, ogConfig, width, height, set);
+      if (generatingImages.has(pathname)) {
+        set.status = 404;
+        set.headers["Retry-After"] = "2";
+        return new Response("Image generation in progress", {
+          status: 404,
+          headers: { "Content-Type": "text/plain" }
+        });
+      }
+      generatingImages.add(pathname);
+      generateOgImage(pathname, clientDir, cwd, isWatchMode, ogConfig, width, height).then(() => {
+        console.log(`[reroute/og] Generated image for: ${pathname}`);
+      }).catch((error) => {
+        console.error(`[reroute/og] Failed to generate image for ${pathname}:`, error);
+      }).finally(() => {
+        generatingImages.delete(pathname);
+      });
+      set.status = 404;
+      set.headers["Retry-After"] = "2";
+      return new Response("Image not yet available, please retry", {
+        status: 404,
+        headers: { "Content-Type": "text/plain" }
+      });
     } catch (error) {
-      console.error("[reroute] Failed to generate OG image:", error);
+      console.error("[reroute] Failed to handle OG image request:", error);
       set.status = 500;
       return new Response("Internal Server Error", {
         status: 500,
@@ -7025,6 +7118,23 @@ function registerRobotsRoute(app, options) {
 // packages/elysia/src/routes/rss.ts
 init_core();
 import { NotFoundError as NotFoundError8 } from "elysia";
+var rssDiscoveryCache = new LRUCache(1);
+async function getOrDiscoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig) {
+  if (isWatchMode) {
+    return discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
+  }
+  const cacheKey = "rss:discovery";
+  const cached = rssDiscoveryCache.get(cacheKey);
+  if (cached && cached.exp > Date.now()) {
+    return cached.discovery;
+  }
+  const discovery5 = await discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
+  rssDiscoveryCache.set(cacheKey, {
+    discovery: discovery5,
+    exp: Date.now() + 5 * 60 * 1000
+  });
+  return discovery5;
+}
 function createFeedTitle(configTitle, name) {
   return configTitle ?? `${name.charAt(0).toUpperCase() + name.slice(1)} Feed`;
 }
@@ -7055,7 +7165,7 @@ async function registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMod
       if (cached) {
         return feedResponse(cached.xml, format, { maxAge, cacheStatus: "HIT" });
       }
-      const discovery5 = await discoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
+      const discovery5 = await getOrDiscoverRSSData(cwd, collections2, baseUrl, isWatchMode, rssConfig);
       const allItems = [
         ...Array.from(discovery5.collections.values()).flat(),
         ...Array.from(discovery5.ssrDataFeeds.values()).flat()
@@ -7094,7 +7204,7 @@ function registerCollectionFeedRoutes(app, collections2, options) {
             cacheStatus: "HIT"
           });
         }
-        const discovery5 = await discoverRSSData(options.cwd, [collection], options.baseUrl, options.isWatchMode, options.rssConfig);
+        const discovery5 = await getOrDiscoverRSSData(options.cwd, [collection], options.baseUrl, options.isWatchMode, options.rssConfig);
         const items = discovery5.collections.get(collection) ?? [];
         if (items.length === 0)
           throw new NotFoundError8;
@@ -7155,7 +7265,7 @@ async function generateSSRDataFeed(route, options) {
   }
   let items = await discoverSSRDataFeedItems(options.cwd, route.pattern, route.path, options.isWatchMode, options.baseUrl, options.rssConfig);
   if (items.length === 0 && route.isLayout) {
-    const discovery5 = await discoverRSSData(options.cwd, [], options.baseUrl, options.isWatchMode, options.rssConfig);
+    const discovery5 = await getOrDiscoverRSSData(options.cwd, [], options.baseUrl, options.isWatchMode, options.rssConfig);
     items = discovery5.ssrDataFeeds.get(route.pattern) ?? [];
   }
   if (items.length === 0)
@@ -7212,7 +7322,6 @@ async function registerRSSRoutes(app, options) {
   const feedDescription = rssConfig?.description ?? "Latest updates";
   const availableFeeds = ["/feed.xml"];
   registerMainFeedRoute(app, cwd, collections2, baseUrl, isWatchMode, rssCache, format, limit, maxAge, ttlMs, feedTitle, feedDescription, rssConfig);
-  const ssrDataRoutes = await discoverSSRRoutes(cwd, isWatchMode);
   registerCollectionFeedRoutes(app, collections2, {
     cwd,
     clientDir,
@@ -7226,6 +7335,11 @@ async function registerRSSRoutes(app, options) {
     rssConfig,
     availableFeeds
   });
+  if (isWatchMode) {
+    globalThis.__REROUTE_AVAILABLE_FEEDS__ = availableFeeds;
+    return app;
+  }
+  const ssrDataRoutes = await discoverSSRRoutes(cwd, isWatchMode);
   const routesWithFeeds = await discoverRoutesWithFeeds(ssrDataRoutes, collections2, {
     cwd,
     clientDir,
@@ -7376,9 +7490,26 @@ function registerSearchRoute(app, cwd, directive, maxAge, searchConfig) {
 // packages/elysia/src/routes/sitemap.ts
 init_core();
 import { NotFoundError as NotFoundError9 } from "elysia";
+var sitemapDiscoveryCache = new LRUCache(1);
+async function getOrDiscoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig) {
+  if (isWatchMode) {
+    return discoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
+  }
+  const cacheKey = "sitemap:discovery";
+  const cached = sitemapDiscoveryCache.get(cacheKey);
+  if (cached && cached.exp > Date.now()) {
+    return cached.discovery;
+  }
+  const discovery5 = await discoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
+  sitemapDiscoveryCache.set(cacheKey, {
+    discovery: discovery5,
+    exp: Date.now() + 5 * 60 * 1000
+  });
+  return discovery5;
+}
 async function generateAndCacheSitemap(options, _ttlMs) {
   const { cwd, collections: collections2, baseUrl, isWatchMode, sitemapConfig } = options;
-  const discovery5 = await discoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
+  const discovery5 = await getOrDiscoverSitemapData(cwd, collections2, baseUrl, isWatchMode, sitemapConfig);
   const result = await generateSitemap(discovery5, baseUrl, {
     changefreq: sitemapConfig?.changefreq,
     priority: sitemapConfig?.priority,
@@ -8107,8 +8238,24 @@ var reroute = () => async (app) => {
   const shouldIgnore = !ignorePatterns.length ? () => false : (file) => ignorePatterns.find((pattern) => typeof pattern === "string" ? file.includes(pattern) : pattern.test(file));
   const isWatchMode = Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
   const dataCacheControl = `${directive}, max-age=${maxAge}`;
-  if (isWatchMode)
+  if (isWatchMode) {
     console.log(`[reroute] Live reload enabled`);
+    registerLiveReloadRoutes(app, liveReloadState);
+    app.post("/__reroute_rebuilding", () => {
+      console.log("[reroute] Rebuild notification received, notifying browsers...");
+      notifyRebuilding();
+      return new Response(JSON.stringify({ ok: true, clients: liveReloadState.clients.size }), {
+        headers: { "content-type": "application/json" }
+      });
+    });
+    app.post("/__reroute_reload", () => {
+      console.log(`[reroute] Reload notification received, notifying ${liveReloadState.clients.size} browser(s)...`);
+      notifyReload();
+      return new Response(JSON.stringify({ ok: true, clients: liveReloadState.clients.size }), {
+        headers: { "content-type": "application/json" }
+      });
+    });
+  }
   const readBundleUrl = async () => {
     const bundlesDir = `${cwd}/.reroute/bundles`;
     const maxAttempts = isWatchMode ? 500 : 10;
@@ -8155,25 +8302,6 @@ var reroute = () => async (app) => {
     isWatchMode,
     maxAge
   });
-  if (isWatchMode) {
-    registerLiveReloadRoutes(app, liveReloadState);
-  }
-  if (isWatchMode) {
-    app.post("/__reroute_rebuilding", () => {
-      console.log("[reroute] Rebuild notification received, notifying browsers...");
-      notifyRebuilding();
-      return new Response(JSON.stringify({ ok: true, clients: liveReloadState.clients.size }), {
-        headers: { "content-type": "application/json" }
-      });
-    });
-    app.post("/__reroute_reload", () => {
-      console.log(`[reroute] Reload notification received, notifying ${liveReloadState.clients.size} browser(s)...`);
-      notifyReload();
-      return new Response(JSON.stringify({ ok: true, clients: liveReloadState.clients.size }), {
-        headers: { "content-type": "application/json" }
-      });
-    });
-  }
   registerArtifactsRoutes(app, cwd, fileCache, {
     bundleMaxAge,
     directive,
@@ -8222,6 +8350,39 @@ var reroute = () => async (app) => {
           console.error("[reroute] Failed to register robots route:", error);
         }
       }
+      if (sitemapEnabled && sitemapBaseUrl) {
+        try {
+          registerSitemapRoutes(app, {
+            cwd,
+            collections: collections2,
+            baseUrl: sitemapBaseUrl,
+            maxAge,
+            isWatchMode,
+            sitemapCache,
+            sitemapConfig
+          });
+          console.log(`[reroute] Sitemap enabled at ${sitemapBaseUrl}/sitemap.xml`);
+        } catch (error) {
+          console.error("[reroute] Failed to register sitemap routes:", error);
+        }
+      }
+      if (rssEnabled && rssBaseUrl) {
+        try {
+          await registerRSSRoutes(app, {
+            cwd,
+            clientDir,
+            collections: collections2,
+            baseUrl: rssBaseUrl,
+            maxAge,
+            isWatchMode,
+            rssCache,
+            rssConfig
+          });
+          console.log(`[reroute] RSS feeds enabled at ${rssBaseUrl}/feed.xml`);
+        } catch (error) {
+          console.error("[reroute] Failed to register RSS routes:", error);
+        }
+      }
       if (llmsEnabled && llmsConfig) {
         try {
           registerLLMsRoutes(app, {
@@ -8252,6 +8413,20 @@ var reroute = () => async (app) => {
           console.error("[reroute] Failed to register LLMs routes:", error);
         }
       }
+      if (ogEnabled && ogConfig) {
+        try {
+          registerOGRoutes(app, {
+            clientDir,
+            cwd,
+            isWatchMode,
+            ogConfig,
+            ogCache
+          });
+          console.log("[reroute] OG image generation enabled");
+        } catch (error) {
+          console.error("[reroute] Failed to register OG routes:", error);
+        }
+      }
       registerSSRRoutes(app, {
         rootComponent,
         clientDir,
@@ -8275,53 +8450,6 @@ var reroute = () => async (app) => {
         baseUrl,
         autoCanonical
       });
-      if (sitemapEnabled && sitemapBaseUrl) {
-        try {
-          registerSitemapRoutes(app, {
-            cwd,
-            collections: collections2,
-            baseUrl: sitemapBaseUrl,
-            maxAge,
-            isWatchMode,
-            sitemapCache,
-            sitemapConfig
-          });
-          console.log(`[reroute] Sitemap enabled at ${sitemapBaseUrl}/sitemap.xml`);
-        } catch (error) {
-          console.error("[reroute] Failed to register sitemap routes:", error);
-        }
-      }
-      if (rssEnabled && rssBaseUrl) {
-        try {
-          await registerRSSRoutes(app, {
-            cwd,
-            clientDir,
-            collections: collections2,
-            baseUrl: rssBaseUrl,
-            maxAge,
-            isWatchMode,
-            rssCache,
-            rssConfig
-          });
-          console.log(`[reroute] RSS feeds enabled at ${rssBaseUrl}/feed.xml`);
-        } catch (error) {
-          console.error("[reroute] Failed to register RSS routes:", error);
-        }
-      }
-      if (ogEnabled && ogConfig) {
-        try {
-          registerOGRoutes(app, {
-            clientDir,
-            cwd,
-            isWatchMode,
-            ogConfig,
-            ogCache
-          });
-          console.log("[reroute] OG image generation enabled");
-        } catch (error) {
-          console.error("[reroute] Failed to register OG routes:", error);
-        }
-      }
     } catch (error) {
       console.error("[reroute] Failed to register SSR routes:", error);
       throw error;
@@ -8342,4 +8470,4 @@ export {
   reroute
 };
 
-//# debugId=EE0ACEF1418C00E864756E2164756E21
+//# debugId=8F66BA5867641AA764756E2164756E21