dinou 6.1.1 → 7.0.0

package/dinou/cloudflare/shims/child_process.js

@@ -0,0 +1,14 @@
+// dinou/cloudflare/shims/child_process.js
+export const fork = () => {
+  return {
+    on: () => {},
+    stdout: { on: () => {} },
+    stderr: { on: () => {} },
+    stdio: [null, null, null, null, { write: () => {}, end: () => {} }],
+    kill: () => {},
+  };
+};
+export const spawn = () => ({ on: () => {} });
+export const exec = () => {};
+export const execSync = () => "";
+export default { fork, spawn, exec, execSync };

package/dinou/cloudflare/shims/empty.js

@@ -0,0 +1,2 @@
+// dinou/cloudflare/shims/empty.js
+export default {};

package/dinou/cloudflare/shims/fs.js

@@ -0,0 +1,99 @@
+// dinou/cloudflare/shims/fs.js
+function getVfs() {
+  return (typeof globalThis !== "undefined" && globalThis.__DINOU_VFS__) || {};
+}
+
+function lookupVfs(vfs, p) {
+  if (!vfs || !p) return null;
+  if (vfs[p]) return vfs[p];
+
+  const s = String(p).split("\\").join("/");
+  if (vfs[s]) return vfs[s];
+
+  if (s.length > 2 && s[1] === ":") {
+    const noDrive = s.slice(2);
+    if (vfs[noDrive]) return vfs[noDrive];
+  }
+
+  const idx = s.indexOf("/src");
+  if (idx !== -1) {
+    const fromSlash = s.slice(idx);
+    if (vfs[fromSlash]) return vfs[fromSlash];
+    const noSlash = fromSlash.slice(1);
+    if (vfs[noSlash]) return vfs[noSlash];
+  } else if (s.startsWith("src/") || s === "src") {
+    if (vfs[s]) return vfs[s];
+    if (vfs["/" + s]) return vfs["/" + s];
+  }
+
+  const trimmed = s.replace(/^\/+/, "");
+  if (vfs[trimmed]) return vfs[trimmed];
+  if (vfs["/" + trimmed]) return vfs["/" + trimmed];
+
+  return null;
+}
+
+export const existsSync = (p) => {
+  const vfs = getVfs();
+  return lookupVfs(vfs, p) !== null;
+};
+
+export const readFileSync = (p) => {
+  const vfs = getVfs();
+  const entry = lookupVfs(vfs, p);
+  if (entry && typeof entry.content === "string") {
+    return entry.content;
+  }
+  return "";
+};
+
+export const readdirSync = (p, options) => {
+  const vfs = getVfs();
+  const entry = lookupVfs(vfs, p);
+  if (!entry || entry.type !== "directory" || !Array.isArray(entry.children)) {
+    return [];
+  }
+  if (options && options.withFileTypes) {
+    return entry.children.map((c) => ({
+      name: c.name,
+      isDirectory: () => !!c.isDirectory,
+      isFile: () => !c.isDirectory,
+    }));
+  }
+  return entry.children.map((c) => c.name);
+};
+
+export const statSync = (p) => {
+  const vfs = getVfs();
+  const entry = lookupVfs(vfs, p);
+  const isDir = entry && entry.type === "directory";
+  const isF = entry && entry.type === "file";
+  return {
+    isDirectory: () => !!isDir,
+    isFile: () => !!isF,
+  };
+};
+
+export const mkdirSync = () => {};
+export const writeFileSync = () => {};
+export const rmSync = () => {};
+
+export const promises = {
+  readFile: async (p) => readFileSync(p),
+  writeFile: async () => {},
+  readdir: async (p, opts) => readdirSync(p, opts),
+  stat: async (p) => statSync(p),
+  mkdir: async () => {},
+  rm: async () => {},
+};
+
+export default {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  promises,
+};

package/dinou/cloudflare/shims/os.js

@@ -0,0 +1,29 @@
+// dinou/cloudflare/shims/os.js
+export const cpus = () => [{ model: "Cloudflare Workers Edge vCPU", speed: 2000 }];
+export const freemem = () => 128 * 1024 * 1024;
+export const totalmem = () => 128 * 1024 * 1024;
+export const platform = () => "workerd";
+export const arch = () => "x64";
+export const homedir = () => "/";
+export const tmpdir = () => "/tmp";
+export const hostname = () => "cloudflare-worker";
+export const type = () => "Linux";
+export const release = () => "edge";
+export const uptime = () => 0;
+export const loadavg = () => [0, 0, 0];
+export const networkInterfaces = () => ({});
+export default {
+  cpus,
+  freemem,
+  totalmem,
+  platform,
+  arch,
+  homedir,
+  tmpdir,
+  hostname,
+  type,
+  release,
+  uptime,
+  loadavg,
+  networkInterfaces,
+};

package/dinou/config.js

@@ -0,0 +1 @@
+module.exports = require("./core/config.js");

package/dinou/config.mjs

@@ -0,0 +1,2 @@
+export * from "./core/config.js";
+export { default } from "./core/config.js";

package/dinou/constants.js

@@ -1,7 +1,32 @@
-const useClientRegex =
-  /^\s*(?:(?:\/\/[^\n]*\n\s*)|(?:\/\*[\s\S]*?\*\/\s*))*['"]use client['"]/;
+function hasDirective(code, directive) {
+  if (typeof code !== "string" || !code.includes(directive)) return false;
+  const header = code
+    .slice(0, 2000)
+    .replace(/\/\/[^\r\n]*/g, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .trim();
+  return (
+    header.startsWith(`"${directive}"`) ||
+    header.startsWith(`'${directive}'`)
+  );
+}
 
-const useServerRegex =
-  /^\s*(?:(?:\/\/[^\n]*\n\s*)|(?:\/\*[\s\S]*?\*\/\s*))*['"]use server['"]/;
+const useClientRegex = {
+  test(code) {
+    return hasDirective(code, "use client");
+  },
+  [Symbol.match](str) {
+    return this.test(str) ? [str] : null;
+  },
+};
+
+const useServerRegex = {
+  test(code) {
+    return hasDirective(code, "use server");
+  },
+  [Symbol.match](str) {
+    return this.test(str) ? [str] : null;
+  },
+};
 
 module.exports = { useClientRegex, useServerRegex };

package/dinou/core/babel-esm-loader.js

@@ -14,27 +14,38 @@ const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
 let reactServerPath, reactDomServerPath, reactJsxRuntimePath, reactJsxDevRuntimePath;
 
-if (!isWebpack) {
-  const reactPkgJson = require.resolve("react/package.json");
-  reactServerPath = path.join(path.dirname(reactPkgJson), "react.react-server.js");
-  reactJsxRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-runtime.react-server.js");
-  reactJsxDevRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-dev-runtime.react-server.js");
-
-  const reactDomPkgJson = require.resolve("react-dom/package.json");
-  reactDomServerPath = path.join(path.dirname(reactDomPkgJson), "react-dom.react-server.js");
-}
+const reactPkgJson = require.resolve("react/package.json");
+reactServerPath = path.join(path.dirname(reactPkgJson), "react.react-server.js");
+reactJsxRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-runtime.react-server.js");
+reactJsxDevRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-dev-runtime.react-server.js");
+
+const reactDomPkgJson = require.resolve("react-dom/package.json");
+reactDomServerPath = path.join(path.dirname(reactDomPkgJson), "react-dom.react-server.js");
+
+let roggcServerNodePath, webpackServerNodePath;
+try {
+  const roggcPkg = require.resolve("@roggc/react-server-dom-esm/package.json");
+  roggcServerNodePath = path.join(path.dirname(roggcPkg), "server.node.js");
+} catch (e) {}
+
+try {
+  const wpPkg = require.resolve("react-server-dom-webpack/package.json");
+  webpackServerNodePath = path.join(path.dirname(wpPkg), "server.node.js");
+} catch (e) {}
 
 Module._resolveFilename = function (request, parent, isMain, options) {
-  if (!isWebpack) {
-    if (request === "react") {
-      return reactServerPath;
-    } else if (request === "react-dom") {
-      return reactDomServerPath;
-    } else if (request === "react/jsx-runtime") {
-      return reactJsxRuntimePath;
-    } else if (request === "react/jsx-dev-runtime") {
-      return reactJsxDevRuntimePath;
-    }
+  if (request === "react") {
+    return reactServerPath;
+  } else if (request === "react-dom") {
+    return reactDomServerPath;
+  } else if (request === "react/jsx-runtime") {
+    return reactJsxRuntimePath;
+  } else if (request === "react/jsx-dev-runtime") {
+    return reactJsxDevRuntimePath;
+  } else if (request === "@roggc/react-server-dom-esm/server" && roggcServerNodePath) {
+    return roggcServerNodePath;
+  } else if (request === "react-server-dom-webpack/server" && webpackServerNodePath) {
+    return webpackServerNodePath;
   }
   return originalResolveFilename.call(this, request, parent, isMain, options);
 };
@@ -51,6 +62,27 @@ function getMtimeParam(absPath) {
 }
 
 exports.resolve = async function resolve(specifier, context, defaultResolve) {
+  if (process.env.DINOU_PROCESS !== "ssr-html") {
+    if (specifier === "react") {
+      return { url: pathToFileURL(reactServerPath).href, shortCircuit: true };
+    }
+    if (specifier === "react/jsx-runtime") {
+      return { url: pathToFileURL(reactJsxRuntimePath).href, shortCircuit: true };
+    }
+    if (specifier === "react/jsx-dev-runtime") {
+      return { url: pathToFileURL(reactJsxDevRuntimePath).href, shortCircuit: true };
+    }
+    if (specifier === "react-dom") {
+      return { url: pathToFileURL(reactDomServerPath).href, shortCircuit: true };
+    }
+    if (specifier === "@roggc/react-server-dom-esm/server" && roggcServerNodePath) {
+      return { url: pathToFileURL(roggcServerNodePath).href, shortCircuit: true };
+    }
+    if (specifier === "react-server-dom-webpack/server" && webpackServerNodePath) {
+      return { url: pathToFileURL(webpackServerNodePath).href, shortCircuit: true };
+    }
+  }
+
   const absPathWithExt = getAbsPathWithExt(specifier, context);
   if (absPathWithExt) {
     let url = pathToFileURL(absPathWithExt).href;
@@ -122,20 +154,17 @@ exports.load = async function load(url, context, defaultLoad) {
       return defaultLoad(url, context, defaultLoad);
     }
 
-    const isReactServer = process.execArgv.some(arg => arg.includes("react-server"));
+    const isReactServer = process.env.DINOU_PROCESS !== "ssr-html";
     if (isReactServer && hasUseClient) {
       const parseExports = require("./parse-exports.js");
       const exports = parseExports(source);
-      let newSrc = "";
-      if (isWebpack) {
-        newSrc += 'import { registerClientReference } from "react-server-dom-webpack/server";\n';
-      } else {
-        const packageJsonPath = require.resolve("@roggc/react-server-dom-esm/package.json");
-        const serverNodePath = path.join(path.dirname(packageJsonPath), "server.node.js");
-        const serverNodeUrl = pathToFileURL(serverNodePath).href;
-        newSrc += `import pkg from ${JSON.stringify(serverNodeUrl)};\n`;
-        newSrc += 'const {registerClientReference} = pkg;\n';
-      }
+      const clientPkgPath = isWebpack
+        ? require.resolve("react-server-dom-webpack/package.json")
+        : require.resolve("@roggc/react-server-dom-esm/package.json");
+      const clientServerNodePath = path.join(path.dirname(clientPkgPath), "server.node.js");
+      const clientServerNodeUrl = pathToFileURL(clientServerNodePath).href;
+      let newSrc = `import pkg from ${JSON.stringify(clientServerNodeUrl)};\n`;
+      newSrc += 'const {registerClientReference} = pkg;\n';
       for (const name of exports) {
         if (name === 'default') {
           newSrc += 'export default ';
@@ -180,13 +209,13 @@ exports.load = async function load(url, context, defaultLoad) {
 
       let newSrc = code + "\n\n";
 
-      if (!isWebpack) {
-        const packageJsonPath = require.resolve("@roggc/react-server-dom-esm/package.json");
-        const serverNodePath = path.join(path.dirname(packageJsonPath), "server.node.js");
-        const serverNodeUrl = pathToFileURL(serverNodePath).href;
-        newSrc += `import pkgServer from ${JSON.stringify(serverNodeUrl)};\n`;
-        newSrc += 'const {registerServerReference} = pkgServer;\n';
-      }
+      const serverPkgPath = isWebpack
+        ? require.resolve("react-server-dom-webpack/package.json")
+        : require.resolve("@roggc/react-server-dom-esm/package.json");
+      const serverNodePath = path.join(path.dirname(serverPkgPath), "server.node.js");
+      const serverNodeUrl = pathToFileURL(serverNodePath).href;
+      newSrc += `import pkgServer from ${JSON.stringify(serverNodeUrl)};\n`;
+      newSrc += 'const {registerServerReference} = pkgServer;\n';
 
       const relativeFileUrl = "file:///" + rel.replace(/\\/g, "/");
       for (const name of exports) {

package/dinou/core/bailout-proxy.js

@@ -0,0 +1,61 @@
+const { isPprBuildActive, isInsideSuspense, markDynamicAccess } = require("./ppr-context.js");
+
+function triggerBailout(label, onBailout) {
+  if (isPprBuildActive() && isInsideSuspense()) {
+    markDynamicAccess(label);
+  } else if (typeof onBailout === "function") {
+    onBailout();
+  }
+}
+
+/**
+ * Creates a transparent proxy that spies on property accesses
+ * to detect dynamic usage and trigger a bailout callback.
+ * 
+ * @param {Object} target - The object to proxy (cookies, headers, query...)
+ * @param {string} label - Name for logging/debugging
+ * @param {Function} onBailout - Callback invoked when property access occurs
+ * @returns {Proxy}
+ */
+function createBailoutProxy(target, label = "Context", onBailout) {
+  const safeTarget = target || {};
+
+  return new Proxy(safeTarget, {
+    get(t, prop, receiver) {
+      if (
+        typeof prop === "symbol" ||
+        prop === "inspect" ||
+        prop === "valueOf" ||
+        prop === "toString" ||
+        prop === "constructor" ||
+        prop === "prototype"
+      ) {
+        return Reflect.get(t, prop, receiver);
+      }
+
+      triggerBailout(label, onBailout);
+
+      return Reflect.get(t, prop, receiver);
+    },
+
+    ownKeys(t) {
+      triggerBailout(label, onBailout);
+      return Reflect.ownKeys(t);
+    },
+
+    has(t, prop) {
+      if (
+        typeof prop !== "symbol" &&
+        prop !== "constructor" &&
+        prop !== "prototype"
+      ) {
+        triggerBailout(label, onBailout);
+      }
+      return Reflect.has(t, prop);
+    },
+  });
+}
+
+module.exports = {
+  createBailoutProxy,
+};