dinou 6.1.1 → 7.1.0

package/dinou/core/generate-static-rsc.js

@@ -3,26 +3,39 @@ const path = require("path");
 const { PassThrough } = require("stream");
 const url = require("url");
 const getJSX = require("./get-jsx.js");
-const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
-const { renderToPipeableStream } = isWebpack
-  ? require("react-server-dom-webpack/server")
-  : require("@roggc/react-server-dom-esm/server");
+let _renderToPipeableStream = null;
+function getRenderToPipeableStream() {
+  if (!_renderToPipeableStream) {
+    const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+    const mod = isWebpack
+      ? require("react-server-dom-webpack/server")
+      : require("@roggc/react-server-dom-esm/server");
+    _renderToPipeableStream = mod.renderToPipeableStream;
+  }
+  return _renderToPipeableStream;
+}
 const { requestStorage } = require("./request-context.js");
 
 const OUT_DIR = path.resolve(".dinou/dist2");
-// const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
-async function generateStaticRSC(reqPath) {
+async function generateStaticRSC(reqPath, options = {}) {
   const finalReqPath = reqPath.endsWith("/") ? reqPath : reqPath + "/";
+  const segment = options.segment || "page";
+  const fileName = segment === "layout" ? "layout.rsc" : "page.rsc";
 
-  const payloadPath = path.join(OUT_DIR, finalReqPath, "rsc.rsc");
-  const tempPayloadPath = path.join(OUT_DIR, finalReqPath, `rsc.rsc.${Date.now()}-${Math.random()}.tmp`);
+  const payloadPath = path.join(OUT_DIR, finalReqPath, fileName);
+  const tempPayloadPath = path.join(
+    OUT_DIR,
+    finalReqPath,
+    `${fileName}.${Date.now()}-${Math.random()}.tmp`
+  );
 
   // 👇 2. MOCK RES (Complete and Robust Version)
   const mockRes = {
     _statusCode: 200,
     _headers: {},
-    _redirectUrl: null, // ✅ We recover this property
+    _redirectUrl: null,
     _cookies: [],
 
     cookie(name, value, options) {
@@ -41,12 +54,10 @@ async function generateStaticRSC(reqPath) {
       this._statusCode = code;
     },
 
-    // ✅ YOUR ORIGINAL LOGIC (The correct one)
     redirect(arg1, arg2) {
       let status = 302;
       let url = "";
 
-      // Overload handling: redirect(url) vs redirect(status, url)
       if (typeof arg1 === "number") {
         status = arg1;
         url = arg2;
@@ -97,7 +108,11 @@ async function generateStaticRSC(reqPath) {
     const passThrough = new PassThrough();
 
     await requestStorage.run(mockContext, async () => {
-      const jsx = await getJSX(finalReqPath, {}, null, false);
+      const jsx = await getJSX(finalReqPath, {}, null, false, false, {
+        segment,
+        layoutPath: options.layoutPath,
+      });
+      const renderToPipeableStream = getRenderToPipeableStream();
       const { pipe } = isWebpack
         ? renderToPipeableStream(jsx, manifest)
         : renderToPipeableStream(jsx, url.pathToFileURL(process.cwd()).href + "/");
@@ -111,23 +126,40 @@ async function generateStaticRSC(reqPath) {
       });
     });
 
-    // 3. RETURN RESULT (We DO NOT rename here)
+    // 3. RETURN RESULT (We DO NOT rename here, atomic rename handled by caller)
     const success = mockRes._statusCode !== 500;
 
     return {
       success,
       type: "rsc",
+      segment,
+      fileName,
       reqPath: finalReqPath,
       tempPath: tempPayloadPath,
       finalPath: payloadPath,
       status: mockRes._statusCode,
     };
   } catch (error) {
-    console.error("❌ Error generating RSC payload:", error);
+    console.error(`❌ Error generating ${fileName} payload:`, error);
     // Emergency cleanup
     if (fs.existsSync(tempPayloadPath)) fs.unlinkSync(tempPayloadPath);
-    return { success: false, tempPath: tempPayloadPath };
+    return { success: false, segment, fileName, tempPath: tempPayloadPath };
   }
 }
 
+async function generateStaticPageRSC(reqPath, options = {}) {
+  return generateStaticRSC(reqPath, { ...options, segment: "page" });
+}
+
+async function generateStaticLayoutRSC(layoutFolderPath, layoutFilePath, options = {}) {
+  return generateStaticRSC(layoutFolderPath, {
+    ...options,
+    segment: "layout",
+    layoutPath: layoutFilePath,
+  });
+}
+
 module.exports = generateStaticRSC;
+module.exports.generateStaticRSC = generateStaticRSC;
+module.exports.generateStaticPageRSC = generateStaticPageRSC;
+module.exports.generateStaticLayoutRSC = generateStaticLayoutRSC;

package/dinou/core/generate-static.js

@@ -1,22 +1,224 @@
+// dinou/core/generate-static.js
+// Unified Static Site Generation runner using the in-memory Dual-Bundle Engine.
+// Guarantees 100% parity with runtime Incremental Static Generation (ISG).
+
 const path = require("path");
-const { existsSync, rmSync } = require("fs");
-const generateStaticRSCs = require("./generate-static-rscs");
-const generateStaticPages = require("./generate-static-pages");
-const { buildStaticPages, getStaticPaths } = require("./build-static-pages");
+const { existsSync, rmSync, mkdirSync, renameSync } = require("fs");
+const { pathToFileURL } = require("url");
+const { setStorageAdapter, FileSystemStorage } = require("./storage-adapter.js");
+const {
+  generateStaticPageRSC,
+  generateStaticLayoutRSC,
+} = require("./generate-static-rsc.js");
 
 async function generateStatic() {
   const distFolder2 = path.resolve(process.cwd(), ".dinou/dist2");
 
   if (existsSync(distFolder2)) {
     rmSync(distFolder2, { recursive: true, force: true });
-    console.log("Deleted existing .dinou/dist2 folder");
   }
 
-  await buildStaticPages();
-  const routes = getStaticPaths();
-  console.log("Static paths:", routes);
-  await generateStaticRSCs(routes);
-  await generateStaticPages(routes);
+  const { updateBuildProgress, clearBuildProgress, isTTY } = await import(
+    "../node/terminal-status.mjs"
+  );
+
+  // 1. Compile or ensure Dual-Bundle engines (Pass A & Pass B)
+  updateBuildProgress("[SSG] Compiling Dual-Engine for static generation...");
+  const { bundleDualEngine } = await import("../node/bundle-dual-engine.mjs");
+  const { rscEnginePath, ssrEnginePath } = await bundleDualEngine({
+    isDev: false,
+    projectRoot: process.cwd(),
+    outDir: ".dinou/node",
+  });
+
+  // 2. Initialize FileSystemStorage for writing .dinou/dist2
+  const storage = new FileSystemStorage(distFolder2);
+  setStorageAdapter(storage);
+
+  // 3. Load compiled engines
+  const rscModule = await import(pathToFileURL(rscEnginePath).href);
+  const ssrModule = await import(pathToFileURL(ssrEnginePath).href);
+
+  // 4. Discover static routes and layouts
+  updateBuildProgress("[SSG] Discovering static routes and layouts...");
+  await rscModule.buildStaticPages((info) => {
+    if (info.phase === "discovering") {
+      updateBuildProgress(
+        `[SSG] (${info.current}/${info.total}) Discovering: ${info.route}`
+      );
+    } else if (info.phase === "crawling") {
+      updateBuildProgress(`[SSG] Crawling: ${info.route}`);
+    }
+  });
+
+  const routes = rscModule.getStaticPaths();
+  const layouts =
+    typeof rscModule.getStaticLayouts === "function"
+      ? rscModule.getStaticLayouts()
+      : [];
+
+  // 4b. Pre-render all static layout segments (layout.rsc)
+  if (layouts.length > 0) {
+    if (!isTTY) {
+      console.log(`⚡ [SSG] Pre-rendering ${layouts.length} static layout(s)...`);
+    }
+    for (const layoutInfo of layouts) {
+      const layoutReqPath = layoutInfo.routePath.startsWith("/")
+        ? layoutInfo.routePath
+        : "/" + layoutInfo.routePath;
+      updateBuildProgress(`[SSG] Compiling layout: ${layoutReqPath}`);
+      try {
+        const layoutReq = new Request(`http://localhost/____rsc_layout____${layoutReqPath}`);
+        const layoutRes = await rscModule.handleRequest(layoutReq, {
+          runtime: "node-bundle",
+        });
+        if (layoutRes.status === 200) {
+          const layoutRscText = await layoutRes.text();
+          const cleanLayoutPath = layoutReqPath.replace(/^\/+/, "").replace(/\/+$/, "");
+          const layoutRscKey = cleanLayoutPath ? `${cleanLayoutPath}/layout.rsc` : "layout.rsc";
+
+          let layoutMeta = {
+            status: 200,
+            generatedAt: Date.now(),
+            revalidate: undefined,
+            tags: [],
+          };
+          try {
+            const { resolveLayoutFunctionsConfig } = require("./layout-functions.js");
+            const layoutConfig = await resolveLayoutFunctionsConfig(
+              layoutInfo.layoutPath,
+              layoutInfo.params || {}
+            );
+            layoutMeta.revalidate = layoutConfig.revalidate;
+            layoutMeta.tags = layoutConfig.tags || [];
+          } catch (e) {}
+
+          await storage.set(layoutRscKey, layoutRscText, layoutMeta);
+        } else {
+          const layoutResult = await generateStaticLayoutRSC(
+            layoutReqPath,
+            layoutInfo.layoutPath
+          );
+          if (
+            layoutResult &&
+            layoutResult.tempPath &&
+            layoutResult.finalPath &&
+            existsSync(layoutResult.tempPath)
+          ) {
+            mkdirSync(path.dirname(layoutResult.finalPath), { recursive: true });
+            renameSync(layoutResult.tempPath, layoutResult.finalPath);
+          }
+        }
+      } catch (layoutErr) {
+        console.error(
+          `❌ [SSG] Error compiling layout ${layoutReqPath}:`,
+          layoutErr
+        );
+      }
+    }
+  }
+
+  if (!isTTY) {
+    console.log(
+      `⚡ [SSG] Pre-rendering ${routes.length} static route(s) with in-memory Dual-Engine...`
+    );
+  }
+
+  // 5. Pre-render all routes using Dual-Bundle engine (index.html + page.rsc)
+  let renderedCount = 0;
+  let currentIndex = 0;
+  for (const route of routes) {
+    currentIndex++;
+    const reqPath = route.startsWith("/") ? route : "/" + route;
+    updateBuildProgress(
+      `[SSG] (${currentIndex}/${routes.length}) Pre-rendering: ${reqPath}`
+    );
+    try {
+      // A. Pre-render full HTML (index.html) and metadata (metadata.json)
+      const webReq = new Request(`http://localhost${reqPath}`);
+      const res = await rscModule.handleRequest(webReq, {
+        runtime: "node-bundle",
+        renderHtmlStream: ssrModule.renderHtml,
+        isSSG: true,
+      });
+
+      const routeMeta = typeof rscModule.getStaticMetadata === "function" ? rscModule.getStaticMetadata(reqPath) : null;
+      const isRoutePpr = Boolean(routeMeta?.ppr);
+      const cleanPagePath = reqPath.replace(/^\/+/, "").replace(/\/+$/, "");
+
+      if (res.status === 200) {
+        renderedCount++;
+        if (isRoutePpr) {
+          const indexHtmlKey = cleanPagePath ? `${cleanPagePath}/index.html` : "index.html";
+          const shellHtmlKey = cleanPagePath ? `${cleanPagePath}/shell.html` : "shell.html";
+          const metaKey = cleanPagePath ? `${cleanPagePath}/metadata.json` : "metadata.json";
+
+          const htmlItem = await storage.get(indexHtmlKey);
+          if (htmlItem) {
+            await storage.set(shellHtmlKey, htmlItem.content, { ...(htmlItem.metadata || {}), ppr: true, holes: routeMeta.holes || [] });
+          }
+          const metaItem = await storage.get(metaKey);
+          let metaObj = {};
+          try {
+            metaObj = metaItem ? JSON.parse(metaItem.content || "{}") : {};
+          } catch (e) {}
+          metaObj.ppr = true;
+          metaObj.holes = routeMeta.holes || [];
+          await storage.set(metaKey, JSON.stringify(metaObj));
+        }
+      } else {
+        if (process.env.DINOU_DEBUG) {
+          console.warn(`⚠️ [SSG] Route ${reqPath} returned status ${res.status}`);
+        }
+      }
+
+      // B. Pre-render isolated page RSC segment (page.rsc)
+      try {
+        const pageReq = new Request(`http://localhost/____rsc_page____${reqPath}`);
+        const pageRes = await rscModule.handleRequest(pageReq, {
+          runtime: "node-bundle",
+        });
+        if (pageRes.status === 200) {
+          const pageRscText = await pageRes.text();
+          const pageRscKey = cleanPagePath ? `${cleanPagePath}/page.rsc` : "page.rsc";
+          await storage.set(pageRscKey, pageRscText);
+          if (isRoutePpr) {
+            const shellRscKey = cleanPagePath ? `${cleanPagePath}/shell.rsc` : "shell.rsc";
+            await storage.set(shellRscKey, pageRscText, { ppr: true });
+          }
+        } else {
+          const pageResult = await generateStaticPageRSC(reqPath);
+          if (
+            pageResult &&
+            pageResult.tempPath &&
+            pageResult.finalPath &&
+            existsSync(pageResult.tempPath)
+          ) {
+            mkdirSync(path.dirname(pageResult.finalPath), { recursive: true });
+            renameSync(pageResult.tempPath, pageResult.finalPath);
+          }
+        }
+      } catch (pageErr) {
+        const pageResult = await generateStaticPageRSC(reqPath);
+        if (
+          pageResult &&
+          pageResult.tempPath &&
+          pageResult.finalPath &&
+          existsSync(pageResult.tempPath)
+        ) {
+          mkdirSync(path.dirname(pageResult.finalPath), { recursive: true });
+          renameSync(pageResult.tempPath, pageResult.finalPath);
+        }
+      }
+    } catch (err) {
+      console.error(`❌ [SSG] Error pre-rendering ${reqPath}:`, err);
+    }
+  }
+
+  clearBuildProgress();
+  console.log(
+    `✓ [SSG] Pre-rendered ${renderedCount} page(s) and ${layouts.length} layout(s) to .dinou/dist2`
+  );
 }
 
 module.exports = generateStatic;

package/dinou/core/generating-isg.js

@@ -18,6 +18,11 @@ function generatingISG(reqPath, isDynamicFromServer) {
         path.join(dist2Folder, reqPath, "index.html"),
         path.join(dist2Folder, reqPath, "index._old.html")
       );
+    if (existsSync(path.join(dist2Folder, reqPath, "page.rsc")))
+      copyFileSync(
+        path.join(dist2Folder, reqPath, "page.rsc"),
+        path.join(dist2Folder, reqPath, "page._old.rsc")
+      );
     if (existsSync(path.join(dist2Folder, reqPath, "rsc.rsc")))
       copyFileSync(
         path.join(dist2Folder, reqPath, "rsc.rsc"),

package/dinou/core/get-asset-from-manifest.js

@@ -6,17 +6,23 @@ let read = false;
 const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
 function getAssetFromManifest(name) {
-  if (process.env.NODE_ENV === "production" && !read) {
+  if (typeof globalThis !== "undefined" && globalThis.__DINOU_ASSET_MANIFEST__) {
+    return "/" + (globalThis.__DINOU_ASSET_MANIFEST__[name] || name);
+  }
+  const isDev =
+    process.env.DINOU_DEV === "true" ||
+    (typeof globalThis !== "undefined" && Boolean(globalThis.__DINOU_DEV__));
+  if (process.env.NODE_ENV === "production" && !isDev && !read) {
     const manifestPath = path.resolve(process.cwd(), ".dinou/dist3/manifest.json");
     if (fs.existsSync(manifestPath)) {
       manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
       read = true;
     }
-  } else if (isWebpack && !read) {
+  } else if ((isWebpack || isDev) && !read) {
     const manifestPath = path.resolve(process.cwd(), ".dinou/public/manifest.json");
     if (fs.existsSync(manifestPath)) {
       manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-      read = true;
+      if (!isDev) read = true;
     }
   }
   return "/" + (manifest[name] || name);