catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/server/renderer/extract.js

@@ -1,38 +1,44 @@
-import React from "react"
-import path from "path"
-import fs from "fs"
+import React from "react";
+import path from "path";
+import fs from "fs";
+
+// Caches this module parks on the `process` object so they survive across
+// requests. Declared here purely so TypeScript knows about them; no runtime
+// effect.
 
 // ── CSS: read from disk and inline as <style> ──────────────────────────
 
 // Process-level cache — survives across requests, reset on deploy.
-if (!process.cssFileCache) process.cssFileCache = {}
+if (!process.cssFileCache) process.cssFileCache = {};
 
 // Per-route deferred asset paths/URLs learned from past SSRs — inlined in <head> on later visits
 // so late <style> after </body> does not re-layout already-painted content. CSS file bodies use
 // process.cssFileCache inside readCssFromDisk (no repeat disk read).
-if (!process.deferredAssetsByRoute) process.deferredAssetsByRoute = new Map()
-
-const routeRecord = (routeKey) => {
-    let rec = process.deferredAssetsByRoute.get(routeKey)
-    if (!rec) {
-        rec = { css: new Set(), js: new Set() }
-        process.deferredAssetsByRoute.set(routeKey, rec)
-    }
-    return rec
-}
+if (!process.deferredAssetsByRoute) process.deferredAssetsByRoute = new Map();
+const routeRecord = routeKey => {
+  let rec = process.deferredAssetsByRoute.get(routeKey);
+  if (!rec) {
+    rec = {
+      css: new Set(),
+      js: new Set()
+    };
+    process.deferredAssetsByRoute.set(routeKey, rec);
+  }
+  return rec;
+};
 
 /** Stable key for caching deferred chunks — uses the matched route pattern (e.g. "/product/:name/:id")
  *  so all pages on the same route share one entry regardless of their actual URL parameters. */
 export const getDeferredRouteKey = (req, allMatches = []) => {
-    return allMatches?.length ? (allMatches[allMatches.length - 1]?.route?.path ?? null) : null
-}
+  return allMatches?.length ? allMatches[allMatches.length - 1]?.route?.path ?? null : null;
+};
 
 /** CSS paths (manifest-relative) previously deferred on this route — for <head> inlining. */
-export const getCachedDeferredCssPathsForRoute = (routeKey) => {
-    if (!routeKey) return []
-    const rec = process.deferredAssetsByRoute.get(routeKey)
-    return rec ? [...rec.css] : []
-}
+export const getCachedDeferredCssPathsForRoute = routeKey => {
+  if (!routeKey) return [];
+  const rec = process.deferredAssetsByRoute.get(routeKey);
+  return rec ? [...rec.css] : [];
+};
 
 /**
  * Record deferred asset paths/URLs for this route. Returns CSS paths not yet on the route so they
@@ -40,22 +46,29 @@ export const getCachedDeferredCssPathsForRoute = (routeKey) => {
  * JS URLs are always emitted in HTML on every navigation — skipping "cached" scripts would omit modules.
  * @returns {{ newCssPaths: string[] }}
  */
-export const registerDeferredAssetsForRoute = (routeKey, { css = [], js = [] } = {}, isBot = false) => {
-    if (!routeKey) return { newCssPaths: [] }
-    const rec = routeRecord(routeKey)
-    const newCssPaths = []
-    for (const p of css) {
-        if (!p) continue
-        if (!rec.css.has(p)) newCssPaths.push(p)
-        rec.css.add(p)
+export const registerDeferredAssetsForRoute = (routeKey, {
+  css = [],
+  js = []
+} = {}, isBot = false) => {
+  if (!routeKey) return {
+    newCssPaths: []
+  };
+  const rec = routeRecord(routeKey);
+  const newCssPaths = [];
+  for (const p of css) {
+    if (!p) continue;
+    if (!rec.css.has(p)) newCssPaths.push(p);
+    rec.css.add(p);
+  }
+  if (!isBot) {
+    for (const url of js) {
+      if (url) rec.js.add(url);
     }
-    if (!isBot) {
-        for (const url of js) {
-            if (url) rec.js.add(url)
-        }
-    }
-    return { newCssPaths }
-}
+  }
+  return {
+    newCssPaths
+  };
+};
 
 /**
  * Cached deferred script URLs for this route, excluding URLs already loaded as critical scripts.
@@ -64,27 +77,24 @@ export const registerDeferredAssetsForRoute = (routeKey, { css = [], js = [] } =
  * @returns {string[]}
  */
 export const getDeferredPreloadScriptUrls = (routeKey, excludeUrls = []) => {
-    if (!routeKey) return []
-    const rec = process.deferredAssetsByRoute.get(routeKey)
-    if (!rec) return []
-    const exclude = new Set(excludeUrls)
-    return [...rec.js].filter((url) => url && !exclude.has(url))
-}
+  if (!routeKey) return [];
+  const rec = process.deferredAssetsByRoute.get(routeKey);
+  if (!rec) return [];
+  const exclude = new Set(excludeUrls);
+  return [...rec.js].filter(url => url && !exclude.has(url));
+};
 
 /**
  * React <link rel="modulepreload"> elements (deduped). Use before matching <script type="module">.
  * @param {string[]} jsUrls
  * @param {string} [keyPrefix] - Unique prefix for React keys when rendering multiple lists.
  */
-export const generateModulePreloadLinkElements = (jsUrls = [], keyPrefix = "modulepreload") =>
-    [...new Set(jsUrls)].map((url, i) =>
-        React.createElement("link", {
-            key: `${keyPrefix}-${i}`,
-            rel: "modulepreload",
-            href: url,
-            fetchPriority: "high",
-        })
-    )
+export const generateModulePreloadLinkElements = (jsUrls = [], keyPrefix = "modulepreload") => [...new Set(jsUrls)].map((url, i) => React.createElement("link", {
+  key: `${keyPrefix}-${i}`,
+  rel: "modulepreload",
+  href: url,
+  fetchPriority: "high"
+}));
 
 /**
  * Read CSS files from disk and return concatenated CSS string for inlining.
@@ -93,58 +103,51 @@ export const generateModulePreloadLinkElements = (jsUrls = [], keyPrefix = "modu
  * @returns {string} Concatenated CSS content.
  */
 export const readCssFromDisk = (cssPaths = [], basePath) => {
-    if (!cssPaths.length) return ""
-
-    const seen = new Set()
-    const chunks = []
-
-    for (const asset of cssPaths) {
-        if (!asset || seen.has(asset)) continue
-        seen.add(asset)
-        if (asset.startsWith("http")) continue
-
-        // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - asset paths come from the Vite build manifest generated at build time, never from a request, so there is no user-controlled input here.
-        const filePath = path.isAbsolute(asset) ? asset : path.join(basePath, asset.replace(/^\/+/, ""))
-
-        try {
-            if (!process.cssFileCache[filePath]) {
-                process.cssFileCache[filePath] = fs.readFileSync(filePath, "utf8")
-            }
-            if (process.cssFileCache[filePath]) {
-                chunks.push(process.cssFileCache[filePath])
-            }
-        } catch {
-            // Silently skip unreadable assets in production
-        }
+  if (!cssPaths.length) return "";
+  const seen = new Set();
+  const chunks = [];
+  for (const asset of cssPaths) {
+    if (!asset || seen.has(asset)) continue;
+    seen.add(asset);
+    if (asset.startsWith("http")) continue;
+
+    // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - asset paths come from the Vite build manifest generated at build time, never from a request, so there is no user-controlled input here.
+    const filePath = path.isAbsolute(asset) ? asset : path.join(basePath, asset.replace(/^\/+/, ""));
+    try {
+      if (!process.cssFileCache[filePath]) {
+        process.cssFileCache[filePath] = fs.readFileSync(filePath, "utf8");
+      }
+      if (process.cssFileCache[filePath]) {
+        chunks.push(process.cssFileCache[filePath]);
+      }
+    } catch {
+      // Silently skip unreadable assets in production
     }
-
-    return chunks.join("\n")
-}
+  }
+  return chunks.join("\n");
+};
 
 // ── React elements (for SSR rendering inside <Head>) ───────────────────
 
 /**
  * <script type="module"> React elements for JS assets.
  */
-export const generateScriptElements = (jsUrls = []) =>
-    [...new Set(jsUrls)].map((url, i) =>
-        React.createElement("script", { key: `js-${i}`, type: "module", src: url })
-    )
+export const generateScriptElements = (jsUrls = []) => [...new Set(jsUrls)].map((url, i) => React.createElement("script", {
+  key: `js-${i}`,
+  type: "module",
+  src: url
+}));
 
 // ── HTML strings (for streaming injection after body via res.write) ────
 
 /**
  * <link rel="stylesheet"> HTML strings for deferred CSS (non-blocking, after body).
  */
-export const generateCssLinkStrings = (cssUrls = []) =>
-    [...new Set(cssUrls)].map((url) => `<link rel="stylesheet" href="${url}">`).join("")
+export const generateCssLinkStrings = (cssUrls = []) => [...new Set(cssUrls)].map(url => `<link rel="stylesheet" href="${url}">`).join("");
 
 /**
  * <link rel="modulepreload"> + <script type="module"> HTML strings.
  */
-export const generateScriptStrings = (jsUrls = []) =>
-    [...new Set(jsUrls)]
-        .map((url) => {
-            return `<script type="module" src="${url}"></script>`
-        })
-        .join("")
+export const generateScriptStrings = (jsUrls = []) => [...new Set(jsUrls)].map(url => {
+  return `<script type="module" src="${url}"></script>`;
+}).join("");

package/dist/server/renderer/handler.d.ts

@@ -0,0 +1,2 @@
+declare const handler: any;
+export default handler;