dinou 6.1.0 → 7.0.0

package/dinou/esbuild/plugins-esbuild/stable-chunk-names-and-maps-plugin.mjs

@@ -1,158 +1,203 @@
 import path from "node:path";
+import stripNamespace from "../helpers-esbuild/strip-namespace.mjs";
+
+const normKey = (p) => {
+  if (!p) return "";
+  let s = path.resolve(p).replace(/\\/g, "/");
+  if (process.platform === "win32") {
+    s = s.replace(/^([a-zA-Z]):/, (_, d) => d.toLowerCase() + ":");
+  }
+  return s;
+};
+
+export default function stableChunkNamesAndMapsPlugin({ dev = true, changedIds } = {}) {
+  let isInitial = true;
 
-export default function stableChunkNamesAndMapsPlugin({ dev = true } = {}) {
   return {
     name: "stable-chunk-names",
     setup(build) {
       build.onEnd(async (result) => {
-        if (!result.metafile || !result.outputFiles?.length) return;
-        const outdir = build.initialOptions.outdir;
-        if (!outdir) return;
-
-        const renames = new Map(); // oldFilename → newFilename (e.g., 'chunk-ABC.js' → 'chunk-stable.js')
-        const normalizeRel = (p) => p.replace(/\\/g, "/");
-        // First, rename chunks
-        for (const [oldRelPath, info] of Object.entries(
-          result.metafile.outputs
-        )) {
-          if (info.entryPoint || !oldRelPath.endsWith(".js")) continue;
-          const inputs = Object.keys(info.inputs);
-          const sourceFile = inputs.find(
-            (f) => f.startsWith("src/") && /\.(js|jsx|ts|tsx)$/.test(f)
-          );
-          if (!sourceFile) continue;
-          // Stable name based on the source file (always the same)
-          const rel = path.relative("src", sourceFile);
-          const normalizedRel = rel.replace(/\\/g, "/");
-          const dir = path.dirname(normalizedRel);
-          const base = path.basename(
-            normalizedRel,
-            path.extname(normalizedRel)
-          );
-          const stableName =
-            dir === "." ? base : `${dir.replace(/\//g, "-")}-${base}`;
-          let finalName;
-          if (dev) {
-            finalName = `${stableName}.js`; // 100% stable in dev
-          } else {
+        const tStable0 = Date.now();
+        try {
+          if (!result.metafile || !result.outputFiles?.length) return;
+          const outdir = build.initialOptions.outdir;
+          if (!outdir) return;
+
+          const normalizeRel = (p) => p.replace(/\\/g, "/");
+          const isIncremental = !isInitial && changedIds && changedIds.size > 0;
+          const renames = new Map(); // oldFilename → newFilename (e.g., 'chunk-ABC.js' → 'chunk-stable.js')
+
+          // First, rename chunks
+          for (const [oldRelPath, info] of Object.entries(
+            result.metafile.outputs
+          )) {
+            if (info.entryPoint || !oldRelPath.endsWith(".js")) continue;
+            const inputs = Object.keys(info.inputs || {});
+            const sourceFile = inputs.find(
+              (f) =>
+                (f.startsWith("src/") ||
+                  f.includes(".dinou/swc/src/") ||
+                  f.includes(".dinou\\swc\\src\\")) &&
+                /\.(js|jsx|ts|tsx)$/.test(f)
+            );
+            if (!sourceFile) continue;
+            // Clean source file if it was loaded from .dinou/swc/
+            const cleanSourceFile = sourceFile.replace(/^.*\.dinou[/\\]swc[/\\]/, "");
+            // Stable name based on the source file (always the same)
+            const rel = path.relative("src", cleanSourceFile);
+            const normalizedRel = rel.replace(/\\/g, "/");
+            const dir = path.dirname(normalizedRel);
+            const base = path.basename(
+              normalizedRel,
+              path.extname(normalizedRel)
+            );
+            const stableName =
+              dir === "." ? base : `${dir.replace(/\//g, "-")}-${base}`;
             const hash = oldRelPath.match(/-([A-Z0-9]+)\./)?.[1] || "";
-            finalName = `${stableName}-${hash}.js`;
+            const finalName = dev ? `${stableName}.js` : (hash ? `${stableName}-${hash}.js` : `${stableName}.js`);
+            const finalRelPath = `chunk-${finalName}`;
+            const oldLocal = path.basename(oldRelPath);
+            if (Array.from(renames.values()).includes(finalRelPath)) {
+              renames.set(oldLocal, oldLocal);
+            } else {
+              renames.set(oldLocal, finalRelPath);
+            }
           }
-          const finalRelPath = `chunk-${finalName}`;
-          const oldLocal = path.basename(oldRelPath);
-          renames.set(oldLocal, finalRelPath);
-        }
-        // Second, rename maps corresponding to the chunks
-        for (const [oldRelPath, info] of Object.entries(
-          result.metafile.outputs
-        )) {
-          if (!oldRelPath.endsWith(".js.map")) continue;
-          const jsRelPath = oldRelPath.replace(".map", "");
-          const jsLocal = path.basename(jsRelPath);
-          if (renames.has(jsLocal)) {
-            const newJsLocal = renames.get(jsLocal);
-            const newMapLocal = newJsLocal.replace(/\.js$/, ".js.map");
-            const oldMapLocal = path.basename(oldRelPath);
-            renames.set(oldMapLocal, newMapLocal);
+          // Second, rename maps corresponding to the chunks
+          for (const [oldRelPath, info] of Object.entries(
+            result.metafile.outputs
+          )) {
+            if (!oldRelPath.endsWith(".js.map")) continue;
+            const jsRelPath = oldRelPath.replace(".map", "");
+            const jsLocal = path.basename(jsRelPath);
+            if (renames.has(jsLocal)) {
+              const newJsLocal = renames.get(jsLocal);
+              const newMapLocal = newJsLocal.replace(/\.js$/, ".js.map");
+              const oldMapLocal = path.basename(oldRelPath);
+              renames.set(oldMapLocal, newMapLocal);
+            }
           }
-        }
-        // Step 3: Update references in importers (imports in .js)
-        const outputs = result.metafile.outputs;
-        const escapeRegExp = (string) =>
-          string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        for (const relPath in outputs) {
-          const output = outputs[relPath];
-          if (!output.imports || !relPath.endsWith(".js")) continue;
-          const importerFile = result.outputFiles.find(
-            (f) =>
-              normalizeRel(path.relative(process.cwd(), f.path)) === relPath
-          );
-          if (!importerFile) continue;
-          let content = new TextDecoder().decode(importerFile.contents);
-          for (const imp of output.imports) {
-            const importedRelPath = imp.path;
-            const oldImportedLocal = path.basename(importedRelPath);
-            const newImportedLocal = renames.get(oldImportedLocal);
-            if (!newImportedLocal) continue;
-            // Replace for double quotes with ./
-            const oldDouble = `"./${escapeRegExp(oldImportedLocal)}"`;
-            const newDouble = `"./${newImportedLocal}"`;
-            content = content.replace(new RegExp(oldDouble, "g"), newDouble);
-            // Replace for double quotes without ./
-            const oldDoubleNoDot = `"${escapeRegExp(oldImportedLocal)}"`;
-            const newDoubleNoDot = `"${newImportedLocal}"`;
+
+          if (renames.size === 0) return;
+          if (typeof globalThis !== "undefined") {
+            globalThis.__DINOU_CHUNK_RENAMES__ = renames;
+          }
+
+          // Step 3: Update references in importers (imports in .js)
+          const outputs = result.metafile.outputs;
+          const escapeRegExp = (string) =>
+            string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+          // Pre-index outputFiles for O(1) lookup
+          const outputFilesMap = new Map();
+          for (const f of result.outputFiles) {
+            outputFilesMap.set(normalizeRel(path.relative(process.cwd(), f.path)), f);
+          }
+
+          for (const relPath in outputs) {
+            const output = outputs[relPath];
+            if (!output.imports || !relPath.endsWith(".js")) continue;
+
+            const importerFile = outputFilesMap.get(relPath);
+            if (!importerFile) continue;
+
+            // Only decode and regex-replace if this output imports any renamed chunk
+            const hasRenamedChunk = output.imports.some((imp) => renames.has(path.basename(imp.path)));
+            if (!hasRenamedChunk) continue;
+
+            let content = new TextDecoder().decode(importerFile.contents);
+            for (const imp of output.imports) {
+              const importedRelPath = imp.path;
+              const oldImportedLocal = path.basename(importedRelPath);
+              const newImportedLocal = renames.get(oldImportedLocal);
+              if (!newImportedLocal) continue;
+              // Replace for double quotes with ./
+              const oldDouble = `"./${escapeRegExp(oldImportedLocal)}"`;
+              const newDouble = `"./${newImportedLocal}"`;
+              content = content.replace(new RegExp(oldDouble, "g"), newDouble);
+              // Replace for double quotes without ./
+              const oldDoubleNoDot = `"${escapeRegExp(oldImportedLocal)}"`;
+              const newDoubleNoDot = `"${newImportedLocal}"`;
+              content = content.replace(
+                new RegExp(oldDoubleNoDot, "g"),
+                newDoubleNoDot
+              );
+              // Replace for single quotes with ./
+              const oldSingle = `'./${escapeRegExp(oldImportedLocal)}'`;
+              const newSingle = `'./${newImportedLocal}'`;
+              content = content.replace(new RegExp(oldSingle, "g"), newSingle);
+              // Replace for single quotes without ./
+              const oldSingleNoDot = `'${escapeRegExp(oldImportedLocal)}'`;
+              const newSingleNoDot = `'${newImportedLocal}'`;
+              content = content.replace(
+                new RegExp(oldSingleNoDot, "g"),
+                newSingleNoDot
+              );
+            }
+            importerFile.contents = new TextEncoder().encode(content);
+          }
+
+          // Step 4: Update sourceMappingURL in the .js files being renamed
+          for (const file of result.outputFiles) {
+            if (!file.path.endsWith(".js")) continue;
+            const oldRelPath = normalizeRel(
+              path.relative(process.cwd(), file.path)
+            );
+            const oldLocal = path.basename(oldRelPath);
+            if (!renames.has(oldLocal)) continue;
+
+            const newLocal = renames.get(oldLocal);
+            const oldMapLocal = oldLocal.replace(/\.js$/, ".js.map");
+            const newMapLocal = newLocal.replace(/\.js$/, ".js.map");
+            let content = new TextDecoder().decode(file.contents);
+            const escOld = escapeRegExp(oldMapLocal);
+            const escNew = newMapLocal;
             content = content.replace(
-              new RegExp(oldDoubleNoDot, "g"),
-              newDoubleNoDot
+              new RegExp(`sourceMappingURL=${escOld}`, "g"),
+              `sourceMappingURL=${escNew}`
             );
-            // Replace for single quotes with ./
-            const oldSingle = `'./${escapeRegExp(oldImportedLocal)}'`;
-            const newSingle = `'./${newImportedLocal}'`;
-            content = content.replace(new RegExp(oldSingle, "g"), newSingle);
-            // Replace for single quotes without ./
-            const oldSingleNoDot = `'${escapeRegExp(oldImportedLocal)}'`;
-            const newSingleNoDot = `'${newImportedLocal}'`;
             content = content.replace(
-              new RegExp(oldSingleNoDot, "g"),
-              newSingleNoDot
+              new RegExp(`sourceMappingURL=\\./${escOld}`, "g"),
+              `sourceMappingURL=./${escNew}`
             );
+            file.contents = new TextEncoder().encode(content);
           }
-          importerFile.contents = new TextEncoder().encode(content);
-        }
-        // New: Update sourceMappingURL in the .js files being renamed
-        for (const file of result.outputFiles) {
-          if (!file.path.endsWith(".js")) continue;
-          const oldRelPath = normalizeRel(
-            path.relative(process.cwd(), file.path)
-          );
-          const oldLocal = path.basename(oldRelPath);
-          if (!renames.has(oldLocal)) continue;
-          const newLocal = renames.get(oldLocal);
-          const oldMapLocal = oldLocal.replace(/\.js$/, ".js.map");
-          const newMapLocal = newLocal.replace(/\.js$/, ".js.map");
-          let content = new TextDecoder().decode(file.contents);
-          const escOld = escapeRegExp(oldMapLocal);
-          const escNew = newMapLocal;
-          content = content.replace(
-            new RegExp(`sourceMappingURL=${escOld}`, "g"),
-            `sourceMappingURL=${escNew}`
-          );
-          content = content.replace(
-            new RegExp(`sourceMappingURL=\\./${escOld}`, "g"),
-            `sourceMappingURL=./${escNew}`
-          );
-          file.contents = new TextEncoder().encode(content);
-        }
-        // Update paths in outputFiles for chunks and maps
-        for (const file of result.outputFiles) {
-          const relPath = normalizeRel(path.relative(process.cwd(), file.path));
-          const oldLocal = path.basename(relPath);
-          const newLocal = renames.get(oldLocal);
-          if (newLocal) {
-            file.path = path.join(path.dirname(file.path), newLocal);
+
+          // Step 5: Update paths in outputFiles for chunks and maps
+          for (const file of result.outputFiles) {
+            const relPath = normalizeRel(path.relative(process.cwd(), file.path));
+            const oldLocal = path.basename(relPath);
+            const newLocal = renames.get(oldLocal);
+            if (newLocal) {
+              file.path = path.join(path.dirname(file.path), newLocal);
+            }
           }
-        }
-        // Update metafile for consistency
-        const newOutputs = {};
-        for (const oldRelPath in outputs) {
-          const oldLocal = path.basename(oldRelPath);
-          const newLocal = renames.get(oldLocal);
-          const newRelPath = newLocal
-            ? normalizeRel(path.join(path.dirname(oldRelPath), newLocal))
-            : oldRelPath;
-          newOutputs[newRelPath] = outputs[oldRelPath];
-          if (newOutputs[newRelPath].imports) {
-            for (let i = 0; i < newOutputs[newRelPath].imports.length; i++) {
-              const imp = newOutputs[newRelPath].imports[i];
-              const oldImpLocal = path.basename(imp.path);
-              const newImpLocal = renames.get(oldImpLocal) || oldImpLocal;
-              imp.path = normalizeRel(
-                path.join(path.dirname(imp.path), newImpLocal)
-              );
+
+          // Step 6: Update metafile for consistency
+          const newOutputs = {};
+          for (const oldRelPath in outputs) {
+            const oldLocal = path.basename(oldRelPath);
+            const newLocal = renames.get(oldLocal);
+            const newRelPath = newLocal
+              ? normalizeRel(path.join(path.dirname(oldRelPath), newLocal))
+              : oldRelPath;
+            newOutputs[newRelPath] = outputs[oldRelPath];
+            if (newOutputs[newRelPath].imports) {
+              for (let i = 0; i < newOutputs[newRelPath].imports.length; i++) {
+                const imp = newOutputs[newRelPath].imports[i];
+                const oldImpLocal = path.basename(imp.path);
+                const newImpLocal = renames.get(oldImpLocal) || oldImpLocal;
+                imp.path = normalizeRel(
+                  path.join(path.dirname(imp.path), newImpLocal)
+                );
+              }
             }
           }
+          result.metafile.outputs = newOutputs;
+        } finally {
+          isInitial = false;
+          globalThis.__DINOU_STABLE_TIME__ = Date.now() - tStable0;
         }
-        result.metafile.outputs = newOutputs;
       });
     },
   };

package/dinou/esbuild/plugins-postcss/postcss-extract-plugin.js

@@ -1,11 +1,14 @@
-// // postcss-extract-plugin.js
+// postcss-extract-plugin.js
 const fs = require("fs");
 const path = require("path");
 
+let cachedExtractedCSS = "";
+let cachedCSSBuffer = null;
+
 const createPostCSSExtractPlugin = (options = {}) => {
   const { outputFile = "styles.css", shouldExtract = () => true } = options;
 
-  let extractedCSS = "";
+  let currentExtractedCSS = "";
 
   // Define the PostCSS plugin to intercept and extract CSS rules
   const postcssPlugin = {
@@ -15,8 +18,8 @@ const createPostCSSExtractPlugin = (options = {}) => {
       const filePath = result.opts.from;
 
       if (shouldExtract(filePath, root)) {
-        extractedCSS += root.toString();
-        extractedCSS += "\n";
+        currentExtractedCSS += root.toString();
+        currentExtractedCSS += "\n";
 
         // Remove all CSS rules from the original file to prevent duplicate injection
         root.removeAll();
@@ -24,23 +27,47 @@ const createPostCSSExtractPlugin = (options = {}) => {
     },
   };
 
-  // Write the collected CSS contents to the final output file on disk
+  // Write the collected CSS contents to the final output file on disk or memory
   const finalize = () => {
-    if (!extractedCSS) return;
-    const outputDir = path.dirname(outputFile);
+    if (currentExtractedCSS) {
+      cachedExtractedCSS = currentExtractedCSS;
+      cachedCSSBuffer = Buffer.from(cachedExtractedCSS);
+      currentExtractedCSS = "";
+    }
 
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
+    if (!cachedCSSBuffer) return;
+
+    // 1. Ensure it's ALWAYS stored in globalThis.__DINOU_MEM_FILES__
+    if (typeof globalThis !== "undefined") {
+      if (!globalThis.__DINOU_MEM_FILES__) {
+        globalThis.__DINOU_MEM_FILES__ = new Map();
+      }
+      globalThis.__DINOU_MEM_FILES__.set("styles.css", cachedCSSBuffer);
+      globalThis.__DINOU_MEM_FILES__.set("/styles.css", cachedCSSBuffer);
     }
 
-    fs.writeFileSync(outputFile, extractedCSS);
+    // 2. Write to disk if in production OR if DINOU_WRITE_TO_DISK is requested in dev
+    const isProduction = process.env.NODE_ENV === "production";
+    const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true" || isProduction;
+    if (shouldWriteToDisk && cachedExtractedCSS) {
+      const outputDir = path.dirname(outputFile);
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+      fs.writeFileSync(outputFile, cachedExtractedCSS);
+    }
+  };
 
-    extractedCSS = "";
+  const addExtractedCss = (cssText) => {
+    if (cssText) {
+      currentExtractedCSS += cssText + "\n";
+    }
   };
 
   return {
     plugin: postcssPlugin,
     finalize,
+    addExtractedCss,
   };
 };
 

package/dinou/esbuild/react-refresh/esm-hmr/client.mjs

@@ -95,18 +95,21 @@ class HotModuleState {
 }
 
 export function createHotContext(id) {
-  const existing = REGISTERED_MODULES[id];
+  const normId = id.startsWith("/") ? id : "/" + id;
+  const existing = REGISTERED_MODULES[normId] || REGISTERED_MODULES[id];
   if (existing) {
-    existing.lock();
+    existing.isLocked = false;
     return existing;
   }
-  const state = new HotModuleState(id);
+  const state = new HotModuleState(normId);
+  REGISTERED_MODULES[normId] = state;
   REGISTERED_MODULES[id] = state;
   return state;
 }
 
 async function applyUpdate(id) {
-  const state = REGISTERED_MODULES[id];
+  const normId = id.startsWith("/") ? id : "/" + id;
+  const state = REGISTERED_MODULES[normId] || REGISTERED_MODULES[id];
   if (!state || state.isDeclined) {
     return false;
   }
@@ -120,10 +123,12 @@ async function applyUpdate(id) {
 
   const updateID = Date.now();
   for (const { deps, callback: acceptCallback } of acceptCallbacks) {
-    const url = `/${id.replace(/^\/+/, "")}?mtime=${updateID}`;
     const [module, ...depModules] = await Promise.all([
-      import(url),
-      ...deps.map((d) => import(`/${d.replace(/^\/+/, "")}?mtime=${updateID}`)),
+      import(normId + `?mtime=${updateID}`),
+      ...deps.map((d) => {
+        const depId = d.startsWith("/") ? d : "/" + d;
+        return import(depId + `?mtime=${updateID}`);
+      }),
     ]);
     acceptCallback({ module, deps: depModules });
   }
@@ -140,18 +145,60 @@ socket.addEventListener("message", ({ data: _data }) => {
     return;
   }
 
+  if (data.type === "rsc-update") {
+    if (typeof window !== "undefined" && typeof window.__DINOU_ROUTER_REFRESH__ === "function") {
+      window.__DINOU_ROUTER_REFRESH__();
+      return;
+    }
+    reload();
+    return;
+  }
+
+  if (
+    data.type === "style-update" ||
+    (data.type === "update" && data.url && (data.url.endsWith(".css") || data.url.includes("styles.css")))
+  ) {
+    const targetUrl = data.url ? data.url.split("?")[0] : "";
+    const links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (const link of links) {
+      const rawHref = link.getAttribute("href");
+      if (!rawHref) continue;
+      const cleanHref = rawHref.split("?")[0];
+      if (!targetUrl || cleanHref.endsWith(targetUrl) || targetUrl.endsWith(cleanHref) || cleanHref.includes("styles.css")) {
+        const nextUrl = new URL(link.href, window.location.origin);
+        nextUrl.searchParams.set("t", String(Date.now()));
+        link.href = nextUrl.href;
+      }
+    }
+    return;
+  }
+
   if (data.type !== "update") {
     return;
   }
 
+  const tRecv = Date.now();
+  const isDebug = typeof window !== "undefined" && Boolean(window.__DINOU_DEBUG__);
+
+  if (isDebug) {
+    console.log(`⏱️ [BROWSER HMR] Received update for ${data.url} at ${new Date().toTimeString().slice(0, 8)}.${String(Date.now() % 1000).padStart(3, '0')}`);
+  }
+
   applyUpdate(data.url)
     .then((ok) => {
       if (!ok) {
+        if (isDebug) console.warn(`⏱️ [BROWSER HMR] applyUpdate returned false, falling back to full reload!`);
         reload();
+      } else {
+        if (isDebug) {
+          console.log(`⏱️ [BROWSER HMR] Fast Refresh finished applying in ${Date.now() - tRecv}ms!`);
+        } else {
+          console.log(`[ESM-HMR] hot updated: ${data.url}`);
+        }
       }
     })
     .catch((err) => {
-      console.error(err);
+      console.error(`[ESM-HMR] applyUpdate error:`, err);
       reload();
     });
 });

package/dinou/esbuild/react-refresh/esm-hmr/server.js

@@ -16,7 +16,7 @@ class EsmHmrEngine {
     this.dependencyTree = map;
     const wss = options.server
       ? new WebSocket.Server({ noServer: true })
-      : new WebSocket.Server({ port: 3001 });
+      : new WebSocket.Server({ port: options.port || Number(process.env.HMR_PORT) || 3001 });
 
     if (options.server) {
       options.server.on("upgrade", (req, socket, head) => {