dinou 6.1.0 → 7.0.0

package/dinou/esbuild/plugins-esbuild/react-client-manifest-plugin.mjs

@@ -9,14 +9,30 @@ import { useClientRegex } from "../../constants.js";
 export default function reactClientManifestPlugin({
   manifestPath = ".dinou/react_client_manifest/react-client-manifest.json",
   manifest = {},
+  onManifestUpdated,
 } = {}) {
   return {
     name: "react-client-manifest",
     setup(build) {
+      let lastSerialized = "";
       build.onEnd(async (result) => {
+        const tRcm0 = Date.now();
+        let manifestChanged = false;
         try {
           const meta = result.metafile;
           if (meta && meta.outputs) {
+            // Group manifest keys by base file URL for O(1) matching (case-insensitive for Windows)
+            const manifestPrefixMap = new Map();
+            for (const key of Object.keys(manifest)) {
+              const base = key.split("#")[0].toLowerCase();
+              let list = manifestPrefixMap.get(base);
+              if (!list) {
+                list = [];
+                manifestPrefixMap.set(base, list);
+              }
+              list.push(key);
+            }
+
             for (const [outFile, outInfo] of Object.entries(meta.outputs)) {
               const fileName = outFile.replace(/\\/g, "/").split(/[/\\]/).pop();
               const outUrl = "/" + fileName;
@@ -25,39 +41,62 @@ export default function reactClientManifestPlugin({
                 continue;
               }
               const absModulePath = path.resolve(modulePath);
-              const baseFileUrl = pathToFileURL(absModulePath).href;
-              const code = readFileSync(absModulePath, "utf8");
-              const isClientModule = useClientRegex.test(code.trim());
-              if (!isClientModule) {
-                // console.log(
-                //   `[react-client-manifest]   Skipping non-client module: ${baseFileUrl}`
-                // );
-                continue;
+              let baseFileUrl = pathToFileURL(absModulePath).href;
+
+              // If entry point was loaded from .dinou/swc, map to original file URL
+              if (absModulePath.includes(".dinou/swc") || absModulePath.includes(".dinou\\swc")) {
+                const norm = absModulePath.replace(/\\/g, "/");
+                const rel = norm.replace(/^.*\.dinou\/swc\//, "");
+                const base = path.resolve(process.cwd(), rel.replace(/\.js$/, ""));
+                for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
+                  const candidate = base + ext;
+                  const candidateUrl = pathToFileURL(candidate).href;
+                  if (manifestPrefixMap.has(candidateUrl.toLowerCase())) {
+                    baseFileUrl = candidateUrl;
+                    break;
+                  }
+                }
               }
-              const exports = parseExports(code);
-              for (const expName of exports) {
-                const manifestKey =
-                  expName === "default"
-                    ? baseFileUrl
-                    : `${baseFileUrl}#${expName}`;
-                if (manifest[manifestKey]) {
-                  manifest[manifestKey].id = outUrl;
+
+              const relatedKeys = manifestPrefixMap.get(baseFileUrl.toLowerCase());
+              if (relatedKeys) {
+                for (const key of relatedKeys) {
+                  manifest[key].id = outUrl;
                 }
               }
             }
           }
 
-          // Ensure directory exists
-          await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+          // Write merged manifest only if changed
+          const serialized = JSON.stringify(manifest, null, 2);
+          if (typeof globalThis !== "undefined") {
+            globalThis.__DINOU_RAW_CLIENT_MANIFEST__ = { ...manifest };
+          }
+
+          const isDev = process.env.DINOU_DEV === "true" || process.env.NODE_ENV === "development";
+          const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true" || !isDev;
+
+          if (lastSerialized !== serialized) {
+            manifestChanged = true;
+            lastSerialized = serialized;
+          }
 
-          // Write merged manifest
-          await fs.writeFile(
-            manifestPath,
-            JSON.stringify(manifest, null, 2),
-            "utf8"
-          );
+          if (shouldWriteToDisk && manifestChanged) {
+            await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+            await fs.writeFile(
+              manifestPath,
+              serialized,
+              "utf8"
+            );
+          }
         } catch (err) {
           console.warn("[react-client-manifest] onEnd error:", err.message);
+        } finally {
+          globalThis.__DINOU_RCM_TIME__ = Date.now() - tRcm0;
+        }
+
+        if (manifestChanged && onManifestUpdated) {
+          await onManifestUpdated();
         }
       });
     }, // end setup

package/dinou/esbuild/plugins-esbuild/server-functions-plugin.mjs

@@ -3,88 +3,209 @@ import fs from "node:fs/promises";
 import parseExports from "../../core/parse-exports.js";
 import { useServerRegex } from "../../constants.js";
 
-export default function serverFunctionsPlugin(manifestData = {}) {
+export default function serverFunctionsPlugin(manifestData = {}, options = {}) {
+  const opts =
+    typeof manifestData === "object" && manifestData !== null && ("onManifestUpdated" in manifestData || "serverFiles" in manifestData)
+      ? manifestData
+      : options;
+  const manifestMap = opts.manifestData || (manifestData.onManifestUpdated ? {} : manifestData) || {};
+  const onManifestUpdated = opts.onManifestUpdated;
+  const serverFiles = opts.serverFiles || manifestData.serverFiles || options.serverFiles || null;
+  const normalizeNormPath = (p) => {
+    let s = path.resolve(p).replace(/\\/g, "/");
+    if (process.platform === "win32") {
+      s = s.replace(/^([a-zA-Z]):/, (_, d) => d.toLowerCase() + ":");
+    }
+    return s;
+  };
+  const serverFilesSet = serverFiles
+    ? new Set(Array.from(serverFiles).map((f) => normalizeNormPath(f)))
+    : null;
+
   return {
     name: "server-functions-proxy",
     setup(build) {
+      if (serverFilesSet && serverFilesSet.size === 0) {
+        return;
+      }
+      const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const sfFilter = serverFilesSet && serverFilesSet.size > 0
+        ? new RegExp(Array.from(serverFilesSet).map((f) => escapeRegExp(path.basename(f))).join("|"))
+        : /\.[jt]sx?$/;
       const root = process.cwd();
       const serverFunctions = new Map(); // Collect server functions here: Map<relativePath, Set<exports>>
+      const sfCache = new Map(); // Cache by path: { mtimeMs, isServer, relativePath, exportsSet, proxyCode }
+      let sfTime = 0;
+      let sfCount = 0;
+
+      build.onStart(() => {
+        sfTime = 0;
+        sfCount = 0;
+      });
 
       // 1. TRANSFORM FILES DURING BUILD
-      build.onLoad({ filter: /\.[jt]sx?$/ }, async (args) => {
-        const code = await fs.readFile(args.path, "utf8");
+      build.onLoad({ filter: sfFilter }, async (args) => {
+        const normPath = args.path.replace(/\\/g, "/");
+        if (normPath.includes("/node_modules/") || normPath.includes("/.dinou/")) return null;
+
+        if (serverFilesSet) {
+          const absNorm = normalizeNormPath(args.path);
+          if (!serverFilesSet.has(absNorm)) {
+            return null;
+          }
+        }
+
+        const t0 = Date.now();
+        try {
+          let stat;
+          try {
+            stat = await fs.stat(args.path);
+          } catch (e) {
+            return null;
+          }
+
+          const cached = sfCache.get(args.path);
+          if (cached && cached.mtimeMs === stat.mtimeMs) {
+            if (!cached.isServer) return null;
+            serverFunctions.set(cached.relativePath, cached.exportsSet);
+            return { contents: cached.proxyCode, loader: "js", watchFiles: [args.path] };
+          }
+
+          const code = await fs.readFile(args.path, "utf8");
 
-        if (!useServerRegex.test(code.trim())) return null;
+          if (!useServerRegex.test(code.trim())) {
+            sfCache.set(args.path, { mtimeMs: stat.mtimeMs, isServer: false });
+            return null;
+          }
 
-        const exports = parseExports(code);
-        if (exports.length === 0) return null;
+          const exports = parseExports(code);
+          if (exports.length === 0) {
+            sfCache.set(args.path, { mtimeMs: stat.mtimeMs, isServer: false });
+            return null;
+          }
 
-        const relativePath = path.relative(root, args.path).replace(/\\/g, "/");
-        serverFunctions.set(relativePath, new Set(exports)); // Save exports as a Set to guarantee uniqueness
+          const relativePath = path.relative(root, args.path).replace(/\\/g, "/");
+          const exportsSet = new Set(exports);
+          serverFunctions.set(relativePath, exportsSet); // Save exports as a Set to guarantee uniqueness
 
-        const fileUrl = `file:///${relativePath}`;
+          const fileUrl = `file:///${relativePath}`;
 
-        // Generate proxy code that forwards calls to the server instead of executing the actual code
-        let proxyCode = `
-          import { createServerFunctionProxy } from "/__SERVER_FUNCTION_PROXY__";
-        `;
+          // Generate proxy code that forwards calls to the server instead of executing the actual code
+          let proxyCode = `
+            import { createServerFunctionProxy } from "/__SERVER_FUNCTION_PROXY__";
+          `;
 
-        for (const exp of exports) {
-          const key =
-            exp === "default" ? `${fileUrl}#default` : `${fileUrl}#${exp}`;
+          for (const exp of exports) {
+            const key =
+              exp === "default" ? `${fileUrl}#default` : `${fileUrl}#${exp}`;
 
-          if (exp === "default") {
-            proxyCode += `export default createServerFunctionProxy(${JSON.stringify(
-              key
-            )});\n`;
-          } else {
-            proxyCode += `export const ${exp} = createServerFunctionProxy(${JSON.stringify(
-              key
-            )});\n`;
+            if (exp === "default") {
+              proxyCode += `export default createServerFunctionProxy(${JSON.stringify(
+                key
+              )});\n`;
+            } else {
+              proxyCode += `export const ${exp} = createServerFunctionProxy(${JSON.stringify(
+                key
+              )});\n`;
+            }
           }
-        }
 
-        return {
-          contents: proxyCode,
-          loader: "js",
-        };
+          sfCache.set(args.path, {
+            mtimeMs: stat.mtimeMs,
+            isServer: true,
+            relativePath,
+            exportsSet,
+            proxyCode,
+          });
+
+          return {
+            contents: proxyCode,
+            loader: "js",
+            watchFiles: [args.path],
+          };
+        } finally {
+          sfTime += Date.now() - t0;
+          sfCount++;
+          globalThis.__DINOU_SF_TIME__ = sfTime;
+          globalThis.__DINOU_SF_COUNT__ = sfCount;
+        }
       });
 
       // 2. REPLACE PLACEHOLDER AND GENERATE MANIFEST AFTER BUILD
       build.onEnd(async (result) => {
-        const hashedProxy =
+        const tEnd0 = Date.now();
+        try {
+          if (serverFunctions.size === 0) {
+            if (typeof globalThis !== "undefined") {
+              globalThis.__DINOU_RAW_SERVER_FUNCTIONS_MANIFEST__ = {};
+            }
+            return;
+          }
+          const hashedProxy =
           "/" +
-          (manifestData["serverFunctionProxy.js"] || "serverFunctionProxy.js");
+          (manifestMap["serverFunctionProxy.js"] || "serverFunctionProxy.js");
 
-        for (const outputFile of Object.values(result.outputFiles)) {
-          const fileCode = new TextDecoder().decode(outputFile.contents);
+          const serverFnNormalized = new Set();
+          for (const relPath of serverFunctions.keys()) {
+            serverFnNormalized.add(path.resolve(root, relPath).replace(/\\/g, "/").toLowerCase());
+          }
 
-          if (!fileCode) continue;
-          if (fileCode.includes("/__SERVER_FUNCTION_PROXY__")) {
-            const newCode = fileCode.replace(
-              /\/__SERVER_FUNCTION_PROXY__/g,
-              hashedProxy
-            );
-            outputFile.contents = new TextEncoder().encode(newCode);
+          let targetOutputFiles = Object.values(result.outputFiles || {});
+          if (result.metafile && result.metafile.outputs) {
+            const allowedOutputs = new Set();
+            for (const [outPath, outMeta] of Object.entries(result.metafile.outputs)) {
+              const hasSf = Object.keys(outMeta.inputs || {}).some((inPath) => {
+                const norm = path.resolve(root, inPath).replace(/\\/g, "/").toLowerCase();
+                return serverFnNormalized.has(norm);
+              });
+              if (hasSf) {
+                allowedOutputs.add(path.resolve(root, outPath).replace(/\\/g, "/").toLowerCase());
+              }
+            }
+            targetOutputFiles = targetOutputFiles.filter((outputFile) => {
+              const norm = path.resolve(outputFile.path).replace(/\\/g, "/").toLowerCase();
+              return allowedOutputs.has(norm);
+            });
           }
-        }
 
-        // Generate the final manifest by converting the Map to a plain object
-        const manifestObj = {};
-        for (const [path, exportsSet] of serverFunctions.entries()) {
-          manifestObj[path] = Array.from(exportsSet);
-        }
+          for (const outputFile of targetOutputFiles) {
+            const fileCode = new TextDecoder().decode(outputFile.contents);
+
+            if (!fileCode) continue;
+            if (fileCode.includes("/__SERVER_FUNCTION_PROXY__")) {
+              const newCode = fileCode.replace(
+                /\/__SERVER_FUNCTION_PROXY__/g,
+                hashedProxy
+              );
+              outputFile.contents = new TextEncoder().encode(newCode);
+            }
+          }
 
-        // Write the server functions manifest JSON file to the output directory
-        const manifestPath = path.join(
-          ".dinou/server_functions_manifest",
-          "server-functions-manifest.json"
-        );
-        await fs.mkdir(path.dirname(manifestPath), { recursive: true });
-        await fs.writeFile(manifestPath, JSON.stringify(manifestObj, null, 2));
-        // console.log(
-        //   `[server-functions-proxy] Generated manifest at ${manifestPath}`
-        // );
+          // Generate the final manifest by converting the Map to a plain object
+          const manifestObj = {};
+          for (const [path, exportsSet] of serverFunctions.entries()) {
+            manifestObj[path] = Array.from(exportsSet);
+          }
+
+          if (typeof globalThis !== "undefined") {
+            globalThis.__DINOU_RAW_SERVER_FUNCTIONS_MANIFEST__ = manifestObj;
+          }
+
+          const isDev = process.env.DINOU_DEV === "true" || process.env.NODE_ENV === "development";
+          const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true" || !isDev;
+
+          if (shouldWriteToDisk) {
+            // Write the server functions manifest JSON file to the output directory
+            const manifestPath = path.join(
+              ".dinou/server_functions_manifest",
+              "server-functions-manifest.json"
+            );
+            await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+            await fs.writeFile(manifestPath, JSON.stringify(manifestObj, null, 2));
+          }
+        } finally {
+          globalThis.__DINOU_SF_END_TIME__ = Date.now() - tEnd0;
+        }
       });
     },
   };

package/dinou/esbuild/plugins-esbuild/skip-missing-entry-points-plugin.mjs

@@ -1,10 +1,13 @@
 import { existsSync } from "node:fs";
 
 export default function skipMissingEntryPointsPlugin() {
+  let checkedOnce = false;
   return {
     name: "skip-missing-entry-points",
     setup(build) {
       build.onStart(async () => {
+        if (checkedOnce) return;
+        checkedOnce = true;
         const entryPoints = build.initialOptions.entryPoints;
         if (!entryPoints || typeof entryPoints === "string") return;