dinou 6.1.1 → 7.1.0

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

@@ -5,14 +5,28 @@ const manifestGeneratorPlugin = require("./manifest-generator-plugin");
 const parseExports = require("../../core/parse-exports.js");
 const { useServerRegex } = require("../../constants.js");
 
-function serverFunctionsPlugin() {
+function serverFunctionsPlugin(manifestData = {}, options = {}) {
+  const opts =
+    typeof manifestData === "object" &&
+    manifestData !== null &&
+    ("onManifestUpdated" in manifestData || "serverFiles" in manifestData)
+      ? manifestData
+      : options;
+  const serverFiles =
+    opts.serverFiles || manifestData.serverFiles || options.serverFiles || null;
   const root = process.cwd();
   const serverFunctions = new Map(); // Collect here: Map<relativePath, Set<exports>>
 
+  function normalizeFsPath(p) {
+    return path.resolve(p).replace(/\\/g, "/").toLowerCase();
+  }
+
   return {
     name: "server-functions-proxy",
     transform(code, id) {
-      if (!useServerRegex.test(code.trim())) return null;
+      if (id.includes("node_modules") || id.includes("\0")) return null;
+      if (serverFiles && !serverFiles.has(normalizeFsPath(id))) return null;
+      if (!useServerRegex.test(code)) return null;
 
       const exports = parseExports(code);
       if (exports.length === 0) return null;
@@ -48,6 +62,12 @@ function serverFunctionsPlugin() {
     },
     // 🪄 After manifest exists, replace the placeholder with the final URL
     async generateBundle(options, bundle) {
+      if (serverFunctions.size === 0) {
+        if (typeof globalThis !== "undefined") {
+          globalThis.__DINOU_RAW_SERVER_FUNCTIONS_MANIFEST__ = {};
+        }
+        return;
+      }
       const manifest = manifestGeneratorPlugin.manifestData;
       const hashedPath =
         "/" + (manifest["serverFunctionProxy.js"] || "serverFunctionProxy.js");
@@ -69,16 +89,28 @@ function serverFunctionsPlugin() {
         manifestObj[relPath] = Array.from(exportsSet);
       }
 
-      // Write the manifest to the specified folder (e.g. same place as other assets)
-      const manifestPath = path.join(
-        ".dinou/server_functions_manifest",
-        "server-functions-manifest.json"
-      );
-      try {
-        await fs.mkdir(path.dirname(manifestPath), { recursive: true });
-        await fs.writeFile(manifestPath, JSON.stringify(manifestObj, null, 2));
-      } catch (err) {
-        console.error(err);
+      if (typeof globalThis !== "undefined") {
+        globalThis.__DINOU_RAW_SERVER_FUNCTIONS_MANIFEST__ = manifestObj;
+      }
+
+      const isDev =
+        process.env.NODE_ENV !== "production" ||
+        process.env.DINOU_DEV === "true";
+      const shouldWriteToDisk =
+        process.env.DINOU_WRITE_TO_DISK === "true" || !isDev;
+
+      if (shouldWriteToDisk) {
+        // Write the manifest to the specified folder (e.g. same place as other assets)
+        const manifestPath = path.join(
+          ".dinou/server_functions_manifest",
+          "server-functions-manifest.json"
+        );
+        try {
+          await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+          await fs.writeFile(manifestPath, JSON.stringify(manifestObj, null, 2));
+        } catch (err) {
+          console.error(err);
+        }
       }
     },
   };

package/dinou/rollup/rollup-plugins/rollup-plugin-swc.js

@@ -0,0 +1,100 @@
+// dinou/rollup/rollup-plugins/rollup-plugin-swc.js
+// Ultra-fast SWC transpilation plugin for Rollup with high-speed in-memory cache.
+// Replaces heavy Babel pipeline in development and eliminates multi-second HMR latencies.
+
+const path = require("node:path");
+const fs = require("node:fs");
+
+let swc = null;
+try {
+  swc = require("@swc/core");
+} catch (e) {
+  console.warn("⚠️ [@swc/core] not found. Please ensure @swc/core is installed for fast Rollup builds.");
+}
+
+function rollupSwcPlugin(options = {}) {
+  const isDev = process.env.NODE_ENV !== "production" || process.env.DINOU_DEV === "true";
+
+  // In-Memory Cache: normSrc -> { mtime, code, map }
+  const memCache = new Map();
+
+  return {
+    name: "rollup-plugin-swc",
+
+    async transform(code, id) {
+      if (!swc || id.includes("\0") || id.startsWith("commonjsHelpers")) {
+        return null;
+      }
+
+      const isNodeModules = id.includes("node_modules");
+      const isDinou = id.includes("dinou");
+      const isReactRefresh = id.includes("react-refresh");
+      if (isNodeModules && !isDinou && !isReactRefresh) {
+        return null;
+      }
+
+      const cleanId = id.replace(/\?.*$/, "");
+      if (!/\.[jt]sx?$/i.test(cleanId)) {
+        return null;
+      }
+
+      const normSrc = path.resolve(cleanId);
+      const isTs = normSrc.endsWith(".ts") || normSrc.endsWith(".tsx");
+      const isJsx = normSrc.endsWith(".tsx") || normSrc.endsWith(".jsx");
+
+      // Memory Cache check
+      let mtimeMs = 0;
+      try {
+        const stat = fs.statSync(normSrc);
+        mtimeMs = stat.mtimeMs;
+      } catch (e) {}
+
+      if (mtimeMs > 0 && memCache.has(normSrc)) {
+        const entry = memCache.get(normSrc);
+        if (entry.mtime === mtimeMs) {
+          return {
+            code: entry.code,
+            map: entry.map,
+          };
+        }
+      }
+
+      // Compile with native Rust SWC
+      try {
+        const swcResult = await swc.transform(code, {
+          filename: normSrc,
+          sourceMaps: isDev ? "inline" : false,
+          jsc: {
+            parser: isTs
+              ? { syntax: "typescript", tsx: isJsx, dynamicImport: true }
+              : { syntax: "ecmascript", jsx: isJsx, dynamicImport: true },
+            target: "es2022",
+            transform: {
+              react: {
+                runtime: "automatic",
+                development: isDev,
+                refresh: isDev,
+              },
+            },
+          },
+        });
+
+        const outputCode = swcResult.code;
+        const outputMap = swcResult.map ? JSON.parse(swcResult.map) : null;
+
+        memCache.set(normSrc, { mtime: mtimeMs, code: outputCode, map: outputMap });
+
+        return {
+          code: outputCode,
+          map: outputMap,
+        };
+      } catch (err) {
+        console.error(`❌ [Rollup SWC Transform Error in ${path.basename(normSrc)}]:`, err.message || err);
+        return null;
+      }
+    },
+  };
+}
+
+module.exports = rollupSwcPlugin;
+

package/dinou/rollup/rollup.config.js

@@ -16,9 +16,8 @@ const tsconfigPaths = require("rollup-plugin-tsconfig-paths");
 const serverFunctionsPlugin = require("./rollup-plugins/rollup-plugin-server-functions");
 const { regex } = require("../core/asset-extensions.js");
 const manifestGeneratorPlugin = require("./rollup-plugins/manifest-generator-plugin.js");
-
-const isDevelopment = process.env.NODE_ENV !== "production";
-const outputDirectory = isDevelopment ? ".dinou/public" : ".dinou/dist3";
+const rollupMemoryPlugin = require("./rollup-plugins/rollup-plugin-memory.js");
+const rollupSwcPlugin = require("./rollup-plugins/rollup-plugin-swc.js");
 
 const localDinouPath = path.resolve(process.cwd(), "dinou");
 const isEjected = fs.existsSync(localDinouPath);
@@ -30,8 +29,12 @@ console.log(
 );
 
 module.exports = async function () {
+  const isDevelopment = process.env.NODE_ENV !== "production";
+  const outputDirectory = isDevelopment ? ".dinou/public" : ".dinou/dist3";
+  const shouldWriteToDisk = process.env.DINOU_WRITE_TO_DISK === "true" || !isDevelopment;
+  const serverFiles = new Set();
   const del = (await import("rollup-plugin-delete")).default;
-  return {
+  const clientConfig = {
     input: isDevelopment
       ? {
         runtime: path.resolve(
@@ -43,7 +46,6 @@ module.exports = async function () {
           "react-refresh/react-refresh-entry.js",
         ),
         main: path.resolve(__dirname, "../core/client.jsx"),
-        error: path.resolve(__dirname, "../core/client-error.jsx"),
         serverFunctionProxy: path.resolve(
           __dirname,
           "../core/server-function-proxy.js",
@@ -56,10 +58,13 @@ module.exports = async function () {
           __dirname,
           "../core/link.jsx",
         ),
+        dinouSlot: path.resolve(
+          __dirname,
+          "../core/slot.js",
+        ),
       }
       : {
         main: path.resolve(__dirname, "../core/client.jsx"),
-        error: path.resolve(__dirname, "../core/client-error.jsx"),
         serverFunctionProxy: path.resolve(
           __dirname,
           "../core/server-function-proxy.js",
@@ -72,12 +77,31 @@ module.exports = async function () {
           __dirname,
           "../core/link.jsx",
         ),
+        dinouSlot: path.resolve(
+          __dirname,
+          "../core/slot.js",
+        ),
       },
     output: {
       dir: outputDirectory,
       format: "esm",
       entryFileNames: isDevelopment ? "[name].js" : "[name]-[hash].js",
-      chunkFileNames: isDevelopment ? "[name].js" : "[name]-[hash].js",
+      chunkFileNames: (chunkInfo) => {
+        if (!isDevelopment) return "[name]-[hash].js";
+        const moduleIds =
+          chunkInfo.moduleIds || Object.keys(chunkInfo.modules || {});
+        if (moduleIds.length === 0) return "[name].js";
+        const isVendor = moduleIds.every(
+          (id) =>
+            id.includes("node_modules") ||
+            id.includes("\0") ||
+            id.includes("commonjsHelpers")
+        );
+        if (isVendor) {
+          return "[name]-[hash].js";
+        }
+        return "[name].js";
+      },
       // 🛑 THE MAGIC SOLUTION 👇
       // Defaults to 'true' in some cases.
       // By setting it to 'false', you force Rollup to use the original exported
@@ -87,21 +111,24 @@ module.exports = async function () {
     // 🛑 ADD THIS MAGIC LINE
     // Tells Rollup: "Keep entry point signatures (export names) intact"
     preserveEntrySignatures: "strict",
+    perf: isDevelopment,
+    treeshake: isDevelopment ? false : true,
     external: [
       "/refresh.js",
       "/__hmr_client__.js",
       "/__SERVER_FUNCTION_PROXY__",
     ],
     plugins: [
-      del({
-        targets: [
-          `${outputDirectory}/*`,
-          ".dinou/react_client_manifest/*",
-          ".dinou/server_functions_manifest/*",
-        ],
-        runOnce: true,
-        hook: "buildStart",
-      }),
+      shouldWriteToDisk &&
+        del({
+          targets: [
+            `${outputDirectory}/*`,
+            ".dinou/react_client_manifest/*",
+            ".dinou/server_functions_manifest/*",
+          ],
+          runOnce: true,
+          hook: "buildStart",
+        }),
       tsconfigPaths(),
       replace({
         preventAssignment: true,
@@ -121,20 +148,21 @@ module.exports = async function () {
       dinouAssetPlugin({
         include: regex,
       }),
-      babel({
-        babelHelpers: "bundled",
-        extensions: [".js", ".jsx", ".ts", ".tsx"],
-        presets: [
-          ["@babel/preset-react", { runtime: "automatic" }],
-          "@babel/preset-typescript",
-        ],
-        plugins: [
-          "babel-plugin-react-compiler",
-          isDevelopment && require.resolve("react-refresh/babel"),
-          "@babel/plugin-syntax-import-meta",
-        ].filter(Boolean),
-        exclude: /node_modules[\\/](?!dinou|react-refresh)/,
-      }),
+      isDevelopment
+        ? rollupSwcPlugin()
+        : babel({
+            babelHelpers: "bundled",
+            extensions: [".js", ".jsx", ".ts", ".tsx"],
+            presets: [
+              ["@babel/preset-react", { runtime: "automatic" }],
+              "@babel/preset-typescript",
+            ],
+            plugins: [
+              "babel-plugin-react-compiler",
+              "@babel/plugin-syntax-import-meta",
+            ].filter(Boolean),
+            exclude: /node_modules[\\/](?!dinou|react-refresh)/,
+          }),
       postcss({
         modules: {
           generateScopedName: (name, filename) =>
@@ -146,34 +174,52 @@ module.exports = async function () {
           path: path.resolve(__dirname, "postcss.config.js"),
         },
       }),
-      copy({
-        targets: [
-          {
-            src: "favicons/*",
-            dest: outputDirectory,
-          },
-        ],
-        flatten: true,
-      }),
+      shouldWriteToDisk &&
+        copy({
+          targets: [
+            fs.existsSync("public") && {
+              src: "public/*",
+              dest: outputDirectory,
+            },
+            fs.existsSync("favicons") && {
+              src: "favicons/*",
+              dest: outputDirectory,
+            },
+          ].filter(Boolean),
+          flatten: true,
+        }),
       reactClientManifest({
         manifestPath: path.join(
           ".dinou/react_client_manifest",
           "react-client-manifest.json",
         ),
+        serverFiles,
       }),
       isDevelopment && reactRefreshWrapModules(),
       isDevelopment && esmHmrPlugin(),
       !isDevelopment && manifestGeneratorPlugin(),
-      serverFunctionsPlugin(),
+      serverFunctionsPlugin({ serverFiles }),
+      isDevelopment && rollupMemoryPlugin(),
     ].filter(Boolean),
     watch: {
+      buildDelay: 100,
       exclude: [
-        ".dinou/public/**",
-        ".dinou/react_client_manifest/**",
-        ".dinou/server_functions_manifest/**",
+        /[\\/]node_modules[\\/]/,
+        /[\\/]\.git[\\/]/,
+        /[\\/]\.dinou[\\/]/,
+        /[\\/]test-results[\\/]/,
+        /[\\/]playwright-report[\\/]/,
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/.dinou/**",
+        "**/test-results/**",
+        "**/playwright-report/**",
       ],
     },
     onwarn(warning, warn) {
+      if (warning.code === "CIRCULAR_DEPENDENCY" || warning.code === "THIS_IS_UNDEFINED") {
+        return;
+      }
       // Ignore eval warning if it comes from our request-context file
       if (warning.code === "EVAL") {
         // Optional: If you want to be very specific and only allow it in that file:
@@ -194,4 +240,70 @@ module.exports = async function () {
       warn(warning);
     },
   };
+
+  if (isDevelopment) {
+    return clientConfig;
+  }
+
+  const serverConfig = {
+    input: {
+      handler: path.resolve(__dirname, "../core/handler.js"),
+      netlify: path.resolve(__dirname, "../adapters/netlify.js"),
+    },
+    output: {
+      dir: path.resolve(outputDirectory, "server"),
+      format: "esm",
+      entryFileNames: "[name].js",
+      chunkFileNames: "[name]-[hash].js",
+      sourcemap: true,
+      banner: "import { createRequire as ___createRequire } from 'node:module'; import { fileURLToPath as ___fileURLToPath } from 'node:url'; import ___path from 'node:path'; const require = ___createRequire(import.meta.url || ___path.resolve(process.cwd(), 'package.json')); globalThis.__dinou_require__ = require; const __filename = import.meta.url ? ___fileURLToPath(import.meta.url) : ___path.resolve(process.cwd(), 'index.js'); const __dirname = ___path.dirname(__filename); process.env.NODE_ENV = process.env.NODE_ENV || 'production';",
+    },
+    external: [
+      "express",
+      "chokidar",
+      "dotenv",
+      "fsevents",
+      "@swc/core",
+      "@babel/core",
+      "esbuild",
+    ],
+    plugins: [
+      replace({
+        preventAssignment: true,
+        "process.env.NODE_ENV": JSON.stringify("production"),
+      }),
+      json(),
+      resolve({
+        exportConditions: ["react-server", "node", "import"],
+        preferBuiltins: true,
+        browser: false,
+      }),
+      commonjs({
+        ignoreDynamicRequires: true,
+      }),
+      {
+        name: "post-build-server",
+        closeBundle() {
+          const fs = require("fs");
+          fs.writeFileSync(
+            path.resolve(process.cwd(), ".dinou/dist3/server/package.json"),
+            JSON.stringify({ type: "module" }, null, 2)
+          );
+          const { execSync } = require("child_process");
+          execSync(`"${process.execPath}" --conditions=react-server "${path.resolve(__dirname, "../core/run-ssg.js")}"`, {
+            stdio: "inherit",
+            env: { ...process.env, NODE_ENV: "production" },
+          });
+        },
+      },
+    ],
+    onwarn(warning, warn) {
+      if (warning.code === "CIRCULAR_DEPENDENCY" || warning.code === "EVAL") {
+        return;
+      }
+      warn(warning);
+    },
+  };
+
+  return [clientConfig, serverConfig];
 };

package/dinou/server.d.ts

@@ -1,12 +1,114 @@
-/**
- * Revalidates the cache for a specific route path.
- * * It deletes the old cached HTML and RSC files and rebuilds them synchronously.
- * @param path The path of the route to revalidate (e.g. "/blog" or "/blog/12").
- */
-export declare function revalidatePath(path: string): Promise<void>;
-
-/**
- * Revalidates all routes that are associated with the specified cache tag.
- * @param tag The tag string to revalidate (e.g. "blog-posts").
- */
-export declare function revalidateTag(tag: string): Promise<void>;
+/**
+ * Revalidates the cache for a specific route path.
+ * * It deletes the old cached HTML and RSC files and rebuilds them synchronously.
+ * * When `{ cascade: true }` is specified, if a layout is present and revalidated in that path,
+ * it cascades `revalidatePage` to all child routes to ensure 0 hydration mismatch.
+ * @param path The path of the route to revalidate (e.g. "/blog" or "/dashboard").
+ * @param options Optional configuration: `{ cascade?: boolean }` or legacy `"layout"`.
+ */
+export declare function revalidatePath(
+  path: string,
+  options?: { cascade?: boolean } | "layout"
+): Promise<void>;
+
+/**
+ * Revalidates only the page component (`page.rsc`) and its HTML (`index.html`) for a specific route path,
+ * without touching any layout.
+ * @param path The path of the page to revalidate (e.g. "/dashboard/analytics").
+ */
+export declare function revalidatePage(path: string): Promise<void>;
+
+/**
+ * Revalidates all routes that are associated with the specified cache tag.
+ * * By default, layout tags only revalidate the layout shell (`layout.rsc`) for maximum efficiency.
+ * * When `{ cascade: true }` is specified, layout tags invoke `revalidatePath(path, { cascade: true })`
+ * to cascade `revalidatePage` to all child pages, ensuring 0 hydration mismatch.
+ * @param tag The tag string to revalidate (e.g. "blog-posts").
+ * @param options Optional configuration: `{ cascade?: boolean }` or legacy `"layout"`.
+ */
+export declare function revalidateTag(
+  tag: string,
+  options?: { cascade?: boolean } | "layout"
+): Promise<void>;
+export type {
+  PPRConfig,
+  RouteSegmentConfig,
+  PageFunctions,
+  LayoutFunctions,
+  StaticPathItem,
+  StaticPathsResult,
+} from "./index";
+
+export interface DinouCacheSlotProps {
+  id?: string;
+  tag?: string;
+  tags?: string[];
+  revalidate?: number;
+  children: any;
+}
+
+/**
+ * DinouCacheSlot: Vertical segmentation primitive (Micro-ISR) for React Server Components.
+ * Caches and invalidates component sub-trees inside a page via revalidate and revalidateTag,
+ * without re-evaluating the parent page or re-fetching unneeded database queries.
+ */
+export declare function DinouCacheSlot(props: DinouCacheSlotProps): Promise<any>;
+
+// ====================================================================
+// STORAGE ADAPTER TYPES (ISR / CACHE)
+// ====================================================================
+
+export interface StorageItem {
+  content: string;
+  metadata?: any;
+}
+
+export abstract class StorageAdapter {
+  abstract get(key: string): Promise<StorageItem | null>;
+  abstract set(key: string, content: string, metadata?: any): Promise<void>;
+  abstract has(key: string): Promise<boolean>;
+  abstract delete(key: string): Promise<void>;
+}
+
+export class FileSystemStorage extends StorageAdapter {
+  constructor(baseDir?: string);
+  get(key: string): Promise<StorageItem | null>;
+  set(key: string, content: string, metadata?: any): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+}
+
+export class CloudflareKVStorage extends StorageAdapter {
+  constructor(kvNamespace: any);
+  get(key: string): Promise<StorageItem | null>;
+  set(key: string, content: string, metadata?: any): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+}
+
+export class DenoKVStorage extends StorageAdapter {
+  constructor(kvInstance?: any);
+  get(key: string): Promise<StorageItem | null>;
+  set(key: string, content: string, metadata?: any): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+}
+
+export class MemoryStorage extends StorageAdapter {
+  constructor();
+  get(key: string): Promise<StorageItem | null>;
+  set(key: string, content: string, metadata?: any): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+}
+
+export class RedisStorage extends StorageAdapter {
+  constructor(redisClient: any, prefix?: string);
+  get(key: string): Promise<StorageItem | null>;
+  set(key: string, content: string, metadata?: any): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+}
+
+export function getStorageAdapter(): StorageAdapter;
+export function setStorageAdapter(adapter: StorageAdapter): void;

package/dinou/server.js

@@ -1,10 +1,35 @@
-module.exports = {
-  revalidatePath: async function (path) {
-    const { revalidatePath: fn } = require("./core/cache-revalidate.js");
-    return fn(path);
-  },
-  revalidateTag: async function (tag) {
-    const { revalidateTag: fn } = require("./core/cache-revalidate.js");
-    return fn(tag);
-  },
-};
+const {
+  StorageAdapter,
+  FileSystemStorage,
+  CloudflareKVStorage,
+  DenoKVStorage,
+  MemoryStorage,
+  RedisStorage,
+  getStorageAdapter,
+  setStorageAdapter,
+} = require("./core/storage-adapter.js");
+const { DinouCacheSlot } = require("./core/cache-slot.js");
+
+module.exports = {
+  DinouCacheSlot,
+  revalidatePath: async function (path, options) {
+    const { revalidatePath: fn } = require("./core/cache-revalidate.js");
+    return fn(path, options);
+  },
+  revalidatePage: async function (path) {
+    const { revalidatePage: fn } = require("./core/cache-revalidate.js");
+    return fn(path);
+  },
+  revalidateTag: async function (tag, options) {
+    const { revalidateTag: fn } = require("./core/cache-revalidate.js");
+    return fn(tag, options);
+  },
+  StorageAdapter,
+  FileSystemStorage,
+  CloudflareKVStorage,
+  DenoKVStorage,
+  MemoryStorage,
+  RedisStorage,
+  getStorageAdapter,
+  setStorageAdapter,
+};

package/dinou/server.mjs

@@ -1,9 +1,30 @@
-export async function revalidatePath(path) {
-  const { revalidatePath: fn } = await import("./core/cache-revalidate.js");
-  return fn(path);
-}
-
-export async function revalidateTag(tag) {
-  const { revalidateTag: fn } = await import("./core/cache-revalidate.js");
-  return fn(tag);
-}
+export async function revalidatePath(path, options) {
+  const { revalidatePath: fn } = await import("./core/cache-revalidate.js");
+  return fn(path, options);
+}
+
+export async function revalidatePage(path) {
+  const { revalidatePage: fn } = await import("./core/cache-revalidate.js");
+  return fn(path);
+}
+
+export async function revalidateTag(tag, options) {
+  const { revalidateTag: fn } = await import("./core/cache-revalidate.js");
+  return fn(tag, options);
+}
+
+export async function DinouCacheSlot(props) {
+  const { DinouCacheSlot: fn } = await import("./core/cache-slot.js");
+  return fn(props);
+}
+
+export {
+  StorageAdapter,
+  FileSystemStorage,
+  CloudflareKVStorage,
+  DenoKVStorage,
+  MemoryStorage,
+  RedisStorage,
+  getStorageAdapter,
+  setStorageAdapter,
+} from "./core/storage-adapter.js";