vite 3.0.0-alpha.3 → 3.0.0-alpha.4

package/dist/node/chunks/{dep-b1fc04c1.js → dep-28f8c91c.js}

@@ -1,5 +1,5 @@
 import require$$0 from 'postcss';
-import { v as commonjsGlobal } from './dep-6f5ac69c.js';
+import { v as commonjsGlobal } from './dep-aea1d487.js';
 import path$2 from 'path';
 import require$$1 from 'crypto';
 import fs__default from 'fs';

package/dist/node/chunks/{dep-da8244f4.js → dep-35b61ee3.js}

@@ -1,4 +1,4 @@
-import { w as getAugmentedNamespace, x as getDefaultExportFromCjs } from './dep-6f5ac69c.js';
+import { w as getAugmentedNamespace, x as getDefaultExportFromCjs } from './dep-aea1d487.js';
 
 import { fileURLToPath as __cjs_fileURLToPath } from 'url';
 import { dirname as __cjs_dirname } from 'path';

package/dist/node/chunks/{dep-6f5ac69c.js → dep-aea1d487.js}

@@ -32597,7 +32597,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-da8244f4.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-35b61ee3.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -33702,7 +33702,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-b1fc04c1.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-28f8c91c.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -36303,12 +36303,13 @@ async function discoverProjectDependencies(config, timestamp) {
     const browserHash = getOptimizedBrowserHash(getDepHash(config), deps, timestamp);
     const discovered = {};
     for (const id in deps) {
-        const entry = deps[id];
+        const src = deps[id];
         discovered[id] = {
             id,
             file: getOptimizedDepPath(id, config),
-            src: entry,
-            browserHash: browserHash
+            src,
+            browserHash: browserHash,
+            exportsData: extractExportsData(src, config)
         };
     }
     return discovered;
@@ -36355,15 +36356,21 @@ async function runOptimizeDeps(config, depsInfo) {
     // to wait here. Code that needs to access the cached deps needs to await
     // the optimizedDepInfo.processing promise for each dep
     const qualifiedIds = Object.keys(depsInfo);
+    const processingResult = {
+        metadata,
+        async commit() {
+            // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
+            // Processing is done, we can now replace the depsCacheDir with processingCacheDir
+            // Rewire the file paths from the temporal processing dir to the final deps cache dir
+            await removeDir(depsCacheDir);
+            await renameDir(processingCacheDir, depsCacheDir);
+        },
+        cancel() {
+            fs__default.rmSync(processingCacheDir, { recursive: true, force: true });
+        }
+    };
     if (!qualifiedIds.length) {
-        return {
-            metadata,
-            commit() {
-                // Write metadata file, delete `deps` folder and rename the `processing` folder to `deps`
-                return commitProcessingDepsCacheSync();
-            },
-            cancel
-        };
+        return processingResult;
     }
     // esbuild generates nested directory output with lowest common ancestor base
     // this is unpredictable and makes it difficult to analyze entry / output
@@ -36375,50 +36382,20 @@ async function runOptimizeDeps(config, depsInfo) {
     const idToExports = {};
     const flatIdToExports = {};
     const { plugins = [], ...esbuildOptions } = config.optimizeDeps?.esbuildOptions ?? {};
-    await init;
     for (const id in depsInfo) {
-        const flatId = flattenId(id);
-        const filePath = (flatIdDeps[flatId] = depsInfo[id].src);
-        let exportsData;
-        if (config.optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
-            // For custom supported extensions, build the entry file to transform it into JS,
-            // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
-            // so only the entry file is being transformed.
-            const result = await build$3({
-                ...esbuildOptions,
-                plugins,
-                entryPoints: [filePath],
-                write: false,
-                format: 'esm'
-            });
-            exportsData = parse$h(result.outputFiles[0].text);
-        }
-        else {
-            const entryContent = fs__default.readFileSync(filePath, 'utf-8');
-            try {
-                exportsData = parse$h(entryContent);
-            }
-            catch {
-                const loader = esbuildOptions.loader?.[path$p.extname(filePath)] || 'jsx';
-                debug$c(`Unable to parse dependency: ${id}. Trying again with a ${loader} transform.`);
-                const transformed = await transformWithEsbuild(entryContent, filePath, {
-                    loader
-                });
-                // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
-                // This is useful for packages such as Gatsby.
-                esbuildOptions.loader = {
-                    '.js': 'jsx',
-                    ...esbuildOptions.loader
-                };
-                exportsData = parse$h(transformed.code);
-            }
-            for (const { ss, se } of exportsData[0]) {
-                const exp = entryContent.slice(ss, se);
-                if (/export\s+\*\s+from/.test(exp)) {
-                    exportsData.hasReExports = true;
-                }
-            }
+        const src = depsInfo[id].src;
+        const exportsData = await (depsInfo[id].exportsData ??
+            extractExportsData(src, config));
+        if (exportsData.jsxLoader) {
+            // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
+            // This is useful for packages such as Gatsby.
+            esbuildOptions.loader = {
+                '.js': 'jsx',
+                ...esbuildOptions.loader
+            };
         }
+        const flatId = flattenId(id);
+        flatIdDeps[flatId] = src;
         idToExports[id] = exportsData;
         flatIdToExports[flatId] = exportsData;
     }
@@ -36455,13 +36432,16 @@ async function runOptimizeDeps(config, depsInfo) {
     const processingCacheDirOutputPath = path$p.relative(process.cwd(), processingCacheDir);
     for (const id in depsInfo) {
         const output = esbuildOutputFromId(meta.outputs, id, processingCacheDir);
+        const { exportsData, ...info } = depsInfo[id];
         addOptimizedDepInfo(metadata, 'optimized', {
-            ...depsInfo[id],
-            needsInterop: needsInterop(id, idToExports[id], output),
+            ...info,
             // We only need to hash the output.imports in to check for stability, but adding the hash
             // and file path gives us a unique hash that may be useful for other things in the future
             fileHash: getHash(metadata.hash + depsInfo[id].file + JSON.stringify(output.imports)),
-            browserHash: metadata.browserHash
+            browserHash: metadata.browserHash,
+            // After bundling we have more information and can warn the user about legacy packages
+            // that require manual configuration
+            needsInterop: needsInterop(config, id, idToExports[id], output)
         });
     }
     for (const o of Object.keys(meta.outputs)) {
@@ -36483,23 +36463,7 @@ async function runOptimizeDeps(config, depsInfo) {
     const dataPath = path$p.join(processingCacheDir, '_metadata.json');
     writeFile(dataPath, stringifyOptimizedDepsMetadata(metadata, depsCacheDir));
     debug$c(`deps bundled in ${(performance.now() - start).toFixed(2)}ms`);
-    return {
-        metadata,
-        commit() {
-            // Write metadata file, delete `deps` folder and rename the new `processing` folder to `deps` in sync
-            return commitProcessingDepsCacheSync();
-        },
-        cancel
-    };
-    async function commitProcessingDepsCacheSync() {
-        // Processing is done, we can now replace the depsCacheDir with processingCacheDir
-        // Rewire the file paths from the temporal processing dir to the final deps cache dir
-        await removeDir(depsCacheDir);
-        await renameDir(processingCacheDir, depsCacheDir);
-    }
-    function cancel() {
-        fs__default.rmSync(processingCacheDir, { recursive: true, force: true });
-    }
+    return processingResult;
 }
 async function findKnownImports(config) {
     const deps = (await scanImports(config)).deps;
@@ -36638,12 +36602,58 @@ function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
     const flatId = flattenId(id) + '.js';
     return outputs[normalizePath$3(path$p.relative(process.cwd(), path$p.join(cacheDirOutputPath, flatId)))];
 }
+async function extractExportsData(filePath, config) {
+    await init;
+    let exportsData;
+    const esbuildOptions = config.optimizeDeps?.esbuildOptions ?? {};
+    if (config.optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
+        // For custom supported extensions, build the entry file to transform it into JS,
+        // and then parse with es-module-lexer. Note that the `bundle` option is not `true`,
+        // so only the entry file is being transformed.
+        const result = await build$3({
+            ...esbuildOptions,
+            entryPoints: [filePath],
+            write: false,
+            format: 'esm'
+        });
+        exportsData = parse$h(result.outputFiles[0].text);
+    }
+    else {
+        const entryContent = fs__default.readFileSync(filePath, 'utf-8');
+        try {
+            exportsData = parse$h(entryContent);
+        }
+        catch {
+            const loader = esbuildOptions.loader?.[path$p.extname(filePath)] || 'jsx';
+            debug$c(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
+            const transformed = await transformWithEsbuild(entryContent, filePath, {
+                loader
+            });
+            // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
+            // This is useful for packages such as Gatsby.
+            esbuildOptions.loader = {
+                '.js': 'jsx',
+                ...esbuildOptions.loader
+            };
+            exportsData = parse$h(transformed.code);
+            exportsData.jsxLoader = true;
+        }
+        for (const { ss, se } of exportsData[0]) {
+            const exp = entryContent.slice(ss, se);
+            if (/export\s+\*\s+from/.test(exp)) {
+                exportsData.hasReExports = true;
+            }
+        }
+    }
+    return exportsData;
+}
 // https://github.com/vitejs/vite/issues/1724#issuecomment-767619642
 // a list of modules that pretends to be ESM but still uses `require`.
 // this causes esbuild to wrap them as CJS even when its entry appears to be ESM.
 const KNOWN_INTEROP_IDS = new Set(['moment']);
-function needsInterop(id, exportsData, output) {
-    if (KNOWN_INTEROP_IDS.has(id)) {
+function needsInterop(config, id, exportsData, output) {
+    if (config.optimizeDeps?.needsInterop?.includes(id) ||
+        KNOWN_INTEROP_IDS.has(id)) {
         return true;
     }
     const [imports, exports] = exportsData;
@@ -36651,13 +36661,16 @@ function needsInterop(id, exportsData, output) {
     if (!exports.length && !imports.length) {
         return true;
     }
-    // if a peer dependency used require() on a ESM dependency, esbuild turns the
-    // ESM dependency's entry chunk into a single default export... detect
-    // such cases by checking exports mismatch, and force interop.
-    const generatedExports = output.exports;
-    if (!generatedExports ||
-        (isSingleDefaultExport(generatedExports) && !isSingleDefaultExport(exports))) {
-        return true;
+    if (output) {
+        // if a peer dependency used require() on a ESM dependency, esbuild turns the
+        // ESM dependency's entry chunk into a single default export... detect
+        // such cases by checking exports mismatch, and force interop.
+        const generatedExports = output.exports;
+        if (!generatedExports ||
+            (isSingleDefaultExport(generatedExports) &&
+                !isSingleDefaultExport(exports))) {
+            return true;
+        }
     }
     return false;
 }
@@ -36710,12 +36723,12 @@ function findOptimizedDepInfoInRecord(dependenciesInfo, callbackFn) {
         }
     }
 }
-async function optimizedDepNeedsInterop(metadata, file) {
+async function optimizedDepNeedsInterop(metadata, file, config) {
     const depInfo = optimizedDepInfoFromFile(metadata, file);
-    if (!depInfo)
-        return undefined;
-    // Wait until the dependency has been pre-bundled
-    await depInfo.processing;
+    if (depInfo?.src && depInfo.needsInterop === undefined) {
+        depInfo.exportsData ?? (depInfo.exportsData = extractExportsData(depInfo.src, config));
+        depInfo.needsInterop = needsInterop(config, depInfo.id, await depInfo.exportsData);
+    }
     return depInfo?.needsInterop;
 }
 
@@ -36736,6 +36749,7 @@ var index$1 = {
 	getDepsCacheDir: getDepsCacheDir,
 	isOptimizedDepFile: isOptimizedDepFile,
 	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
+	extractExportsData: extractExportsData,
 	getDepHash: getDepHash,
 	optimizedDepInfoFromId: optimizedDepInfoFromId,
 	optimizedDepInfoFromFile: optimizedDepInfoFromFile,
@@ -44633,7 +44647,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await import('./dep-5eede05c.js')).createCertificate();
+        const content = (await import('./dep-ce833324.js')).createCertificate();
         promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => promises.writeFile(cachePath, content))
@@ -46563,11 +46577,25 @@ function createOptimizedDeps(server) {
         try {
             const processingResult = await runOptimizeDeps(config, newDeps);
             const newData = processingResult.metadata;
+            const needsInteropMismatch = [];
+            for (const dep in metadata.discovered) {
+                const discoveredDepInfo = metadata.discovered[dep];
+                const depInfo = newData.optimized[dep];
+                if (depInfo) {
+                    if (discoveredDepInfo.needsInterop !== undefined &&
+                        depInfo.needsInterop !== discoveredDepInfo.needsInterop) {
+                        // This only happens when a discovered dependency has mixed ESM and CJS syntax
+                        // and it hasn't been manually added to optimizeDeps.needsInterop
+                        needsInteropMismatch.push(dep);
+                    }
+                }
+            }
             // After a re-optimization, if the internal bundled chunks change a full page reload
             // is required. If the files are stable, we can avoid the reload that is expensive
             // for large applications. Comparing their fileHash we can find out if it is safe to
             // keep the current browser state.
-            const needsReload = metadata.hash !== newData.hash ||
+            const needsReload = needsInteropMismatch.length > 0 ||
+                metadata.hash !== newData.hash ||
                 Object.keys(metadata.optimized).some((dep) => {
                     return (metadata.optimized[dep].fileHash !== newData.optimized[dep].fileHash);
                 });
@@ -46647,6 +46675,11 @@ function createOptimizedDeps(server) {
                     logger.info(colors$1.green(`✨ optimized dependencies changed. reloading`), {
                         timestamp: true
                     });
+                    if (needsInteropMismatch.length > 0) {
+                        config.logger.warn(`Mixed ESM and CJS detected in ${colors$1.yellow(needsInteropMismatch.join(', '))}, add ${needsInteropMismatch.length === 1 ? 'it' : 'them'} to optimizeDeps.needsInterop to speed up cold start`, {
+                            timestamp: true
+                        });
+                    }
                     fullReload();
                 }
             }
@@ -46716,7 +46749,8 @@ function createOptimizedDeps(server) {
             browserHash: getDiscoveredBrowserHash(metadata.hash, depsFromOptimizedDepInfo(metadata.optimized), depsFromOptimizedDepInfo(metadata.discovered)),
             // loading of this pre-bundled dep needs to await for its processing
             // promise to be resolved
-            processing: depOptimizationProcessing.promise
+            processing: depOptimizationProcessing.promise,
+            exportsData: extractExportsData(resolved, config)
         });
         // Debounced rerun, let other missing dependencies be discovered before
         // the running next optimizeDeps
@@ -54452,10 +54486,6 @@ function importAnalysisPlugin(config) {
                 }
                 return [url, resolved.id];
             };
-            // Import rewrites, we do them after all the URLs have been resolved
-            // to help with the discovery of new dependencies. If we need to wait
-            // for each dependency there could be one reload per import
-            const importRewrites = [];
             for (let index = 0; index < imports.length; index++) {
                 const { s: start, e: end, ss: expStart, se: expEnd, d: dynamicIndex, 
                 // #2083 User may use escape path,
@@ -54517,51 +54547,51 @@ function importAnalysisPlugin(config) {
                     // record as safe modules
                     server?.moduleGraph.safeModulesPath.add(fsPathFromUrl(url));
                     if (url !== specifier) {
-                        importRewrites.push(async () => {
-                            let rewriteDone = false;
-                            if (server?._optimizedDeps &&
-                                isOptimizedDepFile(resolvedId, config) &&
-                                !resolvedId.match(optimizedDepChunkRE)) {
-                                // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
-                                // internal optimized chunks don't need es interop and are excluded
-                                // The browserHash in resolvedId could be stale in which case there will be a full
-                                // page reload. We could return a 404 in that case but it is safe to return the request
-                                const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                                const needsInterop = await optimizedDepNeedsInterop(server._optimizedDeps.metadata, file);
-                                if (needsInterop === undefined) {
-                                    // Non-entry dynamic imports from dependencies will reach here as there isn't
-                                    // optimize info for them, but they don't need es interop. If the request isn't
-                                    // a dynamic import, then it is an internal Vite error
-                                    if (!file.match(optimizedDepDynamicRE)) {
-                                        config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
-                                    }
+                        let rewriteDone = false;
+                        if (server?._optimizedDeps &&
+                            isOptimizedDepFile(resolvedId, config) &&
+                            !resolvedId.match(optimizedDepChunkRE)) {
+                            // for optimized cjs deps, support named imports by rewriting named imports to const assignments.
+                            // internal optimized chunks don't need es interop and are excluded
+                            // The browserHash in resolvedId could be stale in which case there will be a full
+                            // page reload. We could return a 404 in that case but it is safe to return the request
+                            const file = cleanUrl(resolvedId); // Remove ?v={hash}
+                            const needsInterop = await optimizedDepNeedsInterop(server._optimizedDeps.metadata, file, config);
+                            if (needsInterop === undefined) {
+                                // Non-entry dynamic imports from dependencies will reach here as there isn't
+                                // optimize info for them, but they don't need es interop. If the request isn't
+                                // a dynamic import, then it is an internal Vite error
+                                if (!file.match(optimizedDepDynamicRE)) {
+                                    config.logger.error(colors$1.red(`Vite Error, ${url} optimized info should be defined`));
+                                }
+                            }
+                            else if (needsInterop) {
+                                debug$1(`${url} needs interop`);
+                                if (isDynamicImport) {
+                                    // rewrite `import('package')` to expose the default directly
+                                    str().overwrite(expStart, expEnd, `import('${url}').then(m => m.default && m.default.__esModule ? m.default : ({ ...m.default, default: m.default }))`, { contentOnly: true });
                                 }
-                                else if (needsInterop) {
-                                    debug$1(`${url} needs interop`);
-                                    if (isDynamicImport) {
-                                        // rewrite `import('package')` to expose the default directly
-                                        str().overwrite(expStart, expEnd, `import('${url}').then(m => m.default && m.default.__esModule ? m.default : ({ ...m.default, default: m.default }))`, { contentOnly: true });
+                                else {
+                                    const exp = source.slice(expStart, expEnd);
+                                    const rewritten = transformCjsImport(exp, url, rawUrl, index);
+                                    if (rewritten) {
+                                        str().overwrite(expStart, expEnd, rewritten, {
+                                            contentOnly: true
+                                        });
                                     }
                                     else {
-                                        const exp = source.slice(expStart, expEnd);
-                                        const rewritten = transformCjsImport(exp, url, rawUrl, index);
-                                        if (rewritten) {
-                                            str().overwrite(expStart, expEnd, rewritten, {
-                                                contentOnly: true
-                                            });
-                                        }
-                                        else {
-                                            // #1439 export * from '...'
-                                            str().overwrite(start, end, url, { contentOnly: true });
-                                        }
+                                        // #1439 export * from '...'
+                                        str().overwrite(start, end, url, { contentOnly: true });
                                     }
-                                    rewriteDone = true;
                                 }
+                                rewriteDone = true;
                             }
-                            if (!rewriteDone) {
-                                str().overwrite(start, end, isDynamicImport ? `'${url}'` : url, { contentOnly: true });
-                            }
-                        });
+                        }
+                        if (!rewriteDone) {
+                            str().overwrite(start, end, isDynamicImport ? `'${url}'` : url, {
+                                contentOnly: true
+                            });
+                        }
                     }
                     // record for HMR import chain analysis
                     // make sure to normalize away base
@@ -54671,13 +54701,6 @@ function importAnalysisPlugin(config) {
                     });
                 });
             }
-            // Await for import rewrites that requires dependencies to be pre-bundled to
-            // know if es interop is needed after starting further transformRequest calls
-            // This will let Vite process deeper into the user code and find more missing
-            // dependencies before the next page reload
-            for (const rewrite of importRewrites) {
-                await rewrite();
-            }
             if (s) {
                 return {
                     code: s.toString(),

package/dist/node/chunks/{dep-5eede05c.js → dep-ce833324.js}

@@ -1,4 +1,4 @@
-import { v as commonjsGlobal } from './dep-6f5ac69c.js';
+import { v as commonjsGlobal } from './dep-aea1d487.js';
 import require$$1 from 'crypto';
 import 'fs';
 import 'path';

package/dist/node/cli.js

@@ -1,6 +1,6 @@
 import { performance } from 'perf_hooks';
 import { EventEmitter } from 'events';
-import { u as colors, i as createLogger, e as resolveConfig } from './chunks/dep-6f5ac69c.js';
+import { u as colors, i as createLogger, e as resolveConfig } from './chunks/dep-aea1d487.js';
 import { VERSION } from './constants.js';
 import 'fs';
 import 'path';
@@ -682,7 +682,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-6f5ac69c.js').then(function (n) { return n.A; });
+    const { createServer } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.A; });
     try {
         const server = await createServer({
             root,
@@ -727,7 +727,7 @@ cli
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
-    const { build } = await import('./chunks/dep-6f5ac69c.js').then(function (n) { return n.z; });
+    const { build } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.z; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -750,7 +750,7 @@ cli
     .command('optimize [root]', 'pre-bundle dependencies')
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
-    const { optimizeDeps } = await import('./chunks/dep-6f5ac69c.js').then(function (n) { return n.y; });
+    const { optimizeDeps } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.y; });
     try {
         const config = await resolveConfig({
             root,
@@ -773,7 +773,7 @@ cli
     .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .action(async (root, options) => {
-    const { preview } = await import('./chunks/dep-6f5ac69c.js').then(function (n) { return n.B; });
+    const { preview } = await import('./chunks/dep-aea1d487.js').then(function (n) { return n.B; });
     try {
         const server = await preview({
             root,

package/dist/node/constants.js

@@ -1,7 +1,7 @@
 import path, { resolve } from 'path';
 import { fileURLToPath } from 'url';
 
-var version = "3.0.0-alpha.3";
+var version = "3.0.0-alpha.4";
 
 const VERSION = version;
 const DEFAULT_MAIN_FIELDS = [

package/dist/node/index.d.ts

@@ -23,6 +23,7 @@ import type * as net from 'net';
 import type { OutgoingHttpHeaders } from 'http';
 import type { OutputBundle } from 'rollup';
 import type { OutputChunk } from 'rollup';
+import { parse } from 'es-module-lexer';
 import type { PartialResolvedId } from 'rollup';
 import type { Plugin as Plugin_3 } from 'rollup';
 import type { PluginContext } from 'rollup';
@@ -543,6 +544,12 @@ export declare interface DepOptimizationOptions {
      * cannot be globs).
      */
     exclude?: string[];
+    /**
+     * Force ESM interop when importing for these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
     /**
      * Options to pass to esbuild during the dep scanning and optimization
      *
@@ -629,6 +636,11 @@ export declare interface ExperimentalOptions {
     importGlobRestoreExtension?: boolean;
 }
 
+export declare type ExportsData = ReturnType<typeof parse> & {
+    hasReExports?: true;
+    jsxLoader?: true;
+};
+
 export declare interface FileSystemServeOptions {
     /**
      * Strictly restrict file accessing outside of allowing paths.
@@ -1281,6 +1293,11 @@ export declare interface OptimizedDepInfo {
      * but the bundles may not yet be saved to disk
      */
     processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
 }
 
 export declare interface OptimizedDeps {

package/dist/node/index.js

@@ -1,4 +1,4 @@
-export { b as build, i as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, l as loadConfigFromFile, k as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, p as preview, e as resolveConfig, q as resolveEnvPrefix, a as resolvePackageData, r as resolvePackageEntry, j as searchForWorkspaceRoot, h as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-6f5ac69c.js';
+export { b as build, i as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, l as loadConfigFromFile, k as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, p as preview, e as resolveConfig, q as resolveEnvPrefix, a as resolvePackageData, r as resolvePackageEntry, j as searchForWorkspaceRoot, h as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-aea1d487.js';
 import 'fs';
 import 'path';
 import 'url';

package/dist/node/optimizer/index.d.ts

@@ -4,6 +4,7 @@ import type { ResolvedConfig } from '../config';
 export declare const debuggerViteDeps: (...args: any[]) => any;
 export declare type ExportsData = ReturnType<typeof parse> & {
     hasReExports?: true;
+    jsxLoader?: true;
 };
 export interface OptimizedDeps {
     metadata: DepOptimizationMetadata;
@@ -32,6 +33,12 @@ export interface DepOptimizationOptions {
      * cannot be globs).
      */
     exclude?: string[];
+    /**
+     * Force ESM interop when importing for these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
     /**
      * Options to pass to esbuild during the dep scanning and optimization
      *
@@ -87,6 +94,11 @@ export interface OptimizedDepInfo {
      * but the bundles may not yet be saved to disk
      */
     processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
 }
 export interface DepOptimizationMetadata {
     /**
@@ -148,7 +160,8 @@ export declare function getOptimizedDepPath(id: string, config: ResolvedConfig):
 export declare function getDepsCacheDir(config: ResolvedConfig): string;
 export declare function isOptimizedDepFile(id: string, config: ResolvedConfig): boolean;
 export declare function createIsOptimizedDepUrl(config: ResolvedConfig): (url: string) => boolean;
+export declare function extractExportsData(filePath: string, config: ResolvedConfig): Promise<ExportsData>;
 export declare function getDepHash(config: ResolvedConfig): string;
 export declare function optimizedDepInfoFromId(metadata: DepOptimizationMetadata, id: string): OptimizedDepInfo | undefined;
 export declare function optimizedDepInfoFromFile(metadata: DepOptimizationMetadata, file: string): OptimizedDepInfo | undefined;
-export declare function optimizedDepNeedsInterop(metadata: DepOptimizationMetadata, file: string): Promise<boolean | undefined>;
+export declare function optimizedDepNeedsInterop(metadata: DepOptimizationMetadata, file: string, config: ResolvedConfig): Promise<boolean | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -20,6 +20,7 @@
     "./client": {
       "types": "./client.d.ts"
     },
+    "./dist/client/*": "./dist/client/*",
     "./terser": {
       "require": "./dist/node-cjs/terser.cjs"
     }