dinou 6.1.1 → 7.0.0

package/dinou/webpack/helpers/get-webpack-entries.js

@@ -43,7 +43,8 @@ async function getCSSEntries({
     const csss = new Set();
 
     const importNodes = [];
-    traverse.default(ast, {
+    const traverseFn = typeof traverse === "function" ? traverse : (traverse.default || traverse);
+    traverseFn(ast, {
       ImportDeclaration(nodePath) {
         importNodes.push(nodePath);
       },
@@ -144,10 +145,20 @@ async function getCSSEntries({
     absolute: true,
   });
 
+  const serverFiles = new Set();
+
   // Gather client modules and update manifest entries
+  let fileScanCount = 0;
   for (const absPath of files) {
+    if (++fileScanCount % 5 === 0) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
     const code = readFileSync(absPath, "utf8");
-    const isClientModule = useClientRegex.test(code.trim());
+    const trimmed = code.trim();
+    if (useServerRegex.test(trimmed)) {
+      serverFiles.add(path.resolve(absPath).replace(/\\/g, "/").toLowerCase());
+    }
+    const isClientModule = useClientRegex.test(trimmed);
     const normalizedPath = normalizePath(absPath);
 
     if (isClientModule) {
@@ -157,22 +168,6 @@ async function getCSSEntries({
         absPath: normalizedPath,
         name,
       });
-      const { imports } = await getImportsAndAssetsAndCsss(
-        code,
-        absPath,
-        new Set(),
-        true,
-      );
-      const clientComponentRegex = /\.(js|jsx|ts|tsx)$/i;
-      imports.forEach((imp) => {
-        if (clientComponentRegex.test(imp) && !imp.includes("node_modules")) {
-          const name = path.basename(imp, path.extname(imp));
-          detectedClientEntries.add({
-            absPath: normalizePath(imp),
-            name,
-          });
-        }
-      });
     } else if (isPageOrLayout(absPath)) {
       try {
         const { csss } = await getImportsAndAssetsAndCsss(code, absPath);
@@ -205,7 +200,7 @@ async function getCSSEntries({
     dCSSE.outfileName = outfileName;
   }
 
-  return [detectedCSSEntries, detectedClientEntries];
+  return [detectedCSSEntries, detectedClientEntries, serverFiles];
 }
 
 module.exports = getCSSEntries;

package/dinou/webpack/loaders/server-functions-loader.js

@@ -5,13 +5,34 @@ const parseExports = require("../../core/parse-exports.js");
 const { useServerRegex } = require("../../constants.js");
 
 module.exports = function (source) {
+  const options = this.getOptions ? this.getOptions() : {};
+  const norm = path.resolve(this.resourcePath).replace(/\\/g, "/").toLowerCase();
+
+  if (options.serverFiles) {
+    if (!options.serverFiles.has(norm)) {
+      if (!source.includes("use server")) {
+        return source;
+      }
+      if (useServerRegex.test(source)) {
+        options.serverFiles.add(norm);
+      } else {
+        return source;
+      }
+    }
+  }
+
   let hasUseServer = false;
 
   if (useServerRegex.test(source)) {
     hasUseServer = true;
   }
 
-  if (!hasUseServer) return source;
+  if (!hasUseServer) {
+    if (options.serverFiles) {
+      options.serverFiles.delete(norm);
+    }
+    return source;
+  }
 
   const exports = parseExports(source);
   if (exports.length === 0) return source;

package/dinou/webpack/loaders/swc-loader.js

@@ -0,0 +1,76 @@
+// dinou/webpack/loaders/swc-loader.js
+// Ultra-fast SWC transpilation loader for Webpack.
+// Replaces heavy Babel pipeline in development and eliminates multi-second rebuild latencies.
+
+const path = require("path");
+
+let swc = null;
+try {
+  swc = require("@swc/core");
+} catch (e) {
+  // Handled on first invocation
+}
+
+module.exports = function (source, inputSourceMap) {
+  if (this.cacheable) this.cacheable(true);
+
+  if (!swc) {
+    try {
+      swc = require("@swc/core");
+    } catch (e) {
+      throw new Error(
+        "[@swc/core] not found. Please ensure @swc/core is installed to use swc-loader."
+      );
+    }
+  }
+
+  const callback = this.async();
+  const options = this.getOptions ? this.getOptions() : {};
+  const isDev =
+    options.isDevelopment !== undefined
+      ? options.isDevelopment
+      : process.env.NODE_ENV !== "production";
+
+  const resourcePath = this.resourcePath;
+  const isTs = /\.tsx?$/i.test(resourcePath);
+  const isJsx = /\.[jt]sx$/i.test(resourcePath);
+
+  swc
+    .transform(source, {
+      filename: resourcePath,
+      sourceMaps: this.sourceMap ? true : false,
+      inputSourceMap:
+        typeof inputSourceMap === "string"
+          ? inputSourceMap
+          : inputSourceMap
+            ? JSON.stringify(inputSourceMap)
+            : undefined,
+      jsc: {
+        parser: isTs
+          ? { syntax: "typescript", tsx: isJsx, dynamicImport: true }
+          : { syntax: "ecmascript", jsx: true, dynamicImport: true },
+        target: "es2022",
+        transform: {
+          react: {
+            runtime: "automatic",
+            development: isDev,
+            refresh: false,
+          },
+        },
+      },
+    })
+    .then((output) => {
+      let map = undefined;
+      if (output.map) {
+        try {
+          map = JSON.parse(output.map);
+        } catch (e) {
+          map = output.map;
+        }
+      }
+      callback(null, output.code, map);
+    })
+    .catch((err) => {
+      callback(err);
+    });
+};

package/dinou/webpack/plugins/manifest-generator-plugin.js

@@ -17,6 +17,7 @@ class ManifestGeneratorPlugin {
           stage: Compilation.PROCESS_ASSETS_STAGE_ANALYSE,
         },
         (assets) => {
+          this.manifestData = {};
           // Traverse chunks to generate manifest
           for (const chunk of compilation.chunks) {
             if (!chunk.name) continue; // only chunks with a name

package/dinou/webpack/plugins/server-functions-plugin.js

@@ -1,3 +1,4 @@
+const path = require("path");
 const manifestGeneratorPlugin = require("./manifest-generator-plugin");
 
 class WebpackServerFunctionsPluginSimple {
@@ -19,25 +20,9 @@ class WebpackServerFunctionsPluginSimple {
             stage: Compilation.PROCESS_ASSETS_STAGE_REPORT,
           },
           (assets) => {
-            // 1. Replace placeholder
-            const manifest = manifestGeneratorPlugin.manifestData;
-            const hashedPath = manifest["serverFunctionProxy.js"] || "serverFunctionProxy.js";
-
-            for (const [filename, asset] of Object.entries(assets)) {
-              if (filename.endsWith(".js")) {
-                let code = asset.source();
-                if (code.includes("__SERVER_FUNCTION_PROXY__")) {
-                  code = code.replace(/__SERVER_FUNCTION_PROXY__/g, hashedPath);
-                  compilation.updateAsset(
-                    filename,
-                    new sources.RawSource(code)
-                  );
-                }
-              }
-            }
-
-            // 2. Collect all server function files
+            // 1. Collect all server function files generated by loader
             const serverFunctionsManifest = {};
+            const serverFunctionPaths = new Set();
 
             for (const [filename, asset] of Object.entries(assets)) {
               if (
@@ -48,6 +33,9 @@ class WebpackServerFunctionsPluginSimple {
                   const content = asset.source();
                   const entry = JSON.parse(content);
                   serverFunctionsManifest[entry.path] = entry.exports;
+                  serverFunctionPaths.add(
+                    path.resolve(process.cwd(), entry.path).replace(/\\/g, "/").toLowerCase()
+                  );
 
                   // Delete this temporary file
                   delete assets[filename];
@@ -57,7 +45,7 @@ class WebpackServerFunctionsPluginSimple {
               }
             }
 
-            // 3. Generate final manifest
+            // 2. Generate final manifest
             const manifestContent = JSON.stringify(
               serverFunctionsManifest,
               null,
@@ -67,6 +55,74 @@ class WebpackServerFunctionsPluginSimple {
               "server-functions-manifest.json",
               new sources.RawSource(manifestContent)
             );
+
+            // 3. If no server functions exist in this compilation, do not touch any assets
+            if (serverFunctionPaths.size === 0) {
+              return;
+            }
+
+            // 4. Identify ONLY chunks that actually bundle a server function module
+            const targetAssetFiles = new Set();
+
+            for (const chunk of compilation.chunks) {
+              let chunkModules = [];
+              try {
+                chunkModules = compilation.chunkGraph
+                  ? compilation.chunkGraph.getChunkModules(chunk)
+                  : (chunk.getModules ? chunk.getModules() : []);
+              } catch (e) {
+                chunkModules = [];
+              }
+
+              let containsServerFunction = false;
+              for (const mod of chunkModules) {
+                if (mod.resource) {
+                  const norm = path.resolve(mod.resource).replace(/\\/g, "/").toLowerCase();
+                  if (serverFunctionPaths.has(norm)) {
+                    containsServerFunction = true;
+                    break;
+                  }
+                }
+                if (mod.modules) {
+                  for (const sub of mod.modules) {
+                    if (sub.resource) {
+                      const normSub = path.resolve(sub.resource).replace(/\\/g, "/").toLowerCase();
+                      if (serverFunctionPaths.has(normSub)) {
+                        containsServerFunction = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+                if (containsServerFunction) break;
+              }
+
+              if (containsServerFunction) {
+                for (const file of chunk.files) {
+                  targetAssetFiles.add(file);
+                }
+              }
+            }
+
+            // 5. Replace placeholder ONLY in chunks that actually contain server functions
+            const manifest = manifestGeneratorPlugin.manifestData;
+            const hashedPath = manifest["serverFunctionProxy.js"] || "serverFunctionProxy.js";
+
+            for (const filename of targetAssetFiles) {
+              if (filename.endsWith(".js") && assets[filename]) {
+                let code = assets[filename].source();
+                if (typeof code !== "string") {
+                  code = code.toString("utf8");
+                }
+                if (code.includes("__SERVER_FUNCTION_PROXY__")) {
+                  code = code.replace(/__SERVER_FUNCTION_PROXY__/g, hashedPath);
+                  compilation.updateAsset(
+                    filename,
+                    new sources.RawSource(code)
+                  );
+                }
+              }
+            }
           }
         );
       }

package/dinou/webpack/plugins/webpack-memory-plugin.js

@@ -0,0 +1,66 @@
+// dinou/webpack/plugins/webpack-memory-plugin.js
+// Captures Webpack client assets, chunks, manifests, and sourcemaps in memory (globalThis.__DINOU_MEM_FILES__)
+// and sets global raw manifests in dev mode to prevent massive disk writes.
+
+const path = require("path");
+
+class WebpackMemoryPlugin {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  apply(compiler) {
+    const isDev =
+      process.env.NODE_ENV !== "production" ||
+      process.env.DINOU_DEV === "true";
+
+    // Only acts in development mode. In production, Webpack writes to .dinou/dist3 normally.
+    if (!isDev) {
+      return;
+    }
+
+    const pluginName = "WebpackMemoryPlugin";
+
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+      compilation.hooks.afterProcessAssets.tap(pluginName, (assets) => {
+        if (typeof globalThis !== "undefined") {
+          if (!globalThis.__DINOU_MEM_FILES__) {
+            globalThis.__DINOU_MEM_FILES__ = new Map();
+          }
+        }
+
+        for (const [filename, asset] of Object.entries(assets)) {
+          if (!asset) continue;
+
+          const normKey = filename.replace(/\\/g, "/");
+          const cleanKey = normKey.replace(/^\/+/, "");
+          const raw = typeof asset.source === "function" ? asset.source() : asset;
+          const buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw || "");
+
+          if (typeof globalThis !== "undefined" && globalThis.__DINOU_MEM_FILES__) {
+            globalThis.__DINOU_MEM_FILES__.set(cleanKey, buf);
+            globalThis.__DINOU_MEM_FILES__.set("/" + cleanKey, buf);
+            const base = path.basename(cleanKey);
+            globalThis.__DINOU_MEM_FILES__.set(base, buf);
+          }
+
+          if (cleanKey === "react-client-manifest.json") {
+            try {
+              globalThis.__DINOU_RAW_CLIENT_MANIFEST__ = JSON.parse(buf.toString("utf8"));
+            } catch (e) {}
+          } else if (cleanKey === "server-functions-manifest.json") {
+            try {
+              globalThis.__DINOU_RAW_SERVER_FUNCTIONS_MANIFEST__ = JSON.parse(buf.toString("utf8"));
+            } catch (e) {}
+          } else if (cleanKey === "manifest.json") {
+            try {
+              globalThis.__DINOU_RAW_ASSET_MANIFEST__ = JSON.parse(buf.toString("utf8"));
+            } catch (e) {}
+          }
+        }
+      });
+    });
+  }
+}
+
+module.exports = WebpackMemoryPlugin;