reroute-js 0.8.0 → 0.9.0

package/core/src/utils/mime.d.ts

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.8.0
+ * reroute-js v0.9.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>

package/core/src/utils/path.d.ts

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.8.0
+ * reroute-js v0.9.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>

package/elysia/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.8.0
+ * reroute-js v0.9.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>

package/elysia/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.8.0
+ * reroute-js v0.9.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -169,6 +169,7 @@ async function buildTailwindIfConfigured(cwd) {
   }
 }
 // packages/core/src/bundler/transpile.ts
+var entryUrlToStaticDeps = new Map;
 function isWatchMode() {
   try {
     return Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
@@ -199,11 +200,19 @@ async function transpileFile(filePath, originalPath, options, bundleCache) {
       target: "browser",
       format: "esm",
       minify: options.minify,
-      splitting: false,
+      splitting: true,
       sourcemap: sm,
+      jsx: {
+        runtime: "automatic",
+        importSource: "react",
+        development: !options.minify
+      },
       define: {
-        "process.env.NODE_ENV": options.minify ? '"production"' : '"development"'
-      }
+        "process.env.NODE_ENV": options.minify ? '"production"' : '"development"',
+        __DEV__: options.minify ? "false" : "true",
+        "import.meta.env.MODE": options.minify ? '"production"' : '"development"'
+      },
+      ...options.minify ? { drop: ["console", "debugger"] } : {}
     });
   }
   let result;
@@ -219,8 +228,19 @@ async function transpileFile(filePath, originalPath, options, bundleCache) {
       console.error(log2);
     throw new Error(`Failed to transpile ${filePath}`);
   }
-  const output = result.outputs[0];
-  const code = await output.text();
+  const outputs = await Promise.all(result.outputs.map(async (o) => ({
+    path: o.path,
+    text: await o.text()
+  })));
+  const entryBase = basename(originalPath, extname(originalPath));
+  let entry = outputs.find((o) => o.path.endsWith(`${entryBase}.js`));
+  if (!entry) {
+    entry = outputs.filter((o) => o.path.endsWith(".js")).sort((a, b) => b.text.length - a.text.length)[0];
+  }
+  if (!entry) {
+    throw new Error(`[reroute] No JS output generated for ${originalPath}`);
+  }
+  const code = entry.text;
   let sourceMap;
   if (options.sourcemap && result.outputs.length > 1) {
     const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
@@ -229,10 +249,38 @@ async function transpileFile(filePath, originalPath, options, bundleCache) {
     }
   }
   const contentHash = await generateContentHash(code);
+  const chunks = outputs.filter((o) => o !== entry && o.path.endsWith(".js")).map((o) => ({
+    fileName: basename(o.path),
+    code: o.text,
+    hash: "",
+    isEntry: false,
+    imports: []
+  }));
+  for (const c of chunks) {
+    c.hash = await generateContentHash(c.code);
+    try {
+      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
+      const matches = [...code.matchAll(re)];
+      if (matches.length) {
+        c.isEntry = false;
+      }
+    } catch {}
+  }
+  const staticDepNames = [];
+  try {
+    for (const c of chunks) {
+      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
+      if (re.test(code))
+        staticDepNames.push(c.fileName);
+    }
+  } catch {}
   const bundleInfo = {
     hash: contentHash,
     code,
-    sourceMap
+    sourceMap,
+    chunks
   };
   bundleCache.set(cacheKey, bundleInfo);
   const sizeKB = (code.length / 1024).toFixed(2);
@@ -251,7 +299,13 @@ async function getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache
     try {
       const bundleInfo = await transpileFile(fullPath, rel, options, bundleCache);
       const base = basename(rel, extname(rel));
-      urls.push(`${prefix}/${base}.${bundleInfo.hash}.js`);
+      const entryUrl = `${prefix}/${base}.${bundleInfo.hash}.js`;
+      urls.push(entryUrl);
+      try {
+        const depNames = Array.isArray(bundleInfo.chunks) ? bundleInfo.chunks.map((c) => c.fileName).filter((name) => new RegExp(`["'\`]((?:\\./)?${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})["'\`]`, "g").test(bundleInfo.code)) : [];
+        const depUrls = depNames.map((n) => `${prefix}/${n}`.replace(/\/+/g, "/"));
+        entryUrlToStaticDeps.set(entryUrl, depUrls);
+      } catch {}
     } catch (error) {
       console.error(`[reroute] Error getting bundle URL for ${rel}:`, error);
       urls.push(`${prefix}/${rel}`);
@@ -259,6 +313,9 @@ async function getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache
   }
   return urls;
 }
+function getStaticDepsForUrl(entryUrl) {
+  return entryUrlToStaticDeps.get(entryUrl) || [];
+}
 // packages/core/src/content/discovery.ts
 import { readdir, stat as stat2 } from "node:fs/promises";
 
@@ -714,6 +771,21 @@ async function renderSSRDocument(options) {
   const scripts = [bundleUrl];
   let hydrationScript = "";
   let extraHead = "";
+  try {
+    if (typeof bundleUrl === "string" && bundleUrl.endsWith(".js")) {
+      extraHead += `
+<link rel="modulepreload" href="${bundleUrl}" />`;
+    }
+  } catch {}
+  try {
+    const staticDeps = getStaticDepsForUrl(bundleUrl);
+    if (Array.isArray(staticDeps) && staticDeps.length) {
+      for (const dep of staticDeps) {
+        extraHead += `
+<link rel="modulepreload" href="${dep}" />`;
+      }
+    }
+  } catch {}
   let statusOverride;
   try {
     globalThis.__REROUTE_SSR_ACCESSED__ = {};
@@ -1076,6 +1148,9 @@ class LRUCache {
     return this.cache.size;
   }
 }
+// packages/core/src/utils/compression.ts
+import { brotliCompressSync } from "node:zlib";
+
 // packages/core/src/utils/mime.ts
 function getMimeType(filePath) {
   const ext = filePath.split(".").pop()?.toLowerCase();
@@ -1108,18 +1183,31 @@ function isCompressible(contentType) {
 function acceptsGzip(acceptEncoding) {
   return Boolean(acceptEncoding && /gzip/i.test(acceptEncoding));
 }
+function acceptsBrotli(acceptEncoding) {
+  return Boolean(acceptEncoding && /\bbr\b/i.test(acceptEncoding));
+}
 function toBytes(input) {
   return typeof input === "string" ? new TextEncoder().encode(input) : input;
 }
 function gzipIfAccepted(body, contentType, acceptEncoding) {
   const extraHeaders = {};
-  if (acceptsGzip(acceptEncoding) && isCompressible(contentType)) {
-    try {
-      const compressed = Bun.gzipSync(toBytes(body));
-      extraHeaders["Content-Encoding"] = "gzip";
-      extraHeaders.Vary = "Accept-Encoding";
-      return { body: compressed, extraHeaders };
-    } catch {}
+  if (isCompressible(contentType)) {
+    if (acceptsBrotli(acceptEncoding)) {
+      try {
+        const compressed = brotliCompressSync(toBytes(body));
+        extraHeaders["Content-Encoding"] = "br";
+        extraHeaders.Vary = "Accept-Encoding";
+        return { body: compressed, extraHeaders };
+      } catch {}
+    }
+    if (acceptsGzip(acceptEncoding)) {
+      try {
+        const compressed = Bun.gzipSync(toBytes(body));
+        extraHeaders["Content-Encoding"] = "gzip";
+        extraHeaders.Vary = "Accept-Encoding";
+        return { body: compressed, extraHeaders };
+      } catch {}
+    }
   }
   return { body, extraHeaders };
 }
@@ -1628,6 +1716,9 @@ function registerSSRRoutes(app, options) {
     dataCache,
     shouldIgnorePathname
   } = options;
+  const SSR_HTML_TTL_MS = isWatchMode2 ? 0 : 5 * 60 * 1000;
+  const htmlCache = new LRUCache(200);
+  const makeKey = (pathname, acceptEncoding) => `${pathname}::${acceptEncoding || "identity"}`;
   for (const collection of collections) {
     app.get(`/${collection}/*`, async ({ request, headers }) => {
       const method = request.method || "GET";
@@ -1637,8 +1728,34 @@ function registerSSRRoutes(app, options) {
       if (!/text\/html/i.test(String(accept)))
         throw new NotFoundError4;
       try {
-        const pathname = new URL(request.url).pathname;
+        const url = new URL(request.url);
+        const pathname = url.pathname;
+        const acceptEncoding = headers["accept-encoding"] || "";
+        if (SSR_HTML_TTL_MS > 0) {
+          try {
+            const ck = makeKey(pathname, acceptEncoding);
+            const cached = htmlCache.get(ck);
+            if (cached && cached.exp > Date.now()) {
+              return new Response(cached.body, {
+                status: cached.status,
+                headers: cached.headers
+              });
+            }
+          } catch {}
+        }
         const bundleUrl = await getBundleUrl();
+        try {
+          const deps = getStaticDepsForUrl(bundleUrl);
+          const all = [bundleUrl, ...deps];
+          if (all.length) {
+            const linkValue = all.map((u) => `<${u}>; rel=modulepreload; as=script`).join(", ");
+            try {
+              const hints = new Headers({ Link: linkValue });
+              request?.sendEarlyHints?.(hints);
+            } catch {}
+            headers.link = headers.link ? `${headers.link}, ${linkValue}` : linkValue;
+          }
+        } catch {}
         const result = await renderSSRDocument({
           pathname,
           rootComponent,
@@ -1651,16 +1768,29 @@ function registerSSRRoutes(app, options) {
           appId,
           minify
         });
-        const acceptEncoding = headers["accept-encoding"] || "";
         const { body, extraHeaders } = gzipIfAccepted(result.html, "text/html; charset=utf-8", acceptEncoding);
-        return new Response(body, {
+        const resHeaders = {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": isWatchMode2 ? "no-cache" : `${directive}, max-age=${maxAge}`,
+          ...headers.link ? { link: headers.link } : {},
+          ...extraHeaders
+        };
+        const response = new Response(body, {
           status: result.status,
-          headers: {
-            "content-type": "text/html; charset=utf-8",
-            "cache-control": isWatchMode2 ? "no-cache" : `${directive}, max-age=${maxAge}`,
-            ...extraHeaders
-          }
+          headers: resHeaders
         });
+        if (SSR_HTML_TTL_MS > 0 && result.status === 200) {
+          try {
+            const ck = makeKey(pathname, acceptEncoding);
+            htmlCache.set(ck, {
+              status: result.status,
+              headers: resHeaders,
+              body,
+              exp: Date.now() + SSR_HTML_TTL_MS
+            });
+          } catch {}
+        }
+        return response;
       } catch (e) {
         console.error(`[reroute] SSR ${collection} render error:`, e);
         throw new NotFoundError4;
@@ -1703,7 +1833,31 @@ function registerSSRRoutes(app, options) {
           if (isWatchMode2) {
             await generateContentRegistry(cwd);
           }
+          const acceptEncoding = request.headers.get("accept-encoding") || "";
+          if (SSR_HTML_TTL_MS > 0) {
+            try {
+              const ck = makeKey(pathname, acceptEncoding);
+              const cached = htmlCache.get(ck);
+              if (cached && cached.exp > Date.now()) {
+                set.status = cached.status;
+                Object.assign(set.headers, cached.headers);
+                return new Response(cached.body);
+              }
+            } catch {}
+          }
           const bundleUrl = await getBundleUrl();
+          try {
+            const deps = getStaticDepsForUrl(bundleUrl);
+            const all = [bundleUrl, ...deps];
+            if (all.length) {
+              const linkValue = all.map((u) => `<${u}>; rel=modulepreload; as=script`).join(", ");
+              try {
+                const hints = new Headers({ Link: linkValue });
+                request?.sendEarlyHints?.(hints);
+              } catch {}
+              set.headers.link = set.headers.link ? `${set.headers.link}, ${linkValue}` : linkValue;
+            }
+          } catch {}
           const result = await renderSSRDocument({
             pathname,
             rootComponent,
@@ -1716,7 +1870,6 @@ function registerSSRRoutes(app, options) {
             appId,
             minify
           });
-          const acceptEncoding = request.headers.get("accept-encoding") || "";
           const { body, extraHeaders } = gzipIfAccepted(result.html, "text/html; charset=utf-8", acceptEncoding);
           set.status = result.status;
           set.headers["content-type"] = "text/html; charset=utf-8";
@@ -1727,7 +1880,19 @@ function registerSSRRoutes(app, options) {
           if (extraHeaders.Vary) {
             set.headers.vary = extraHeaders.Vary;
           }
-          return new Response(body);
+          const response = new Response(body);
+          if (SSR_HTML_TTL_MS > 0 && result.status === 200) {
+            try {
+              const ck = makeKey(pathname, acceptEncoding);
+              htmlCache.set(ck, {
+                status: result.status,
+                headers: Object.fromEntries(Object.entries(set.headers).map(([k, v]) => [k, String(v)])),
+                body,
+                exp: Date.now() + SSR_HTML_TTL_MS
+              });
+            } catch {}
+          }
+          return response;
         } catch {}
       }
     }
@@ -1777,6 +1942,32 @@ function registerStaticRoutes(app, options) {
           if (bundleInfo.hash === hash2) {
             const contentType = "application/javascript; charset=utf-8";
             const { body, extraHeaders } = gzipIfAccepted(bundleInfo.code, contentType, acceptEncoding);
+            try {
+              if (Array.isArray(bundleInfo.chunks) && bundleInfo.chunks.length) {
+                for (const chunk of bundleInfo.chunks) {
+                  const chunkPath = `${prefix}/${chunk.fileName}`.replace(/\/+/g, "/");
+                  const identityResp = new Response(chunk.code, {
+                    headers: {
+                      "Content-Type": contentType,
+                      "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
+                      ...staticHeaders
+                    }
+                  });
+                  fileCache.set(chunkPath, identityResp);
+                  const enc = headers["accept-encoding"] || "";
+                  const comp = gzipIfAccepted(chunk.code, contentType, enc);
+                  const compressedResp = new Response(comp.body, {
+                    headers: {
+                      "Content-Type": contentType,
+                      "Cache-Control": `${directive}, max-age=${365 * 24 * 60 * 60}, immutable`,
+                      ...comp.extraHeaders,
+                      ...staticHeaders
+                    }
+                  });
+                  fileCache.set(`${chunkPath}:${enc}`, compressedResp);
+                }
+              }
+            } catch {}
             const response = new Response(body, {
               headers: {
                 "Content-Type": contentType,
@@ -1824,6 +2015,14 @@ function registerStaticRoutes(app, options) {
         }
       }
     }
+    if (requestPath.endsWith(".js")) {
+      const acceptEncoding = headers["accept-encoding"] || "";
+      const pathWithEnc = `${prefix}/${requestPath}`.replace(/\/+/g, "/");
+      const cachedVariant = fileCache.get(`${pathWithEnc}:${acceptEncoding}`) || fileCache.get(pathWithEnc);
+      if (cachedVariant) {
+        return cachedVariant.clone();
+      }
+    }
     if (requestPath.endsWith(".tsx") || requestPath.endsWith(".ts")) {
       try {
         const m = requestPath.match(/^routes\/([^/]+)\/content\/([^/]+)\.(tsx|ts)$/);
@@ -2107,4 +2306,4 @@ export {
   reroute
 };
 
-//# debugId=FAB74393BB6B67C864756E2164756E21
+//# debugId=76563F260B520FB764756E2164756E21