@vitejs/plugin-react 1.3.2 → 2.0.0-alpha.2

package/dist/{index.js → index.cjs}

@@ -1,191 +1,37 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/jsx-runtime/babel-restore-jsx.ts
-var babel_restore_jsx_exports = {};
-__export(babel_restore_jsx_exports, {
-  default: () => babel_restore_jsx_default
-});
-function babel_restore_jsx_default({ types: t }) {
-  function getJSXNode(node) {
-    if (!isReactCreateElement(node)) {
-      return null;
-    }
-    const [nameNode, propsNode, ...childNodes] = node.arguments;
-    const name = getJSXName(nameNode);
-    if (name == null) {
-      return null;
-    }
-    const props = getJSXProps(propsNode);
-    if (props == null) {
-      return null;
-    }
-    const children = getJSXChildren(childNodes);
-    if (children == null) {
-      return null;
-    }
-    if (t.isJSXMemberExpression(name) && t.isJSXIdentifier(name.object) && name.object.name === "React" && name.property.name === "Fragment") {
-      return t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), children);
-    }
-    const selfClosing = children.length === 0;
-    const startTag = t.jsxOpeningElement(name, props, selfClosing);
-    startTag.loc = node.loc;
-    const endTag = selfClosing ? null : t.jsxClosingElement(name);
-    return t.jsxElement(startTag, endTag, children, selfClosing);
-  }
-  function getJSXName(node) {
-    if (node == null) {
-      return null;
-    }
-    const name = getJSXIdentifier(node, true);
-    if (name != null) {
-      return name;
-    }
-    if (!t.isMemberExpression(node)) {
-      return null;
-    }
-    const object = getJSXName(node.object);
-    const property = getJSXName(node.property);
-    if (object == null || property == null) {
-      return null;
-    }
-    return t.jsxMemberExpression(object, property);
-  }
-  function getJSXProps(node) {
-    if (node == null || isNullLikeNode(node)) {
-      return [];
-    }
-    if (t.isCallExpression(node) && t.isIdentifier(node.callee, { name: "_extends" })) {
-      const props = node.arguments.map(getJSXProps);
-      if (props.every((prop) => prop != null)) {
-        return [].concat(...props);
-      }
-    }
-    if (!t.isObjectExpression(node) && t.isExpression(node))
-      return [t.jsxSpreadAttribute(node)];
-    if (!isPlainObjectExpression(node)) {
-      return null;
-    }
-    return node.properties.map((prop) => t.isObjectProperty(prop) ? t.jsxAttribute(getJSXIdentifier(prop.key), getJSXAttributeValue(prop.value)) : t.jsxSpreadAttribute(prop.argument));
-  }
-  function getJSXChild(node) {
-    if (t.isStringLiteral(node)) {
-      return t.jsxText(node.value);
-    }
-    if (isReactCreateElement(node)) {
-      return getJSXNode(node);
-    }
-    if (t.isExpression(node)) {
-      return t.jsxExpressionContainer(node);
-    }
-    return null;
-  }
-  function getJSXChildren(nodes) {
-    const children = nodes.filter((node) => !isNullLikeNode(node)).map(getJSXChild);
-    if (children.some((child) => child == null)) {
-      return null;
-    }
-    return children;
-  }
-  function getJSXIdentifier(node, tag = false) {
-    if (t.isIdentifier(node) && (!tag || node.name.match(/^[A-Z]/))) {
-      return t.jsxIdentifier(node.name);
-    }
-    if (t.isStringLiteral(node)) {
-      return t.jsxIdentifier(node.value);
-    }
-    return null;
-  }
-  function getJSXAttributeValue(node) {
-    if (t.isStringLiteral(node)) {
-      return node;
-    }
-    if (t.isJSXElement(node)) {
-      return node;
-    }
-    if (t.isExpression(node)) {
-      return t.jsxExpressionContainer(node);
+const path = require('path');
+const babel = require('@babel/core');
+const pluginutils = require('@rollup/pluginutils');
+const vite = require('vite');
+const fs = require('fs');
+const module$1 = require('module');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
     }
-    return null;
   }
-  const isReactCreateElement = (node) => t.isCallExpression(node) && t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object, { name: "React" }) && t.isIdentifier(node.callee.property, { name: "createElement" }) && !node.callee.computed;
-  const isNullLikeNode = (node) => t.isNullLiteral(node) || t.isIdentifier(node, { name: "undefined" });
-  const isPlainObjectExpression = (node) => t.isObjectExpression(node) && node.properties.every((property) => t.isSpreadElement(property) || t.isObjectProperty(property, { computed: false }) && getJSXIdentifier(property.key) != null && getJSXAttributeValue(property.value) != null);
-  return {
-    visitor: {
-      CallExpression(path2) {
-        const node = getJSXNode(path2.node);
-        if (node == null) {
-          return null;
-        }
-        path2.replaceWith(node);
-      }
-    }
-  };
+  n["default"] = e;
+  return n;
 }
-var init_babel_restore_jsx = __esm({
-  "src/jsx-runtime/babel-restore-jsx.ts"() {
-  }
-});
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => viteReact
-});
-module.exports = viteReact;
-viteReact['default'] = viteReact;
-var babel = __toESM(require("@babel/core"));
-var import_pluginutils = require("@rollup/pluginutils");
-var import_resolve = __toESM(require("resolve"));
+const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+const babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 
-// src/fast-refresh.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var runtimePublicPath = "/@react-refresh";
-var reactRefreshDir = import_path.default.dirname(require.resolve("react-refresh/package.json"));
-var runtimeFilePath = import_path.default.join(reactRefreshDir, "cjs/react-refresh-runtime.development.js");
-var runtimeCode = `
+const runtimePublicPath = "/@react-refresh";
+const _require = module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href)));
+const reactRefreshDir = path__default.dirname(_require.resolve("react-refresh/package.json"));
+const runtimeFilePath = path__default.join(reactRefreshDir, "cjs/react-refresh-runtime.development.js");
+const runtimeCode = `
 const exports = {}
-${import_fs.default.readFileSync(runtimeFilePath, "utf-8")}
+${fs__default.readFileSync(runtimeFilePath, "utf-8")}
 function debounce(fn, delay) {
   let handle
   return () => {
@@ -196,14 +42,14 @@ function debounce(fn, delay) {
 exports.performReactRefresh = debounce(exports.performReactRefresh, 16)
 export default exports
 `;
-var preambleCode = `
+const preambleCode = `
 import RefreshRuntime from "__BASE__${runtimePublicPath.slice(1)}"
 RefreshRuntime.injectIntoGlobalHook(window)
 window.$RefreshReg$ = () => {}
 window.$RefreshSig$ = () => (type) => type
 window.__vite_plugin_react_preamble_installed__ = true
 `;
-var header = `
+const header = `
 import RefreshRuntime from "${runtimePublicPath}";
 
 let prevRefreshReg;
@@ -224,7 +70,7 @@ if (import.meta.hot) {
   };
   window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
 }`.replace(/[\n]+/gm, "");
-var footer = `
+const footer = `
 if (import.meta.hot) {
   window.$RefreshReg$ = prevRefreshReg;
   window.$RefreshSig$ = prevRefreshSig;
@@ -266,14 +112,13 @@ function isComponentLikeName(name) {
   return typeof name === "string" && name[0] >= "A" && name[0] <= "Z";
 }
 
-// src/jsx-runtime/babel-import-to-require.ts
 function babelImportToRequire({ types: t }) {
   return {
     visitor: {
-      ImportDeclaration(path2) {
-        const decl = path2.node;
+      ImportDeclaration(path) {
+        const decl = path.node;
         const spec = decl.specifiers[0];
-        path2.replaceWith(t.variableDeclaration("var", [
+        path.replaceWith(t.variableDeclaration("var", [
           t.variableDeclarator(spec.local, t.memberExpression(t.callExpression(t.identifier("require"), [decl.source]), spec.imported))
         ]));
       }
@@ -281,13 +126,19 @@ function babelImportToRequire({ types: t }) {
   };
 }
 
-// src/jsx-runtime/restore-jsx.ts
-var babelRestoreJSX;
-var jsxNotFound = [null, false];
-async function restoreJSX(babel2, code, filename) {
-  if (filename.includes("/.vite/react-dom.js")) {
-    return jsxNotFound;
-  }
+let babelRestoreJSX;
+const jsxNotFound = [null, false];
+async function getBabelRestoreJSX() {
+  if (!babelRestoreJSX)
+    babelRestoreJSX = import('./chunks/babel-restore-jsx.cjs').then((r) => {
+      const fn = r.default;
+      if ("default" in fn)
+        return fn.default;
+      return fn;
+    });
+  return babelRestoreJSX;
+}
+async function restoreJSX(babel, code, filename) {
   const [reactAlias, isCommonJS] = parseReactAlias(code);
   if (!reactAlias) {
     return jsxNotFound;
@@ -308,8 +159,7 @@ async function restoreJSX(babel2, code, filename) {
   if (!hasCompiledJsx) {
     return jsxNotFound;
   }
-  babelRestoreJSX || (babelRestoreJSX = Promise.resolve().then(() => (init_babel_restore_jsx(), babel_restore_jsx_exports)));
-  const result = await babel2.transformAsync(code, {
+  const result = await babel.transformAsync(code, {
     babelrc: false,
     configFile: false,
     ast: true,
@@ -318,9 +168,9 @@ async function restoreJSX(babel2, code, filename) {
     parserOpts: {
       plugins: ["jsx"]
     },
-    plugins: [(await babelRestoreJSX).default]
+    plugins: [await getBabelRestoreJSX()]
   });
-  return [result == null ? void 0 : result.ast, isCommonJS];
+  return [result?.ast, isCommonJS];
 }
 function parseReactAlias(code) {
   let match = code.match(/\b(var|let|const) +(\w+) *= *require\(["']react["']\)/);
@@ -334,25 +184,17 @@ function parseReactAlias(code) {
   return [void 0, false];
 }
 
-// src/index.ts
 function viteReact(opts = {}) {
-  var _a;
   let base = "/";
-  let filter = (0, import_pluginutils.createFilter)(opts.include, opts.exclude);
+  let resolvedCacheDir;
+  let filter = pluginutils.createFilter(opts.include, opts.exclude);
   let isProduction = true;
   let projectRoot = process.cwd();
   let skipFastRefresh = opts.fastRefresh === false;
   let skipReactImport = false;
+  let runPluginOverrides = (options, context) => false;
+  let staticBabelOptions;
   const useAutomaticRuntime = opts.jsxRuntime !== "classic";
-  const babelOptions = __spreadValues({
-    babelrc: false,
-    configFile: false
-  }, opts.babel);
-  babelOptions.plugins || (babelOptions.plugins = []);
-  babelOptions.presets || (babelOptions.presets = []);
-  babelOptions.overrides || (babelOptions.overrides = []);
-  babelOptions.parserOpts || (babelOptions.parserOpts = {});
-  (_a = babelOptions.parserOpts).plugins || (_a.plugins = opts.parserPlugins || []);
   const importReactRE = /(^|\n)import\s+(\*\s+as\s+)?React(,|\s+)/;
   const fileExtensionRE = /\.[^\/\s\?]+$/;
   const viteBabel = {
@@ -361,7 +203,8 @@ function viteReact(opts = {}) {
     configResolved(config) {
       base = config.base;
       projectRoot = config.root;
-      filter = (0, import_pluginutils.createFilter)(opts.include, opts.exclude, {
+      resolvedCacheDir = vite.normalizePath(path__default.resolve(config.cacheDir));
+      filter = pluginutils.createFilter(opts.include, opts.exclude, {
         resolve: projectRoot
       });
       isProduction = config.isProduction;
@@ -372,23 +215,41 @@ function viteReact(opts = {}) {
         config.logger.warn("[@vitejs/plugin-react] This plugin imports React for you automatically, so you can stop using `esbuild.jsxInject` for that purpose.");
       }
       config.plugins.forEach((plugin) => {
-        var _a2;
         const hasConflict = plugin.name === "react-refresh" || plugin !== viteReactJsx && plugin.name === "vite:react-jsx";
         if (hasConflict)
           return config.logger.warn(`[@vitejs/plugin-react] You should stop using "${plugin.name}" since this plugin conflicts with it.`);
-        if ((_a2 = plugin.api) == null ? void 0 : _a2.reactBabel) {
-          plugin.api.reactBabel(babelOptions, config);
-        }
       });
+      runPluginOverrides = (babelOptions, context) => {
+        const hooks = config.plugins.map((plugin) => plugin.api?.reactBabel).filter(Boolean);
+        if (hooks.length > 0) {
+          return (runPluginOverrides = (babelOptions2) => {
+            hooks.forEach((hook) => hook(babelOptions2, context, config));
+            return true;
+          })(babelOptions);
+        }
+        runPluginOverrides = () => false;
+        return false;
+      };
     },
     async transform(code, id, options) {
-      const ssr = typeof options === "boolean" ? options : (options == null ? void 0 : options.ssr) === true;
+      const ssr = typeof options === "boolean" ? options : options?.ssr === true;
       const [filepath, querystring = ""] = id.split("?");
       const [extension = ""] = querystring.match(fileExtensionRE) || filepath.match(fileExtensionRE) || [];
       if (/\.(mjs|[tj]sx?)$/.test(extension)) {
         const isJSX = extension.endsWith("x");
         const isNodeModules = id.includes("/node_modules/");
         const isProjectFile = !isNodeModules && (id[0] === "\0" || id.startsWith(projectRoot + "/"));
+        let babelOptions = staticBabelOptions;
+        if (typeof opts.babel === "function") {
+          const rawOptions = opts.babel(id, { ssr });
+          babelOptions = createBabelOptions(rawOptions);
+          runPluginOverrides(babelOptions, { ssr, id });
+        } else if (!babelOptions) {
+          babelOptions = createBabelOptions(opts.babel);
+          if (!runPluginOverrides(babelOptions, { ssr, id })) {
+            staticBabelOptions = babelOptions;
+          }
+        }
         const plugins = isProjectFile ? [...babelOptions.plugins] : [];
         let useFastRefresh = false;
         if (!skipFastRefresh && !ssr && !isNodeModules) {
@@ -404,7 +265,8 @@ function viteReact(opts = {}) {
         let ast;
         if (!isProjectFile || isJSX) {
           if (useAutomaticRuntime) {
-            const [restoredAst, isCommonJS] = !isProjectFile && !isJSX ? await restoreJSX(babel, code, id) : [null, false];
+            const isOptimizedReactDom = id.startsWith(resolvedCacheDir) && id.includes("/react-dom.js");
+            const [restoredAst, isCommonJS] = !isProjectFile && !isJSX && !isOptimizedReactDom ? await restoreJSX(babel__namespace, code, id) : [null, false];
             if (isJSX || (ast = restoredAst)) {
               plugins.push([
                 await loadPlugin("@babel/plugin-transform-react-jsx" + (isProduction ? "" : "-development")),
@@ -445,25 +307,28 @@ function viteReact(opts = {}) {
         if (/\.tsx?$/.test(extension)) {
           parserPlugins.push("typescript");
         }
-        const transformAsync2 = ast ? babel.transformFromAstAsync.bind(babel, ast, code) : babel.transformAsync.bind(babel, code);
+        const transformAsync = ast ? babel__namespace.transformFromAstAsync.bind(babel__namespace, ast, code) : babel__namespace.transformAsync.bind(babel__namespace, code);
         const isReasonReact = extension.endsWith(".bs.js");
-        const result = await transformAsync2(__spreadProps(__spreadValues({}, babelOptions), {
+        const result = await transformAsync({
+          ...babelOptions,
           ast: !isReasonReact,
           root: projectRoot,
           filename: id,
           sourceFileName: filepath,
-          parserOpts: __spreadProps(__spreadValues({}, babelOptions.parserOpts), {
+          parserOpts: {
+            ...babelOptions.parserOpts,
             sourceType: "module",
             allowAwaitOutsideFunction: true,
             plugins: parserPlugins
-          }),
-          generatorOpts: __spreadProps(__spreadValues({}, babelOptions.generatorOpts), {
+          },
+          generatorOpts: {
+            ...babelOptions.generatorOpts,
             decoratorsBeforeExport: true
-          }),
+          },
           plugins,
           sourceMaps: true,
           inputSourceMap: false
-        }));
+        });
         if (result) {
           let code2 = result.code;
           if (useFastRefresh && /\$RefreshReg\$\(/.test(code2)) {
@@ -507,7 +372,6 @@ function viteReact(opts = {}) {
         ];
     }
   };
-  const runtimeId = "react/jsx-runtime";
   const viteReactJsx = {
     name: "vite:react-jsx",
     enforce: "pre",
@@ -517,32 +381,28 @@ function viteReact(opts = {}) {
           include: ["react/jsx-dev-runtime"]
         }
       };
-    },
-    resolveId(id) {
-      return id === runtimeId ? id : null;
-    },
-    load(id) {
-      if (id === runtimeId) {
-        const runtimePath = import_resolve.default.sync(runtimeId, {
-          basedir: projectRoot
-        });
-        const exports = ["jsx", "jsxs", "Fragment"];
-        return [
-          `import * as jsxRuntime from ${JSON.stringify(runtimePath)}`,
-          ...exports.map((name) => `export const ${name} = jsxRuntime.${name}`)
-        ].join("\n");
-      }
     }
   };
   return [viteBabel, viteReactRefresh, useAutomaticRuntime && viteReactJsx];
 }
 viteReact.preambleCode = preambleCode;
 function loadPlugin(path2) {
-  return Promise.resolve().then(() => __toESM(require(path2))).then((module2) => module2.default || module2);
+  return import(path2).then((module) => module.default || module);
+}
+function createBabelOptions(rawOptions) {
+  var _a;
+  const babelOptions = {
+    babelrc: false,
+    configFile: false,
+    ...rawOptions
+  };
+  babelOptions.plugins || (babelOptions.plugins = []);
+  babelOptions.presets || (babelOptions.presets = []);
+  babelOptions.overrides || (babelOptions.overrides = []);
+  babelOptions.parserOpts || (babelOptions.parserOpts = {});
+  (_a = babelOptions.parserOpts).plugins || (_a.plugins = []);
+  return babelOptions;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
-/**
- * https://github.com/flying-sheep/babel-plugin-transform-react-createelement-to-jsx
- * @license GNU General Public License v3.0
- */
+
+module.exports = viteReact;
+module.exports["default"] = viteReact;

package/dist/index.d.ts

@@ -1,62 +1,69 @@
-import type { ParserOptions } from '@babel/core';
-import type { PluginOption } from 'vite';
-import type { TransformOptions } from '@babel/core';
-
-export declare type BabelOptions = Omit<TransformOptions, 'ast' | 'filename' | 'root' | 'sourceFileName' | 'sourceMaps' | 'inputSourceMap'>;
-
-export declare interface Options {
-    include?: string | RegExp | Array<string | RegExp>;
-    exclude?: string | RegExp | Array<string | RegExp>;
-    /**
-     * Enable `react-refresh` integration. Vite disables this in prod env or build mode.
-     * @default true
-     */
-    fastRefresh?: boolean;
-    /**
-     * Set this to `"automatic"` to use [vite-react-jsx](https://github.com/alloc/vite-react-jsx).
-     * @default "automatic"
-     */
-    jsxRuntime?: 'classic' | 'automatic';
-    /**
-     * Control where the JSX factory is imported from.
-     * This option is ignored when `jsxRuntime` is not `"automatic"`.
-     * @default "react"
-     */
-    jsxImportSource?: string;
-    /**
-     * Set this to `true` to annotate the JSX factory with `\/* @__PURE__ *\/`.
-     * This option is ignored when `jsxRuntime` is not `"automatic"`.
-     * @default true
-     */
-    jsxPure?: boolean;
-    /**
-     * Babel configuration applied in both dev and prod.
-     */
-    babel?: BabelOptions;
-    /**
-     * @deprecated Use `babel.parserOpts.plugins` instead
-     */
-    parserPlugins?: ParserOptions['plugins'];
-}
-
-/**
- * The object type used by the `options` passed to plugins with
- * an `api.reactBabel` method.
- */
-export declare interface ReactBabelOptions extends BabelOptions {
-    plugins: Extract<BabelOptions['plugins'], any[]>;
-    presets: Extract<BabelOptions['presets'], any[]>;
-    overrides: Extract<BabelOptions['overrides'], any[]>;
-    parserOpts: ParserOptions & {
-        plugins: Extract<ParserOptions['plugins'], any[]>;
-    };
-}
-
-declare function viteReact(opts?: Options): PluginOption[];
-
-declare namespace viteReact {
-    var preambleCode: string;
-}
-export default viteReact;
-
-export { }
+import { TransformOptions, ParserOptions } from '@babel/core';
+import { ResolvedConfig, PluginOption } from 'vite';
+
+interface Options {
+    include?: string | RegExp | Array<string | RegExp>;
+    exclude?: string | RegExp | Array<string | RegExp>;
+    /**
+     * Enable `react-refresh` integration. Vite disables this in prod env or build mode.
+     * @default true
+     */
+    fastRefresh?: boolean;
+    /**
+     * Set this to `"automatic"` to use [vite-react-jsx](https://github.com/alloc/vite-react-jsx).
+     * @default "automatic"
+     */
+    jsxRuntime?: 'classic' | 'automatic';
+    /**
+     * Control where the JSX factory is imported from.
+     * This option is ignored when `jsxRuntime` is not `"automatic"`.
+     * @default "react"
+     */
+    jsxImportSource?: string;
+    /**
+     * Set this to `true` to annotate the JSX factory with `\/* @__PURE__ *\/`.
+     * This option is ignored when `jsxRuntime` is not `"automatic"`.
+     * @default true
+     */
+    jsxPure?: boolean;
+    /**
+     * Babel configuration applied in both dev and prod.
+     */
+    babel?: BabelOptions | ((id: string, options: {
+        ssr?: boolean;
+    }) => BabelOptions);
+}
+declare type BabelOptions = Omit<TransformOptions, 'ast' | 'filename' | 'root' | 'sourceFileName' | 'sourceMaps' | 'inputSourceMap'>;
+/**
+ * The object type used by the `options` passed to plugins with
+ * an `api.reactBabel` method.
+ */
+interface ReactBabelOptions extends BabelOptions {
+    plugins: Extract<BabelOptions['plugins'], any[]>;
+    presets: Extract<BabelOptions['presets'], any[]>;
+    overrides: Extract<BabelOptions['overrides'], any[]>;
+    parserOpts: ParserOptions & {
+        plugins: Extract<ParserOptions['plugins'], any[]>;
+    };
+}
+declare type ReactBabelHook = (babelConfig: ReactBabelOptions, context: ReactBabelHookContext, config: ResolvedConfig) => void;
+declare type ReactBabelHookContext = {
+    ssr: boolean;
+    id: string;
+};
+declare module 'vite' {
+    interface Plugin {
+        api?: {
+            /**
+             * Manipulate the Babel options of `@vitejs/plugin-react`
+             */
+            reactBabel?: ReactBabelHook;
+        };
+    }
+}
+declare function viteReact(opts?: Options): PluginOption[];
+declare namespace viteReact {
+    var preambleCode: string;
+}
+
+export { BabelOptions, Options, ReactBabelOptions, viteReact as default };