@mandujs/core 0.53.2 → 0.54.0

package/src/bundler/plugins/react-compiler.ts

@@ -1,162 +1,162 @@
-/**
- * Bundler plugin — React Compiler (#240).
- *
- * Auto-memoizes React components at build time via the official
- * `babel-plugin-react-compiler`. Runs as a Bun `onLoad` transform:
- * source → Babel + react-compiler → transformed code → Bun's remaining
- * pipeline.
- *
- * Ported inline rather than depending on `bun-plugin-react-compiler`
- * (single-maintainer, 9★ at 2026-04). The substantive logic is ~60
- * lines; keeping it in-repo avoids the supply-chain risk without adding
- * real maintenance cost.
- *
- * ## Scope
- *
- * Only invoked by the bundler's island / `"use client"` / partial build
- * paths. Server-rendered files (`page.tsx` + `layout.tsx` SSR) never
- * hit this plugin because React Compiler's memoization is a re-render
- * optimization; SSR renders once and serializes to HTML. See
- * `bundler/build.ts` for the gate.
- *
- * ## Opt-in
- *
- * Disabled by default. Projects enable via `mandu.config.ts`:
- *
- * ```ts
- * export default {
- *   experimental: {
- *     reactCompiler: { enabled: true },
- *   },
- * } satisfies ManduConfig;
- * ```
- *
- * Failure mode: if `@babel/core` or `babel-plugin-react-compiler` are
- * missing, the plugin returns the original source verbatim and logs
- * once per build. This preserves the "enable the flag → try it" UX
- * without blocking anyone who forgot to install the peer deps.
- */
-
-import type { BunPlugin } from "bun";
-import fs from "node:fs/promises";
-
-export interface ReactCompilerPluginOptions {
-  /**
-   * File filter — only matching paths get the transform. Default:
-   * `.jsx` / `.tsx`. The bundler's own client-path gate narrows this
-   * further; the regex here is a belt-and-braces check.
-   */
-  filter?: RegExp;
-  /**
-   * Options forwarded to `babel-plugin-react-compiler`. Common keys:
-   *   - `compilationMode: "annotation" | "infer" | "all"`
-   *   - `target: "19" | "18" | "17"`
-   *   - `panicThreshold: "none" | "all_errors" | "critical_errors"`
-   * Omit to use react-compiler defaults (`compilationMode: "infer"` +
-   * `target` derived from the installed `react` version).
-   */
-  reactCompilerConfig?: Record<string, unknown>;
-}
-
-const DEFAULT_FILTER = /\.(?:jsx|tsx)$/;
-
-/**
- * Create the Bun plugin instance. Dynamic imports inside `onLoad` keep
- * `@babel/core` out of the bundler's import graph when the plugin is
- * never activated — the cost is a one-shot `await import()` on first
- * use, which Bun caches.
- */
-export function reactCompiler(
-  options: ReactCompilerPluginOptions = {},
-): BunPlugin {
-  const filter = options.filter ?? DEFAULT_FILTER;
-  const compilerConfig = options.reactCompilerConfig;
-
-  // `@babel/core` + `babel-plugin-react-compiler` are optional peer
-  // dependencies — keep them out of the type graph so projects that
-  // don't enable the compiler never need `@types/babel__core`.
-  type BabelLike = { transformAsync: (src: string, opts: unknown) => Promise<{ code?: string | null } | null> };
-  let babelMod: BabelLike | null = null;
-  let compilerPlugin: unknown = null;
-  let resolutionFailed = false;
-
-  const resolveBabel = async (): Promise<boolean> => {
-    if (resolutionFailed) return false;
-    if (babelMod && compilerPlugin) return true;
-    try {
-      // Both imports are peerDependencies declared `optional: true` so
-      // projects without React Compiler never pay the install cost. We
-      // import each separately so a missing react-compiler package
-      // doesn't mask a Babel install failure.
-      if (!babelMod) {
-        const mod = (await import(/* @vite-ignore */ "@babel/core" as string)) as unknown as BabelLike;
-        babelMod = mod;
-      }
-      if (!compilerPlugin) {
-        const cm = (await import(/* @vite-ignore */ "babel-plugin-react-compiler" as string)) as unknown as {
-          default?: unknown;
-        };
-        compilerPlugin = cm.default ?? cm;
-      }
-      return true;
-    } catch (err) {
-      resolutionFailed = true;
-      console.warn(
-        "[Mandu React Compiler] Peer dependency missing — skipping transform. " +
-          "Install @babel/core + babel-plugin-react-compiler to enable. " +
-          `Reason: ${err instanceof Error ? err.message : String(err)}`,
-      );
-      return false;
-    }
-  };
-
-  return {
-    name: "mandu:react-compiler",
-    setup(build) {
-      build.onLoad({ filter }, async ({ path: filePath }) => {
-        const ok = await resolveBabel();
-        if (!ok || !babelMod || !compilerPlugin) return undefined;
-
-        let source: string;
-        try {
-          source = await fs.readFile(filePath, "utf-8");
-        } catch {
-          // Bun will surface the original read error when it retries
-          // the load itself; returning undefined gives it the chance.
-          return undefined;
-        }
-
-        try {
-          const result = await babelMod.transformAsync(source, {
-            filename: filePath,
-            sourceMaps: "inline",
-            babelrc: false,
-            configFile: false,
-            parserOpts: {
-              plugins: [
-                "jsx",
-                "typescript",
-                "explicitResourceManagement",
-              ],
-            },
-            plugins: [[compilerPlugin, compilerConfig ?? {}]],
-          });
-          if (!result?.code) return undefined;
-          return {
-            contents: result.code,
-            loader: filePath.endsWith(".tsx") ? "tsx" : "jsx",
-          };
-        } catch (err) {
-          // Return original so Bun falls back to its normal transform —
-          // react-compiler skips plenty of components by design
-          // ("15% bailout") and we don't want a bailout to kill the
-          // build. Log once per file path with the reason.
-          console.warn(
-            `[Mandu React Compiler] skip ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
-          );
-          return undefined;
-        }
-      });
-    },
-  };
-}
+/**
+ * Bundler plugin — React Compiler (#240).
+ *
+ * Auto-memoizes React components at build time via the official
+ * `babel-plugin-react-compiler`. Runs as a Bun `onLoad` transform:
+ * source → Babel + react-compiler → transformed code → Bun's remaining
+ * pipeline.
+ *
+ * Ported inline rather than depending on `bun-plugin-react-compiler`
+ * (single-maintainer, 9★ at 2026-04). The substantive logic is ~60
+ * lines; keeping it in-repo avoids the supply-chain risk without adding
+ * real maintenance cost.
+ *
+ * ## Scope
+ *
+ * Only invoked by the bundler's island / `"use client"` / partial build
+ * paths. Server-rendered files (`page.tsx` + `layout.tsx` SSR) never
+ * hit this plugin because React Compiler's memoization is a re-render
+ * optimization; SSR renders once and serializes to HTML. See
+ * `bundler/build.ts` for the gate.
+ *
+ * ## Opt-in
+ *
+ * Disabled by default. Projects enable via `mandu.config.ts`:
+ *
+ * ```ts
+ * export default {
+ *   experimental: {
+ *     reactCompiler: { enabled: true },
+ *   },
+ * } satisfies ManduConfig;
+ * ```
+ *
+ * Failure mode: if `@babel/core` or `babel-plugin-react-compiler` are
+ * missing, the plugin returns the original source verbatim and logs
+ * once per build. This preserves the "enable the flag → try it" UX
+ * without blocking anyone who forgot to install the peer deps.
+ */
+
+import type { BunPlugin } from "bun";
+import fs from "node:fs/promises";
+
+export interface ReactCompilerPluginOptions {
+  /**
+   * File filter — only matching paths get the transform. Default:
+   * `.jsx` / `.tsx`. The bundler's own client-path gate narrows this
+   * further; the regex here is a belt-and-braces check.
+   */
+  filter?: RegExp;
+  /**
+   * Options forwarded to `babel-plugin-react-compiler`. Common keys:
+   *   - `compilationMode: "annotation" | "infer" | "all"`
+   *   - `target: "19" | "18" | "17"`
+   *   - `panicThreshold: "none" | "all_errors" | "critical_errors"`
+   * Omit to use react-compiler defaults (`compilationMode: "infer"` +
+   * `target` derived from the installed `react` version).
+   */
+  reactCompilerConfig?: Record<string, unknown>;
+}
+
+const DEFAULT_FILTER = /\.(?:jsx|tsx)$/;
+
+/**
+ * Create the Bun plugin instance. Dynamic imports inside `onLoad` keep
+ * `@babel/core` out of the bundler's import graph when the plugin is
+ * never activated — the cost is a one-shot `await import()` on first
+ * use, which Bun caches.
+ */
+export function reactCompiler(
+  options: ReactCompilerPluginOptions = {},
+): BunPlugin {
+  const filter = options.filter ?? DEFAULT_FILTER;
+  const compilerConfig = options.reactCompilerConfig;
+
+  // `@babel/core` + `babel-plugin-react-compiler` are optional peer
+  // dependencies — keep them out of the type graph so projects that
+  // don't enable the compiler never need `@types/babel__core`.
+  type BabelLike = { transformAsync: (src: string, opts: unknown) => Promise<{ code?: string | null } | null> };
+  let babelMod: BabelLike | null = null;
+  let compilerPlugin: unknown = null;
+  let resolutionFailed = false;
+
+  const resolveBabel = async (): Promise<boolean> => {
+    if (resolutionFailed) return false;
+    if (babelMod && compilerPlugin) return true;
+    try {
+      // Both imports are peerDependencies declared `optional: true` so
+      // projects without React Compiler never pay the install cost. We
+      // import each separately so a missing react-compiler package
+      // doesn't mask a Babel install failure.
+      if (!babelMod) {
+        const mod = (await import(/* @vite-ignore */ "@babel/core" as string)) as unknown as BabelLike;
+        babelMod = mod;
+      }
+      if (!compilerPlugin) {
+        const cm = (await import(/* @vite-ignore */ "babel-plugin-react-compiler" as string)) as unknown as {
+          default?: unknown;
+        };
+        compilerPlugin = cm.default ?? cm;
+      }
+      return true;
+    } catch (err) {
+      resolutionFailed = true;
+      console.warn(
+        "[Mandu React Compiler] Peer dependency missing — skipping transform. " +
+          "Install @babel/core + babel-plugin-react-compiler to enable. " +
+          `Reason: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      return false;
+    }
+  };
+
+  return {
+    name: "mandu:react-compiler",
+    setup(build) {
+      build.onLoad({ filter }, async ({ path: filePath }) => {
+        const ok = await resolveBabel();
+        if (!ok || !babelMod || !compilerPlugin) return undefined;
+
+        let source: string;
+        try {
+          source = await fs.readFile(filePath, "utf-8");
+        } catch {
+          // Bun will surface the original read error when it retries
+          // the load itself; returning undefined gives it the chance.
+          return undefined;
+        }
+
+        try {
+          const result = await babelMod.transformAsync(source, {
+            filename: filePath,
+            sourceMaps: "inline",
+            babelrc: false,
+            configFile: false,
+            parserOpts: {
+              plugins: [
+                "jsx",
+                "typescript",
+                "explicitResourceManagement",
+              ],
+            },
+            plugins: [[compilerPlugin, compilerConfig ?? {}]],
+          });
+          if (!result?.code) return undefined;
+          return {
+            contents: result.code,
+            loader: filePath.endsWith(".tsx") ? "tsx" : "jsx",
+          };
+        } catch (err) {
+          // Return original so Bun falls back to its normal transform —
+          // react-compiler skips plenty of components by design
+          // ("15% bailout") and we don't want a bailout to kill the
+          // build. Log once per file path with the reason.
+          console.warn(
+            `[Mandu React Compiler] skip ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+          );
+          return undefined;
+        }
+      });
+    },
+  };
+}