vinext 1.0.0-beta.7 → 1.0.0-beta.8

package/README.md

@@ -606,6 +606,33 @@ Every `next/*` import is shimmed to a Vite-compatible implementation.
 | `images` config                                  | 🟡  | Parsed but not used for optimization                                                                                                                                                                                   |
 | `experimental.optimizePackageImports`            | ✅  | Rewrites barrel imports to direct sub-module imports in RSC/SSR environments. A default set (lucide-react, date-fns, radix-ui, antd, MUI, and others) are always optimized. Add package names here to extend the list. |
 | `vinext({ nextConfig })`                         | ✅  | Inline Next-style config from `vite.config.*`. Supports object-form and function-form config. When provided, this overrides root `next.config.*`.                                                                      |
+| `vinext({ react: { compiler: true } })`          | ✅  | React Compiler auto memoization. Needs `@vitejs/plugin-react` 6.1+ and the optional `oxc-transform-react` package.                                                                                                     |
+
+### React Compiler
+
+vinext auto-registers `@vitejs/plugin-react`, so the React Compiler is enabled through the same `react` option:
+
+```ts
+import { defineConfig } from "vite";
+import vinext from "vinext";
+
+export default defineConfig({
+  plugins: [vinext({ react: { compiler: true } })],
+});
+```
+
+The transform itself ships separately, so install it alongside:
+
+```bash
+npm install -D oxc-transform-react
+```
+
+This requires `@vitejs/plugin-react` 6.1.0 or newer. Older versions accept the option and drop it, so vinext fails with an actionable error instead of leaving the compiler silently disabled. The compiler runs on the client environment only.
+
+One caveat: modules whose JSX is lowered earlier in the pipeline are not memoized. Those build and behave correctly, they just miss auto memoization:
+
+- JSX in plain `.js` files, which `vinext:jsx-in-js` compiles first so the compiler can parse them at all. Rename to `.jsx` or `.tsx` to get memoization.
+- Components using `<style jsx>`, which `vinext:styled-jsx` compiles through the Next.js SWC transform before the compiler runs.
 
 ### Environment variable loading (`.env*`)
 

package/dist/index.d.ts

@@ -61,6 +61,9 @@ type VinextOptions = {
    * Enabled by default. Set to `false` to disable (e.g. if you configure
    * @vitejs/plugin-react manually in your vite.config.ts), or pass an options
    * object to customize the Babel transform.
+   *
+   * Pass `{ compiler: true }` to enable the React Compiler. That requires
+   * @vitejs/plugin-react 6.1+ and the optional `oxc-transform-react` package.
    * @default true
    */
   react?: Options | boolean;

package/dist/index.js

@@ -55,6 +55,7 @@ import { readTrustedRevalidationHostname } from "./server/revalidation-host.js";
 import { installDevStackSourcemapMiddleware } from "./server/dev-stack-sourcemap.js";
 import { runPagesRequest } from "./server/pages-request-pipeline.js";
 import { pagesRouteHasPriorityOverAppRoute, validateHybridRouteConflicts } from "./server/hybrid-route-priority.js";
+import { hasReactCompilerPlugin, isReactCompilerPlugin, isReactCompilerRequested, reactCompilerUnsupportedMessage } from "./utils/react-compiler-support.js";
 import { VIRTUAL_MODULE_ID_RE } from "./utils/virtual-module.js";
 import { assertNoPublicDirAssetConflict, assertNoPublicNextRequestConflict } from "./build/public-dir-conflict.js";
 import { renderVinextBuiltUrl } from "./utils/built-asset-url.js";
@@ -915,9 +916,12 @@ function vinext(options = {}) {
 	const configuredReactOptions = options.react && options.react !== true ? options.react : void 0;
 	const reactOptions = configuredReactOptions;
 	let reactPluginPromise = null;
+	let reactCompilerPluginPromise = null;
 	if (options.react !== false) {
 		if (!resolvedReactPath) throw new Error("vinext: @vitejs/plugin-react is not installed.\nRun: " + detectPackageManager(process.cwd()) + " @vitejs/plugin-react");
-		reactPluginPromise = import(pathToFileURL(resolvedReactPath).href).then((mod) => {
+		const allReactPlugins = import(pathToFileURL(resolvedReactPath).href).catch((cause) => {
+			throw new Error("vinext: Failed to load @vitejs/plugin-react.", { cause });
+		}).then((mod) => {
 			const react = mod.default;
 			const limitToCommand = (plugin, command) => {
 				const originalApply = plugin.apply;
@@ -931,15 +935,17 @@ function vinext(options = {}) {
 					}
 				};
 			};
-			const buildPlugins = react(reactOptions).map((plugin) => limitToCommand(plugin, "build"));
+			const resolvedBuildPlugins = react(reactOptions);
+			if (isReactCompilerRequested(configuredReactOptions) && !hasReactCompilerPlugin(resolvedBuildPlugins)) throw new Error(reactCompilerUnsupportedMessage(detectPackageManager(process.cwd())));
+			const buildPlugins = resolvedBuildPlugins.map((plugin) => limitToCommand(plugin, "build"));
 			const servePlugins = react(configuredReactOptions !== void 0 && Object.prototype.hasOwnProperty.call(configuredReactOptions, "include") ? reactOptions : {
 				...reactOptions,
 				include: /\.(?:[tj]sx?|mdx)$/i
 			}).map((plugin) => limitToCommand(plugin, "serve"));
 			return [...buildPlugins, ...servePlugins];
-		}).catch((cause) => {
-			throw new Error("vinext: Failed to load @vitejs/plugin-react.", { cause });
 		});
+		reactPluginPromise = allReactPlugins.then((plugins) => plugins.filter((plugin) => !isReactCompilerPlugin(plugin)));
+		reactCompilerPluginPromise = allReactPlugins.then((plugins) => plugins.filter(isReactCompilerPlugin));
 	}
 	const imageImportDimCache = /* @__PURE__ */ new Map();
 	const staticImageAssets = /* @__PURE__ */ new Map();
@@ -1075,6 +1081,7 @@ function vinext(options = {}) {
 				}
 			}
 		},
+		reactCompilerPluginPromise,
 		createMiddlewareServerOnlyPlugin({
 			getMiddlewarePath: () => middlewarePath,
 			getCanonicalMiddlewarePath: () => middlewarePath ? tryRealpathSync(middlewarePath) ?? middlewarePath : null,

package/dist/plugins/import-meta-url.js

@@ -205,10 +205,11 @@ function finalizeEmittedModuleIdentity(code, emittedIdentitySentinels, fileName)
 	const urlNamespaceBinding = selectRuntimeBinding("__vinext_module_url");
 	const identityBinding = selectRuntimeBinding("__vinext_module_identity");
 	const emittedFileName = toSlash(fileName).replace(/^\.\//, "").replace(/^\/+/, "");
-	const processCwd = `${processNamespaceBinding}.cwd()`;
-	const emittedPathFallback = emittedFileName ? `(${processCwd}.replace(/[\\\\/]$/, "") + ${JSON.stringify(`/${emittedFileName}`)})` : processCwd;
+	const processCwd = `(typeof ${processNamespaceBinding}.cwd === "function" ? ${processNamespaceBinding}.cwd() : "")`;
+	const emittedPathFallback = emittedFileName ? `(${processCwd}.replace(/[\\\\/]$/, "") + ${JSON.stringify(`/${emittedFileName}`)})` : `(${processCwd} || "/")`;
 	const emittedDirName = path.dirname(emittedFileName);
-	const emittedDirFallback = emittedDirName === "." ? processCwd : `(${processCwd}.replace(/[\\\\/]$/, "") + ${JSON.stringify(`/${emittedDirName}`)})`;
+	const emittedDirFallback = emittedDirName === "." ? `(${processCwd} || "/")` : `(${processCwd}.replace(/[\\\\/]$/, "") + ${JSON.stringify(`/${emittedDirName}`)})`;
+	const absoluteEmittedPath = JSON.stringify(`/${emittedFileName}`.replace(/\/$/, "") || "/");
 	const replacements = {
 		__filename: `${identityBinding}.filename`,
 		__dirname: `${identityBinding}.dirname`,
@@ -230,7 +231,7 @@ function finalizeEmittedModuleIdentity(code, emittedIdentitySentinels, fileName)
 	const needsUrl = usedFields.has("url");
 	const needsPath = usedFields.has("__filename") || usedFields.has("__dirname");
 	const runtimePreamble = [
-		`import * as ${processNamespaceBinding} from "node:process";`,
+		...needsPath ? [`import * as ${processNamespaceBinding} from "node:process";`] : [],
 		...needsPath ? [`import * as ${fsNamespaceBinding} from "node:fs";`] : [],
 		...needsUrl ? [`import * as ${urlNamespaceBinding} from "node:url";`] : [],
 		`const ${identityBinding} = (() => {`,
@@ -238,10 +239,10 @@ function finalizeEmittedModuleIdentity(code, emittedIdentitySentinels, fileName)
 			`  const filename = import.meta.filename;`,
 			`  const native = typeof filename === "string" && ${fsNamespaceBinding}.existsSync(filename);`,
 			`  const resolvedFilename = native ? filename : ${emittedPathFallback};`
-		] : [`  const runtimeUrl = import.meta.url;`],
+		] : [`  const runtimeUrl = import.meta.url;`, `  const runtimeFilename = import.meta.filename;`],
 		`  return {`,
 		...needsPath ? [`    filename: resolvedFilename,`, `    dirname: native ? import.meta.dirname : ${emittedDirFallback},`] : [],
-		...needsUrl ? [needsPath ? `    url: ${urlNamespaceBinding}.pathToFileURL(resolvedFilename).href,` : `    url: typeof runtimeUrl === "string" && runtimeUrl.startsWith("file:") ? runtimeUrl : ${urlNamespaceBinding}.pathToFileURL(${emittedPathFallback}).href,`] : [],
+		...needsUrl ? [needsPath ? `    url: ${urlNamespaceBinding}.pathToFileURL(resolvedFilename).href,` : `    url: typeof runtimeUrl === "string" && runtimeUrl.startsWith("file:") ? runtimeUrl : ${urlNamespaceBinding}.pathToFileURL(typeof runtimeFilename === "string" ? runtimeFilename : ${absoluteEmittedPath}).href,`] : [],
 		`  };`,
 		`})();`,
 		""

package/dist/utils/react-compiler-support.d.ts

@@ -0,0 +1,20 @@
+//#region src/utils/react-compiler-support.d.ts
+/**
+ * The React Compiler option landed in @vitejs/plugin-react 6.1. Older versions
+ * accept an unknown `compiler` key in their options object and silently drop
+ * it, which would leave the compiler disabled while the config says otherwise.
+ *
+ * The plugin factory only returns `vite:react-compiler` when the installed
+ * version understands the option, so its presence is what we probe for.
+ */
+declare const REACT_COMPILER_PLUGIN_NAME = "vite:react-compiler";
+/** Whether the user asked for the React Compiler through vinext's `react` option. */
+declare function isReactCompilerRequested(reactOptions: unknown): boolean;
+/** Whether a plugin entry is the React Compiler plugin. */
+declare function isReactCompilerPlugin(plugin: unknown): boolean;
+/** Whether the resolved @vitejs/plugin-react actually registered the compiler. */
+declare function hasReactCompilerPlugin(plugins: readonly unknown[]): boolean;
+/** Message for when `react: { compiler: true }` cannot be honored. */
+declare function reactCompilerUnsupportedMessage(installCommand: string): string;
+//#endregion
+export { REACT_COMPILER_PLUGIN_NAME, hasReactCompilerPlugin, isReactCompilerPlugin, isReactCompilerRequested, reactCompilerUnsupportedMessage };

package/dist/utils/react-compiler-support.js

@@ -0,0 +1,29 @@
+//#region src/utils/react-compiler-support.ts
+/**
+* The React Compiler option landed in @vitejs/plugin-react 6.1. Older versions
+* accept an unknown `compiler` key in their options object and silently drop
+* it, which would leave the compiler disabled while the config says otherwise.
+*
+* The plugin factory only returns `vite:react-compiler` when the installed
+* version understands the option, so its presence is what we probe for.
+*/
+const REACT_COMPILER_PLUGIN_NAME = "vite:react-compiler";
+/** Whether the user asked for the React Compiler through vinext's `react` option. */
+function isReactCompilerRequested(reactOptions) {
+	if (!reactOptions || typeof reactOptions !== "object") return false;
+	return Boolean(reactOptions.compiler);
+}
+/** Whether a plugin entry is the React Compiler plugin. */
+function isReactCompilerPlugin(plugin) {
+	return typeof plugin === "object" && plugin !== null && plugin.name === "vite:react-compiler";
+}
+/** Whether the resolved @vitejs/plugin-react actually registered the compiler. */
+function hasReactCompilerPlugin(plugins) {
+	return plugins.some(isReactCompilerPlugin);
+}
+/** Message for when `react: { compiler: true }` cannot be honored. */
+function reactCompilerUnsupportedMessage(installCommand) {
+	return "vinext: `react: { compiler: true }` requires @vitejs/plugin-react 6.1 or newer.\nThe installed version ignores the option, which would leave the React Compiler disabled.\nRun: " + installCommand + " @vitejs/plugin-react@latest";
+}
+//#endregion
+export { REACT_COMPILER_PLUGIN_NAME, hasReactCompilerPlugin, isReactCompilerPlugin, isReactCompilerRequested, reactCompilerUnsupportedMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.8",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -182,7 +182,7 @@
     "@types/node": "^25.9.2",
     "@types/react": "^19.2.16",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^6.0.1",
+    "@vitejs/plugin-react": "^6.1.0",
     "@vitejs/plugin-rsc": "^0.5.34",
     "am-i-vibing": "^0.5.0",
     "image-size": "2.0.2",