dinou 6.1.0 → 7.0.0

package/dinou/esbuild/helpers-esbuild/get-config-esbuild.mjs

@@ -1,4 +1,3 @@
-import { TsconfigPathsPlugin } from "@esbuild-plugins/tsconfig-paths";
 import reactClientManifestPlugin from "../plugins-esbuild/react-client-manifest-plugin.mjs";
 import serverFunctionsPlugin from "../plugins-esbuild/server-functions-plugin.mjs";
 import cssProcessorPlugin from "../plugins-esbuild/css-processor-plugin.mjs";
@@ -6,8 +5,9 @@ import esmHmrPlugin from "../react-refresh/esm-hmr-plugin.mjs";
 import stableChunkNamesAndMapsPlugin from "../plugins-esbuild/stable-chunk-names-and-maps-plugin.mjs";
 import assetsPlugin from "../plugins-esbuild/assets-plugin.mjs";
 import skipMissingEntryPointsPlugin from "../plugins-esbuild/skip-missing-entry-points-plugin.mjs";
-import copyStaticFiles from "esbuild-copy-static-files";
-import { existsSync } from "node:fs";
+import { swcRedirectPlugin } from "./swc-disk-cache.mjs";
+import fs from "node:fs";
+import path from "node:path";
 
 export default function getConfigEsbuild({
   entryPoints,
@@ -15,35 +15,123 @@ export default function getConfigEsbuild({
   manifest = {},
   changedIds,
   hmrEngine,
+  serverFiles,
+  onManifestUpdated,
+  onBuildStart,
+  onBuildEnd,
+  hmrPort,
 }) {
+  let esbuildRebuildStart = 0;
   let plugins = [
+    swcRedirectPlugin({ projectRoot: process.cwd() }),
+    ...(onBuildStart
+      ? [
+          {
+            name: "build-start-notifier",
+            setup(build) {
+              build.onStart(() => {
+                esbuildRebuildStart = Date.now();
+                onBuildStart();
+              });
+              build.onEnd(() => {
+                globalThis.__ESBUILD_PURE_TIME__ = Date.now() - esbuildRebuildStart;
+              });
+            },
+          },
+        ]
+      : []),
     skipMissingEntryPointsPlugin(),
-    TsconfigPathsPlugin({}),
-    cssProcessorPlugin(),
-    reactClientManifestPlugin({ manifest }),
-    assetsPlugin(),
-    stableChunkNamesAndMapsPlugin(),
-    serverFunctionsPlugin(),
-    esmHmrPlugin({ entryNames: ["main", "error"], changedIds, hmrEngine }),
+    cssProcessorPlugin({ outdir, hmrEngine }),
+    serverFunctionsPlugin({ serverFiles }),
+    reactClientManifestPlugin({ manifest, onManifestUpdated }),
+    assetsPlugin({ changedIds }),
+    stableChunkNamesAndMapsPlugin({ changedIds }),
+    esmHmrPlugin({ entryNames: ["main", "error"], changedIds, hmrEngine, hmrPort }),
+    ...(onBuildEnd
+      ? [
+          {
+            name: "build-end-notifier",
+            setup(build) {
+              build.onEnd(async (result) => {
+                if (esbuildRebuildStart > 0) {
+                  globalThis.__ESBUILD_CORE_TIME__ = Date.now() - esbuildRebuildStart;
+                }
+                await onBuildEnd(result);
+              });
+            },
+          },
+        ]
+      : []),
   ];
 
-  if (existsSync("favicons")) {
+  const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true";
+  const staticDir = fs.existsSync("public") ? "public" : (fs.existsSync("favicons") ? "favicons" : null);
+  if (staticDir && shouldWriteToDisk) {
+    let staticCopied = false;
     plugins = [
-      copyStaticFiles({
-        src: "favicons",
-        dest: outdir,
-      }),
+      {
+        name: "copy-static-files-once",
+        setup(build) {
+          build.onEnd(() => {
+            if (staticCopied) return;
+            staticCopied = true;
+            try {
+              fs.cpSync(staticDir, outdir, { recursive: true, force: true });
+            } catch (e) {}
+          });
+        },
+      },
       ...plugins,
     ];
   }
 
+  let userTsconfig = {};
+  if (fs.existsSync("tsconfig.json")) {
+    try {
+      const raw = fs.readFileSync("tsconfig.json", "utf8");
+      const clean = raw.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "").replace(/,(\s*[}\]])/g, "$1");
+      userTsconfig = JSON.parse(clean);
+    } catch (e) {}
+  }
+  const compilerOptions = userTsconfig.compilerOptions || {};
+  const userPaths = compilerOptions.paths || {};
+
+  const paths = {};
+  for (const [alias, targets] of Object.entries(userPaths)) {
+    const list = Array.isArray(targets) ? targets : [targets];
+    const swcTargets = list.map((t) => {
+      const norm = t.replace(/^\.\//, "");
+      return `.dinou/swc/${norm}`;
+    });
+    paths[alias] = [...swcTargets, ...list];
+  }
+  if (!paths["@/*"]) {
+    paths["@/*"] = [".dinou/swc/src/*", "src/*"];
+  }
+  if (!paths["~/*"]) {
+    paths["~/*"] = [".dinou/swc/src/*", "src/*"];
+  }
+
+  const tsconfigRaw = {
+    ...userTsconfig,
+    compilerOptions: {
+      ...compilerOptions,
+      baseUrl: compilerOptions.baseUrl || ".",
+      paths,
+    },
+  };
+
+  const isDev = process.env.NODE_ENV !== "production";
+
   return {
     entryPoints,
     outdir,
     format: "esm",
     bundle: true,
     splitting: true,
-    sourcemap: true,
+    sourcemap: !isDev,
+    treeShaking: !isDev,
+    tsconfigRaw,
     jsx: "automatic",
     target: "es2022",
     write: false,

package/dinou/esbuild/helpers-esbuild/get-esbuild-entries.mjs

@@ -15,7 +15,7 @@ import { useClientRegex, useServerRegex } from "../../constants.js";
 import { updateManifestForModule } from "./update-manifest-for-module.mjs";
 
 function hashFilePath(absPath) {
-  return crypto.createHash("sha1").update(absPath).digest("hex").slice(0, 8);
+  return crypto.createHash("sha1").update(normalizePath(absPath)).digest("hex").slice(0, 8);
 }
 
 export default async function getEsbuildEntries({
@@ -27,6 +27,7 @@ export default async function getEsbuildEntries({
   const detectedCSSEntries = new Set();
   const detectedAssetEntries = new Set();
   const serverModules = new Set();
+  const serverFunctions = new Set();
 
   // ---------- Helpers (ported mostly verbatim) ----------
   async function getImportsAndAssetsAndCsss(
@@ -49,7 +50,8 @@ export default async function getEsbuildEntries({
     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);
       },
@@ -88,10 +90,17 @@ export default async function getEsbuildEntries({
         if (isImportedFileClient) {
           continue; // Do not recursively process client components
         }
+
+        const isImportedFileServer = useServerRegex.test(importedCode.trim());
+        if (isImportedFileServer) {
+          serverFunctions.add(normalizePath(absImportPathWithExt));
+          continue;
+        }
       } else {
         const isImportedFileServer = useServerRegex.test(importedCode.trim());
 
         if (isImportedFileServer) {
+          serverFunctions.add(normalizePath(absImportPathWithExt));
           continue;
         }
       }
@@ -157,11 +166,20 @@ export default async function getEsbuildEntries({
   });
 
   // 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 isServerFunction = useServerRegex.test(code.trim());
     const normalizedPath = normalizePath(absPath);
 
+    if (isServerFunction) {
+      serverFunctions.add(normalizedPath);
+    }
+
     if (isClientModule) {
       const name = path.basename(absPath, path.extname(absPath));
 
@@ -170,22 +188,6 @@ export default async function getEsbuildEntries({
         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)) {
       serverModules.add(normalizedPath);
       try {
@@ -253,6 +255,16 @@ export default async function getEsbuildEntries({
     const outfileName = `${dCE.name}-${hash}`;
     dCE.outfile = `${outfileName}.js`;
     dCE.outfileName = outfileName;
+    if (manifest) {
+      const fileUrl = pathToFileURL(dCE.absPath).href;
+      const lowerFileUrl = fileUrl.toLowerCase();
+      for (const key in manifest) {
+        const kBase = key.split("#")[0].toLowerCase();
+        if (kBase === lowerFileUrl) {
+          manifest[key].id = "/" + dCE.outfile;
+        }
+      }
+    }
   }
 
   for (const dCSSE of detectedCSSEntries) {
@@ -273,6 +285,6 @@ export default async function getEsbuildEntries({
     detectedClientEntries,
     detectedCSSEntries,
     detectedAssetEntries,
-    Array.from(serverModules),
+    Array.from(serverFunctions),
   ];
 }

package/dinou/esbuild/helpers-esbuild/strip-namespace.mjs

@@ -0,0 +1,9 @@
+export function stripNamespace(p) {
+  if (!p) return "";
+  if (/^[a-zA-Z]:[/\\]/.test(p)) {
+    return p;
+  }
+  return p.replace(/^[a-zA-Z0-9_-]+:/, "");
+}
+
+export default stripNamespace;

package/dinou/esbuild/helpers-esbuild/swc-disk-cache.mjs

@@ -0,0 +1,225 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+import glob from "fast-glob";
+import { transform } from "@swc/core";
+import { useServerRegex } from "../../constants.js";
+import { extensions as assetExtensions } from "../../core/asset-extensions.js";
+
+const styleExtensions = ["css", "scss", "less", "sass"];
+const fontExtensions = ["woff", "woff2", "ttf", "eot", "otf"];
+const redirectExtensions = [...styleExtensions, ...assetExtensions, ...fontExtensions];
+const redirectFilter = new RegExp(`\\.(${redirectExtensions.join("|")})$`, "i");
+
+const normPath = (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 function getMirrorPath(srcPath, projectRoot = process.cwd()) {
+  if (!srcPath) return "";
+  const norm = normPath(srcPath);
+  const rootNorm = normPath(projectRoot);
+  if (!norm.startsWith(rootNorm)) return srcPath;
+  const rel = norm.slice(rootNorm.length + 1);
+  const targetRel = rel.replace(/\.[jt]sx?$/, ".js");
+  return path.resolve(projectRoot, ".dinou/swc", targetRel);
+}
+
+export function getOriginalPath(mirrorPath, projectRoot = process.cwd()) {
+  if (!mirrorPath) return "";
+  const norm = normPath(mirrorPath);
+  const rootNorm = normPath(projectRoot);
+  const swcPrefix = `${rootNorm}/.dinou/swc/`;
+  if (!norm.startsWith(swcPrefix)) return mirrorPath;
+  const rel = norm.slice(swcPrefix.length);
+  const base = path.resolve(projectRoot, rel.replace(/\.js$/, ""));
+  for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
+    const candidate = base + ext;
+    if (fsSync.existsSync(candidate)) return candidate;
+  }
+  return base + ".tsx";
+}
+
+export async function transformToDisk(srcPath, projectRoot = process.cwd()) {
+  const normSrc = path.resolve(srcPath);
+  if (!fsSync.existsSync(normSrc)) return null;
+
+  const raw = await fs.readFile(normSrc, "utf8");
+  // Skip server functions - handled by serverFunctionsPlugin proxy
+  if (useServerRegex.test(raw)) {
+    return null;
+  }
+
+  const targetPath = getMirrorPath(normSrc, projectRoot);
+
+  try {
+    const { code } = await transform(raw, {
+      filename: normSrc,
+      sourceMaps: "inline",
+      jsc: {
+        parser: { syntax: "typescript", tsx: true, dynamicImport: true },
+        target: "es2022",
+        transform: {
+          react: {
+            refresh: true,
+            development: true,
+            runtime: "automatic",
+          },
+        },
+      },
+    });
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, code, "utf8");
+    return targetPath;
+  } catch (err) {
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, raw, "utf8");
+    return targetPath;
+  }
+}
+
+export async function syncAllSwcFiles(srcDir = path.resolve("src"), projectRoot = process.cwd()) {
+  const files = await glob(["**/*.{js,jsx,ts,tsx}"], { cwd: srcDir, absolute: true });
+  const tasks = [];
+
+  for (const f of files) {
+    let raw = "";
+    try {
+      raw = fsSync.readFileSync(f, "utf8");
+    } catch (e) {
+      continue;
+    }
+    // Skip server functions
+    if (useServerRegex.test(raw)) {
+      continue;
+    }
+
+    const targetPath = getMirrorPath(f, projectRoot);
+    let needCompile = true;
+    try {
+      if (fsSync.existsSync(targetPath)) {
+        const srcStat = fsSync.statSync(f);
+        const tgtStat = fsSync.statSync(targetPath);
+        if (tgtStat.mtimeMs >= srcStat.mtimeMs) {
+          needCompile = false;
+        }
+      }
+    } catch (e) {}
+
+    if (needCompile) {
+      tasks.push(transformToDisk(f, projectRoot));
+    }
+  }
+
+  if (tasks.length > 0) {
+    await Promise.all(tasks);
+  }
+}
+
+export function swcRedirectPlugin({ projectRoot = process.cwd() } = {}) {
+  const swcDir = path.resolve(projectRoot, ".dinou/swc");
+  const resolveCache = new Map();
+
+  let redirTime = 0;
+  let redirCalls = 0;
+  let redirHits = 0;
+
+  const candidateExtensions = [
+    "",
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    "/index.js",
+    "/index.jsx",
+    "/index.ts",
+    "/index.tsx",
+  ];
+
+  return {
+    name: "swc-disk-cache-redirect",
+    setup(build) {
+      build.onStart(() => {
+        resolveCache.clear();
+        redirTime = 0;
+        redirCalls = 0;
+        redirHits = 0;
+      });
+
+      // Redirect CSS, assets, and server functions / source files imported from inside .dinou/swc back to src/
+      build.onResolve(
+        { filter: /.*/ },
+        (args) => {
+          const importer = args.importer || "";
+          if (!importer.includes(".dinou/swc") && !importer.includes(".dinou\\swc")) {
+            return null;
+          }
+
+          // Only process relative imports or assets
+          const isRelative = args.path.startsWith(".");
+          const isAsset = redirectFilter.test(args.path);
+          if (!isRelative && !isAsset) {
+            return null;
+          }
+
+          const tStart = Date.now();
+          redirCalls++;
+
+          const cacheKey = importer + "::" + args.path;
+          if (resolveCache.has(cacheKey)) {
+            redirHits++;
+            redirTime += Date.now() - tStart;
+            return resolveCache.get(cacheKey);
+          }
+
+          // 1. Check if it exists directly in .dinou/swc
+          const candidateBase = path.resolve(path.dirname(importer), args.path);
+          if (fsSync.existsSync(candidateBase) && !fsSync.statSync(candidateBase).isDirectory()) {
+            resolveCache.set(cacheKey, null);
+            redirTime += Date.now() - tStart;
+            return null;
+          }
+
+          for (const ext of [".js", ".jsx", ".ts", ".tsx", "/index.js", "/index.jsx", "/index.ts", "/index.tsx"]) {
+            const candidate = candidateBase + ext;
+            if (fsSync.existsSync(candidate) && !fsSync.statSync(candidate).isDirectory()) {
+              resolveCache.set(cacheKey, null);
+              redirTime += Date.now() - tStart;
+              return null;
+            }
+          }
+
+          // 2. Otherwise redirect to original in src/
+          const relFromSwc = path.relative(swcDir, path.dirname(importer));
+          const originalDir = path.join(projectRoot, relFromSwc);
+          const targetBase = path.resolve(originalDir, args.path);
+
+          for (const ext of candidateExtensions) {
+            const target = targetBase + ext;
+            if (fsSync.existsSync(target) && !fsSync.statSync(target).isDirectory()) {
+              const res = { path: target };
+              resolveCache.set(cacheKey, res);
+              redirTime += Date.now() - tStart;
+              return res;
+            }
+          }
+
+          resolveCache.set(cacheKey, null);
+          redirTime += Date.now() - tStart;
+          return null;
+        }
+      );
+
+      build.onEnd(() => {
+        globalThis.__DINOU_REDIRECT_TIME__ = redirTime;
+        globalThis.__DINOU_REDIRECT_CALLS__ = redirCalls;
+        globalThis.__DINOU_REDIRECT_HITS__ = redirHits;
+      });
+    },
+  };
+}

package/dinou/esbuild/helpers-esbuild/update-manifest-for-module.mjs

@@ -29,6 +29,13 @@ export function updateManifestForModule(
         chunks: expName,
         name: expName,
       };
+      if (expName === "default") {
+        manifest[`${fileUrl}#default`] = {
+          id: relPath,
+          chunks: expName,
+          name: expName,
+        };
+      }
     }
   }
 }

package/dinou/esbuild/helpers-esbuild/write.mjs

@@ -2,7 +2,20 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { regex } from "../../core/asset-extensions.js";
 
+function areBuffersEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.byteLength !== b.byteLength) return false;
+  return Buffer.from(a.buffer, a.byteOffset, a.byteLength).equals(
+    Buffer.from(b.buffer, b.byteOffset, b.byteLength)
+  );
+}
+
+const writtenCache = new Map();
+const createdDirs = new Set();
+
 export default async function write(result) {
+  const tWriteTotal0 = Date.now();
   if (!result.metafile) {
     return;
   }
@@ -47,13 +60,109 @@ export default async function write(result) {
       }
     }
   }
+  // 1. Populate in-memory files cache for zero-disk latency serving
+  globalThis.__DINOU_MEM_FILES__ = globalThis.__DINOU_MEM_FILES__ || new Map();
+  const publicDir = path.resolve(process.cwd(), ".dinou/public");
+  for (const file of result.outputFiles) {
+    const fileRelPath = normalizeRel(path.relative(process.cwd(), file.path));
+    if (skipSet.has(fileRelPath)) continue;
+    const cleanPublicRel = normalizeRel(path.relative(publicDir, file.path));
+    const buf = Buffer.isBuffer(file.contents)
+      ? file.contents
+      : Buffer.from(file.contents.buffer, file.contents.byteOffset, file.contents.byteLength);
+    globalThis.__DINOU_MEM_FILES__.set(cleanPublicRel, buf);
+    globalThis.__DINOU_MEM_FILES__.set("/" + cleanPublicRel, buf);
+    const base = path.basename(cleanPublicRel);
+    globalThis.__DINOU_MEM_FILES__.set(base, buf);
+  }
+
+  // 1.b Also populate aliases for renamed chunks so old/raw names never 404
+  if (globalThis.__DINOU_CHUNK_RENAMES__) {
+    for (const [oldName, newName] of globalThis.__DINOU_CHUNK_RENAMES__.entries()) {
+      const cleanNew = normalizeRel(newName);
+      const newBase = path.basename(cleanNew);
+      const buf =
+        globalThis.__DINOU_MEM_FILES__.get(cleanNew) ||
+        globalThis.__DINOU_MEM_FILES__.get("/" + cleanNew) ||
+        globalThis.__DINOU_MEM_FILES__.get(newBase);
+      if (buf) {
+        const cleanOld = normalizeRel(oldName);
+        const oldBase = path.basename(cleanOld);
+        globalThis.__DINOU_MEM_FILES__.set(cleanOld, buf);
+        globalThis.__DINOU_MEM_FILES__.set("/" + cleanOld, buf);
+        globalThis.__DINOU_MEM_FILES__.set(oldBase, buf);
+      }
+    }
+  }
+
+  const isDebug =
+    process.env.DINOU_DEBUG === "true" ||
+    process.env.DINOU_DEBUG === "1" ||
+    process.env.DEBUG === "true" ||
+    process.env.DEBUG === "1";
+  const timelineTime = () => new Date().toTimeString().slice(0, 8) + "." + String(Date.now() % 1000).padStart(3, "0");
+  const timelineRel = () => globalThis.__TIMELINE_T0__ ? `[+${Date.now() - globalThis.__TIMELINE_T0__}ms]` : ``;
+
+  const isDev = process.env.DINOU_DEV === "true" || process.env.NODE_ENV === "development";
+  const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true" || !isDev;
+
+  if (!shouldWriteToDisk) {
+    globalThis.__DINOU_WRITE_TIME__ = 0;
+    globalThis.__DINOU_WRITE_TOTAL__ = Date.now() - tWriteTotal0;
+    if (isDebug) {
+      console.log(`⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} write.mjs: in-memory cache ready (${result.outputFiles.length} file(s)), disk write skipped (0ms)`);
+    }
+    console.log(`✓ Build completed`);
+    return;
+  }
+
+  const filesToWrite = [];
   for (const file of result.outputFiles) {
     const fileRelPath = normalizeRel(path.relative(process.cwd(), file.path));
     if (skipSet.has(fileRelPath)) {
       continue;
     }
-    await fs.mkdir(path.dirname(file.path), { recursive: true });
-    await fs.writeFile(file.path, file.contents);
+    const cached = writtenCache.get(file.path);
+    if (cached && areBuffersEqual(cached, file.contents)) {
+      continue;
+    }
+    filesToWrite.push(file);
+  }
+
+  if (filesToWrite.length === 0) {
+    if (isDebug) {
+      console.log(`⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} write.mjs: 0 files changed, disk write skipped (0ms)`);
+    }
+    return;
+  }
+
+  const tWrite0 = Date.now();
+  if (isDebug) {
+    console.log(`⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} write.mjs: writing ${filesToWrite.length} file(s) to disk...`);
+  }
+  const uniqueDirs = new Set();
+  for (const f of filesToWrite) {
+    const dir = path.dirname(f.path);
+    if (!createdDirs.has(dir)) {
+      uniqueDirs.add(dir);
+      createdDirs.add(dir);
+    }
+  }
+  if (uniqueDirs.size > 0) {
+    await Promise.all(
+      Array.from(uniqueDirs).map((d) => fs.mkdir(d, { recursive: true }))
+    );
+  }
+  await Promise.all(
+    filesToWrite.map(async (file) => {
+      await fs.writeFile(file.path, file.contents);
+      writtenCache.set(file.path, file.contents);
+    })
+  );
+  globalThis.__DINOU_WRITE_TIME__ = Date.now() - tWrite0;
+
+  if (isDebug) {
+    console.log(`⏱️ [TIMELINE ${timelineTime()}] ${timelineRel()} write.mjs: wrote ${filesToWrite.length} file(s) in ${Date.now() - tWrite0}ms`);
   }
   console.log(`✓ Build completed`);
 }