@sveltejs/vite-plugin-svelte 1.1.0 → 1.2.0

package/src/utils/options.ts

@@ -1,12 +1,5 @@
 /* eslint-disable no-unused-vars */
-import {
-	ConfigEnv,
-	DepOptimizationOptions,
-	ResolvedConfig,
-	UserConfig,
-	ViteDevServer,
-	normalizePath
-} from 'vite';
+import { ConfigEnv, ResolvedConfig, UserConfig, ViteDevServer, normalizePath } from 'vite';
 import { log } from './log';
 import { loadSvelteConfig } from './load-svelte-config';
 import { SVELTE_HMR_IMPORTS, SVELTE_IMPORTS, SVELTE_RESOLVE_MAIN_FIELDS } from './constants';
@@ -21,11 +14,22 @@ import type {
 } from 'svelte/types/compiler/preprocess';
 
 import path from 'path';
-import { findRootSvelteDependencies, needsOptimization, SvelteDependency } from './dependencies';
-import { createRequire } from 'module';
 import { esbuildSveltePlugin, facadeEsbuildSveltePluginName } from './esbuild';
 import { addExtraPreprocessors } from './preprocess';
 import deepmerge from 'deepmerge';
+import {
+	crawlFrameworkPkgs,
+	isDepExcluded,
+	isDepExternaled,
+	isDepIncluded,
+	isDepNoExternaled
+	// eslint-disable-next-line node/no-missing-import
+} from 'vitefu';
+import { atLeastSvelte } from './svelte-version';
+import { isCommonDepWithoutSvelteField } from './dependencies';
+
+// svelte 3.53.0 changed compilerOptions.css from boolean to string | boolen, use string when available
+const cssAsString = atLeastSvelte('3.53.0');
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -170,15 +174,20 @@ export function resolveOptions(
 	preResolveOptions: PreResolvedOptions,
 	viteConfig: ResolvedConfig
 ): ResolvedOptions {
+	const css = cssAsString
+		? preResolveOptions.emitCss
+			? 'external'
+			: 'injected'
+		: !preResolveOptions.emitCss;
 	const defaultOptions: Partial<Options> = {
 		hot: viteConfig.isProduction
 			? false
 			: {
-					injectCss: !preResolveOptions.emitCss,
+					injectCss: css === true || css === 'injected',
 					partialAccept: !!viteConfig.experimental?.hmrPartialAccept
 			  },
 		compilerOptions: {
-			css: !preResolveOptions.emitCss,
+			css,
 			dev: !viteConfig.isProduction
 		}
 	};
@@ -208,11 +217,13 @@ function enforceOptionsForHmr(options: ResolvedOptions) {
 				log.warn('hmr and emitCss are enabled but hot.injectCss is true, forcing it to false');
 				options.hot.injectCss = false;
 			}
-			if (options.compilerOptions.css) {
+			const css = options.compilerOptions.css;
+			if (css === true || css === 'injected') {
+				const forcedCss = cssAsString ? 'external' : false;
 				log.warn(
-					'hmr and emitCss are enabled but compilerOptions.css is true, forcing it to false'
+					`hmr and emitCss are enabled but compilerOptions.css is ${css}, forcing it to ${forcedCss}`
 				);
-				options.compilerOptions.css = false;
+				options.compilerOptions.css = forcedCss;
 			}
 		} else {
 			if (options.hot === true || !options.hot.injectCss) {
@@ -225,11 +236,13 @@ function enforceOptionsForHmr(options: ResolvedOptions) {
 					options.hot.injectCss = true;
 				}
 			}
-			if (!options.compilerOptions.css) {
+			const css = options.compilerOptions.css;
+			if (!(css === true || css === 'injected')) {
+				const forcedCss = cssAsString ? 'injected' : true;
 				log.warn(
-					'hmr with emitCss disabled requires compilerOptions.css to be enabled, forcing it to true'
+					`hmr with emitCss disabled requires compilerOptions.css to be enabled, forcing it to ${forcedCss}`
 				);
-				options.compilerOptions.css = true;
+				options.compilerOptions.css = forcedCss;
 			}
 		}
 	}
@@ -273,20 +286,9 @@ function removeIgnoredOptions(options: ResolvedOptions) {
 // some SvelteKit options need compilerOptions to work, so set them here.
 function addSvelteKitOptions(options: ResolvedOptions) {
 	// @ts-expect-error kit is not typed to avoid dependency on sveltekit
-	if (options?.kit != null) {
-		// @ts-expect-error kit is not typed to avoid dependency on sveltekit
-		const kit_browser_hydrate = options.kit.browser?.hydrate;
-		const hydratable = kit_browser_hydrate !== false;
-		if (
-			options.compilerOptions.hydratable != null &&
-			options.compilerOptions.hydratable !== hydratable
-		) {
-			log.warn(
-				`Conflicting values "compilerOptions.hydratable: ${options.compilerOptions.hydratable}" and "kit.browser.hydrate: ${kit_browser_hydrate}" in your svelte config. You should remove "compilerOptions.hydratable".`
-			);
-		}
-		log.debug(`Setting compilerOptions.hydratable: ${hydratable} for SvelteKit`);
-		options.compilerOptions.hydratable = hydratable;
+	if (options?.kit != null && options.compilerOptions.hydratable == null) {
+		log.debug(`Setting compilerOptions.hydratable = true for SvelteKit`);
+		options.compilerOptions.hydratable = true;
 	}
 }
 
@@ -306,12 +308,10 @@ function resolveViteRoot(viteConfig: UserConfig): string | undefined {
 	return normalizePath(viteConfig.root ? path.resolve(viteConfig.root) : process.cwd());
 }
 
-export function buildExtraViteConfig(
+export async function buildExtraViteConfig(
 	options: PreResolvedOptions,
 	config: UserConfig
-): Partial<UserConfig> {
-	// extra handling for svelte dependencies in the project
-	const svelteDeps = findRootSvelteDependencies(options.root);
+): Promise<Partial<UserConfig>> {
 	const extraViteConfig: Partial<UserConfig> = {
 		resolve: {
 			mainFields: [...SVELTE_RESOLVE_MAIN_FIELDS],
@@ -323,30 +323,50 @@ export function buildExtraViteConfig(
 		// knownJsSrcExtensions: options.extensions
 	};
 
-	extraViteConfig.optimizeDeps = buildOptimizeDepsForSvelte(
-		svelteDeps,
-		options,
-		config.optimizeDeps
-	);
+	const extraSvelteConfig = buildExtraConfigForSvelte(config);
+	const extraDepsConfig = await buildExtraConfigForDependencies(options, config);
+	// merge extra svelte and deps config, but make sure dep values are not contradicting svelte
+	extraViteConfig.optimizeDeps = {
+		include: [
+			...extraSvelteConfig.optimizeDeps.include,
+			...extraDepsConfig.optimizeDeps.include.filter(
+				(dep) => !isDepExcluded(dep, extraSvelteConfig.optimizeDeps.exclude)
+			)
+		],
+		exclude: [
+			...extraSvelteConfig.optimizeDeps.exclude,
+			...extraDepsConfig.optimizeDeps.exclude.filter(
+				(dep) => !isDepIncluded(dep, extraSvelteConfig.optimizeDeps.include)
+			)
+		]
+	};
 
+	extraViteConfig.ssr = {
+		external: [
+			...extraSvelteConfig.ssr.external,
+			...extraDepsConfig.ssr.external.filter(
+				(dep) => !isDepNoExternaled(dep, extraSvelteConfig.ssr.noExternal)
+			)
+		],
+		noExternal: [
+			...extraSvelteConfig.ssr.noExternal,
+			...extraDepsConfig.ssr.noExternal.filter(
+				(dep) => !isDepExternaled(dep, extraSvelteConfig.ssr.external)
+			)
+		]
+	};
+
+	// handle prebundling for svelte files
 	if (options.prebundleSvelteLibraries) {
-		extraViteConfig.optimizeDeps = {
-			...extraViteConfig.optimizeDeps,
-			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			// @ts-ignore
-			extensions: options.extensions ?? ['.svelte'],
-			// Add esbuild plugin to prebundle Svelte files.
-			// Currently a placeholder as more information is needed after Vite config is resolved,
-			// the real Svelte plugin is added in `patchResolvedViteConfig()`
-			esbuildOptions: {
-				plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {} }]
-			}
+		extraViteConfig.optimizeDeps.extensions = options.extensions ?? ['.svelte'];
+		// Add esbuild plugin to prebundle Svelte files.
+		// Currently a placeholder as more information is needed after Vite config is resolved,
+		// the real Svelte plugin is added in `patchResolvedViteConfig()`
+		extraViteConfig.optimizeDeps.esbuildOptions = {
+			plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {} }]
 		};
 	}
 
-	// @ts-ignore
-	extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config, extraViteConfig);
-
 	// enable hmrPartialAccept if not explicitly disabled
 	if (
 		(options.hot == null ||
@@ -357,112 +377,91 @@ export function buildExtraViteConfig(
 		log.debug('enabling "experimental.hmrPartialAccept" in vite config');
 		extraViteConfig.experimental = { hmrPartialAccept: true };
 	}
-
 	return extraViteConfig;
 }
 
-function buildOptimizeDepsForSvelte(
-	svelteDeps: SvelteDependency[],
-	options: PreResolvedOptions,
-	optimizeDeps?: DepOptimizationOptions
-): DepOptimizationOptions {
+async function buildExtraConfigForDependencies(options: PreResolvedOptions, config: UserConfig) {
+	// extra handling for svelte dependencies in the project
+	const depsConfig = await crawlFrameworkPkgs({
+		root: options.root,
+		isBuild: options.isBuild,
+		viteUserConfig: config,
+		isFrameworkPkgByJson(pkgJson) {
+			return !!pkgJson.svelte;
+		},
+		isSemiFrameworkPkgByJson(pkgJson) {
+			return !!pkgJson.dependencies?.svelte || !!pkgJson.peerDependencies?.svelte;
+		},
+		isFrameworkPkgByName(pkgName) {
+			const isNotSveltePackage = isCommonDepWithoutSvelteField(pkgName);
+			if (isNotSveltePackage) {
+				return false;
+			} else {
+				return undefined;
+			}
+		}
+	});
+
+	log.debug('extra config for dependencies generated by vitefu', depsConfig);
+
+	if (options.prebundleSvelteLibraries) {
+		// prebundling enabled, so we don't need extra dependency excludes
+		depsConfig.optimizeDeps.exclude = [];
+		// but keep dependency reinclusions of explicit user excludes
+		const userExclude = config.optimizeDeps?.exclude;
+		depsConfig.optimizeDeps.include = !userExclude
+			? []
+			: depsConfig.optimizeDeps.include.filter((dep: string) => {
+					// reincludes look like this: foo > bar > baz
+					// in case foo or bar are excluded, we have to retain the reinclude even with prebundling
+					return (
+						dep.includes('>') &&
+						dep
+							.split('>')
+							.slice(0, -1)
+							.some((d) => isDepExcluded(d.trim(), userExclude))
+					);
+			  });
+	}
+	if (options.disableDependencyReinclusion === true) {
+		depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter(
+			(dep) => !dep.includes('>')
+		);
+	} else if (Array.isArray(options.disableDependencyReinclusion)) {
+		const disabledDeps = options.disableDependencyReinclusion;
+		depsConfig.optimizeDeps.include = depsConfig.optimizeDeps.include.filter((dep) => {
+			if (!dep.includes('>')) return true;
+			const trimDep = dep.replace(/\s+/g, '');
+			return disabledDeps.some((disabled) => trimDep.includes(`${disabled}>`));
+		});
+	}
+
+	log.debug('post-processed extra config for dependencies', depsConfig);
+
+	return depsConfig;
+}
+
+function buildExtraConfigForSvelte(config: UserConfig) {
 	// include svelte imports for optimization unless explicitly excluded
 	const include: string[] = [];
 	const exclude: string[] = ['svelte-hmr'];
-	const isIncluded = (dep: string) => include.includes(dep) || optimizeDeps?.include?.includes(dep);
-	const isExcluded = (dep: string) => {
-		return (
-			exclude.includes(dep) ||
-			// vite optimizeDeps.exclude works for subpackages too
-			// see https://github.com/vitejs/vite/blob/c87763c1418d1ba876eae13d139eba83ac6f28b2/packages/vite/src/node/optimizer/scan.ts#L293
-			optimizeDeps?.exclude?.some((id: string) => dep === id || id.startsWith(`${dep}/`))
-		);
-	};
-	if (!isExcluded('svelte')) {
+	if (!isDepExcluded('svelte', config.optimizeDeps?.exclude ?? [])) {
 		const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== 'svelte/ssr'); // not used on clientside
 		log.debug(
 			`adding bare svelte packages to optimizeDeps.include: ${svelteImportsToInclude.join(', ')} `
 		);
-		include.push(...svelteImportsToInclude.filter((x) => !isIncluded(x)));
+		include.push(...svelteImportsToInclude);
 	} else {
 		log.debug('"svelte" is excluded in optimizeDeps.exclude, skipped adding it to include.');
 	}
-
-	// If we prebundle svelte libraries, we can skip the whole prebundling dance below
-	if (options.prebundleSvelteLibraries) {
-		return { include, exclude };
-	}
-
-	// only svelte component libraries needs to be processed for optimizeDeps, js libraries work fine
-	svelteDeps = svelteDeps.filter((dep) => dep.type === 'component-library');
-
-	const svelteDepsToExclude = Array.from(new Set(svelteDeps.map((dep) => dep.name))).filter(
-		(dep) => !isIncluded(dep)
-	);
-	log.debug(`automatically excluding found svelte dependencies: ${svelteDepsToExclude.join(', ')}`);
-	exclude.push(...svelteDepsToExclude.filter((x) => !isExcluded(x)));
-
-	if (options.disableDependencyReinclusion !== true) {
-		const disabledReinclusions = options.disableDependencyReinclusion || [];
-		if (disabledReinclusions.length > 0) {
-			log.debug(`not reincluding transitive dependencies of`, disabledReinclusions);
-		}
-		const transitiveDepsToInclude = svelteDeps
-			.filter((dep) => !disabledReinclusions.includes(dep.name) && isExcluded(dep.name))
-			.flatMap((dep) => {
-				const localRequire = createRequire(`${dep.dir}/package.json`);
-				return Object.keys(dep.pkg.dependencies || {})
-					.filter((depOfDep) => !isExcluded(depOfDep) && needsOptimization(depOfDep, localRequire))
-					.map((depOfDep) => dep.path.concat(dep.name, depOfDep).join(' > '));
-			});
-		log.debug(
-			`reincluding transitive dependencies of excluded svelte dependencies`,
-			transitiveDepsToInclude
-		);
-		include.push(...transitiveDepsToInclude);
-	}
-
-	return { include, exclude };
-}
-
-function buildSSROptionsForSvelte(
-	svelteDeps: SvelteDependency[],
-	options: ResolvedOptions,
-	config: UserConfig
-): any {
 	const noExternal: (string | RegExp)[] = [];
-
+	const external: string[] = [];
 	// add svelte to ssr.noExternal unless it is present in ssr.external
 	// so we can resolve it with svelte/ssr
-	if (!config.ssr?.external?.includes('svelte')) {
+	if (!isDepExternaled('svelte', config.ssr?.external ?? [])) {
 		noExternal.push('svelte', /^svelte\//);
 	}
-
-	// add svelte dependencies to ssr.noExternal unless present in ssr.external
-	noExternal.push(
-		...Array.from(new Set(svelteDeps.map((s) => s.name))).filter(
-			(x) => !config.ssr?.external?.includes(x)
-		)
-	);
-	const ssr = {
-		noExternal,
-		external: [] as string[]
-	};
-
-	if (options.isServe) {
-		// during dev, we have to externalize transitive dependencies, see https://github.com/sveltejs/vite-plugin-svelte/issues/281
-		ssr.external = Array.from(
-			new Set(svelteDeps.flatMap((dep) => Object.keys(dep.pkg.dependencies || {})))
-		).filter(
-			(dep) =>
-				!ssr.noExternal.includes(dep) &&
-				// TODO noExternal can be something different than a string array
-				//!config.ssr?.noExternal?.includes(dep) &&
-				!config.ssr?.external?.includes(dep)
-		);
-	}
-
-	return ssr;
+	return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 
 export function patchResolvedViteConfig(viteConfig: ResolvedConfig, options: ResolvedOptions) {

package/src/utils/preprocess.ts

@@ -1,14 +1,8 @@
-import {
-	transformWithEsbuild,
-	ESBuildOptions,
-	ResolvedConfig,
-	TransformResult,
-	Plugin
-} from 'vite';
+import * as vite from 'vite';
+import type { ESBuildOptions, ResolvedConfig, Plugin } from 'vite';
 import MagicString from 'magic-string';
 import { preprocess } from 'svelte/compiler';
 import { Preprocessor, PreprocessorGroup, Processed, ResolvedOptions } from './options';
-import { TransformPluginContext } from 'rollup';
 import { log } from './log';
 import { buildSourceMap } from './sourcemap';
 import path from 'path';
@@ -21,7 +15,7 @@ function createViteScriptPreprocessor(): Preprocessor {
 	return async ({ attributes, content, filename = '' }) => {
 		const lang = attributes.lang as string;
 		if (!supportedScriptLangs.includes(lang)) return;
-		const transformResult = await transformWithEsbuild(content, filename, {
+		const transformResult = await vite.transformWithEsbuild(content, filename, {
 			loader: lang as ESBuildOptions['loader'],
 			target: 'esnext',
 			tsconfigRaw: {
@@ -40,34 +34,47 @@ function createViteScriptPreprocessor(): Preprocessor {
 }
 
 function createViteStylePreprocessor(config: ResolvedConfig): Preprocessor {
-	const pluginName = 'vite:css';
-	const plugin = config.plugins.find((p) => p.name === pluginName);
-	if (!plugin) {
-		throw new Error(`failed to find plugin ${pluginName}`);
-	}
-	if (!plugin.transform) {
-		throw new Error(`plugin ${pluginName} has no transform`);
-	}
-	const pluginTransform = plugin.transform!.bind(null as unknown as TransformPluginContext);
+	const transform = getCssTransformFn(config);
 	return async ({ attributes, content, filename = '' }) => {
 		const lang = attributes.lang as string;
 		if (!supportedStyleLangs.includes(lang)) return;
 		const moduleId = `${filename}.${lang}`;
-		const transformResult: TransformResult = (await pluginTransform(
-			content,
-			moduleId
-		)) as TransformResult;
+		const result = await transform(content, moduleId);
 		// patch sourcemap source to point back to original filename
-		if (transformResult.map?.sources?.[0] === moduleId) {
-			transformResult.map.sources[0] = path.basename(filename);
+		if (result.map?.sources?.[0] === moduleId) {
+			result.map.sources[0] = path.basename(filename);
 		}
 		return {
-			code: transformResult.code,
-			map: transformResult.map ?? undefined
+			code: result.code,
+			map: result.map ?? undefined
 		};
 	};
 }
 
+// eslint-disable-next-line no-unused-vars
+type CssTransform = (code: string, filename: string) => Promise<{ code: string; map?: any }>;
+
+function getCssTransformFn(config: ResolvedConfig): CssTransform {
+	// API is only available in Vite 3.2 and above
+	// TODO: Remove Vite plugin hack when bump peer dep to Vite 3.2
+	if (vite.preprocessCSS) {
+		return async (code, filename) => {
+			return vite.preprocessCSS(code, filename, config);
+		};
+	} else {
+		const pluginName = 'vite:css';
+		const plugin = config.plugins.find((p) => p.name === pluginName);
+		if (!plugin) {
+			throw new Error(`failed to find plugin ${pluginName}`);
+		}
+		if (!plugin.transform) {
+			throw new Error(`plugin ${pluginName} has no transform`);
+		}
+		// @ts-expect-error
+		return plugin.transform.bind(null);
+	}
+}
+
 function createVitePreprocessorGroup(config: ResolvedConfig): PreprocessorGroup {
 	return {
 		markup({ content, filename }) {

package/src/utils/resolve.ts

@@ -1,25 +1,24 @@
 import path from 'path';
-import { builtinModules, createRequire } from 'module';
-import { is_common_without_svelte_field, resolveDependencyData } from './dependencies';
+import { builtinModules } from 'module';
+import { resolveDependencyData, isCommonDepWithoutSvelteField } from './dependencies';
 import { VitePluginSvelteCache } from './vite-plugin-svelte-cache';
 
-export function resolveViaPackageJsonSvelte(
+export async function resolveViaPackageJsonSvelte(
 	importee: string,
 	importer: string | undefined,
 	cache: VitePluginSvelteCache
-): string | void {
+): Promise<string | void> {
 	if (
 		importer &&
 		isBareImport(importee) &&
 		!isNodeInternal(importee) &&
-		!is_common_without_svelte_field(importee)
+		!isCommonDepWithoutSvelteField(importee)
 	) {
 		const cached = cache.getResolvedSvelteField(importee, importer);
 		if (cached) {
 			return cached;
 		}
-		const localRequire = createRequire(importer);
-		const pkgData = resolveDependencyData(importee, localRequire);
+		const pkgData = await resolveDependencyData(importee, importer);
 		if (pkgData) {
 			const { pkg, dir } = pkgData;
 			if (pkg.svelte) {

package/src/utils/svelte-version.ts

@@ -0,0 +1,37 @@
+import { VERSION } from 'svelte/compiler';
+const svelteVersion = parseVersion(VERSION);
+
+export function parseVersion(version: string): number[] {
+	const segments = version.split('.', 3).map((s) => parseInt(s, 10));
+	while (segments.length < 3) {
+		segments.push(0);
+	}
+	return segments;
+}
+
+/**
+ * compare version with current svelte, only takes major.minor.patch into account.
+ * If you don't pass all three, values will be filled with 0, ie `3` is equal to `3.0.0`
+ * @param version
+ * @returns 1 if passed version is larger than current, 0 if it is equal and -1 if it is lower
+ */
+export function compareToSvelte(version: string): 1 | 0 | -1 {
+	const parsedVersion = parseVersion(version);
+	for (let i = 0; i < svelteVersion.length; i++) {
+		const a = parsedVersion[i];
+		const b = svelteVersion[i];
+		if (a === b) {
+			continue;
+		} else if (a > b) {
+			return 1;
+		} else {
+			return -1;
+		}
+	}
+	return 0;
+}
+
+export function atLeastSvelte(version: string) {
+	const result = compareToSvelte(version) <= 0;
+	return result;
+}

package/src/utils/__tests__/dependencies.spec.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findRootSvelteDependencies, needsOptimization } from '../dependencies';
-import * as path from 'path';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-const __dir = path.dirname(fileURLToPath(import.meta.url));
-const e2eTestRoot = path.resolve(__dir, '../../../../../packages/e2e-tests');
-
-describe('dependencies', () => {
-	describe('findRootSvelteDependencies', () => {
-		it('should find svelte dependencies in packages/e2e-test/hmr', () => {
-			const deps = findRootSvelteDependencies(path.resolve('packages/e2e-tests/hmr'));
-			expect(deps).toHaveLength(1);
-			expect(deps[0].name).toBe('e2e-test-dep-svelte-simple');
-			expect(deps[0].path).toEqual([]);
-		});
-		it('should find nested svelte dependencies in packages/e2e-test/package-json-svelte-field', () => {
-			const deps = findRootSvelteDependencies(path.join(e2eTestRoot, 'package-json-svelte-field'));
-			expect(deps).toHaveLength(3);
-			const hybrid = deps.find((dep) => dep.name === 'e2e-test-dep-svelte-hybrid');
-			expect(hybrid).toBeTruthy();
-			expect(hybrid.path).toHaveLength(0);
-			const nested = deps.find((dep) => dep.name === 'e2e-test-dep-svelte-nested');
-			expect(nested).toBeTruthy();
-			expect(nested.path).toHaveLength(0);
-			const simple = deps.find((dep) => dep.name === 'e2e-test-dep-svelte-simple');
-			expect(simple).toBeTruthy();
-			expect(simple.path).toHaveLength(1);
-			expect(simple.path[0]).toBe('e2e-test-dep-svelte-nested');
-		});
-	});
-	describe('needsOptimization', () => {
-		it('should optimize cjs deps only', () => {
-			const testDepsPath = path.join(e2eTestRoot, 'dependencies/package.json');
-			const localRequire = createRequire(testDepsPath);
-			expect(needsOptimization('e2e-test-dep-cjs-and-esm', localRequire)).toBe(false);
-			expect(needsOptimization('e2e-test-dep-cjs-only', localRequire)).toBe(true);
-			expect(needsOptimization('e2e-test-dep-esm-only', localRequire)).toBe(false);
-			expect(needsOptimization('e2e-test-dep-index-only', localRequire)).toBe(true);
-			expect(needsOptimization('e2e-test-dep-types-only', localRequire)).toBe(false);
-		});
-	});
-});