@sveltejs/vite-plugin-svelte 1.0.0-next.9 → 1.0.2

package/src/index.ts

@@ -0,0 +1,242 @@
+import fs from 'fs';
+import { HmrContext, ModuleNode, Plugin, ResolvedConfig, UserConfig } from 'vite';
+import { handleHotUpdate } from './handle-hot-update';
+import { log, logCompilerWarnings } from './utils/log';
+import { CompileData, createCompileSvelte } from './utils/compile';
+import { buildIdParser, IdParser, SvelteRequest } from './utils/id';
+import {
+	buildExtraViteConfig,
+	validateInlineOptions,
+	Options,
+	ResolvedOptions,
+	resolveOptions,
+	patchResolvedViteConfig,
+	preResolveOptions
+} from './utils/options';
+import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache';
+
+import { ensureWatchedFile, setupWatchers } from './utils/watch';
+import { resolveViaPackageJsonSvelte } from './utils/resolve';
+import { PartialResolvedId } from 'rollup';
+import { toRollupError } from './utils/error';
+import { saveSvelteMetadata } from './utils/optimizer';
+import { svelteInspector } from './ui/inspector/plugin';
+
+interface PluginAPI {
+	/**
+	 * must not be modified, should not be used outside of vite-plugin-svelte repo
+	 * @internal
+	 * @experimental
+	 */
+	options?: ResolvedOptions;
+	// TODO expose compile cache here so other utility plugins can use it
+}
+
+export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
+	if (process.env.DEBUG != null) {
+		log.setLevel('debug');
+	}
+	validateInlineOptions(inlineOptions);
+	const cache = new VitePluginSvelteCache();
+	// updated in configResolved hook
+	let requestParser: IdParser;
+	let options: ResolvedOptions;
+	let viteConfig: ResolvedConfig;
+	/* eslint-disable no-unused-vars */
+	let compileSvelte: (
+		svelteRequest: SvelteRequest,
+		code: string,
+		options: Partial<ResolvedOptions>
+	) => Promise<CompileData>;
+	/* eslint-enable no-unused-vars */
+
+	let resolvedSvelteSSR: Promise<PartialResolvedId | null>;
+	const api: PluginAPI = {};
+	const plugins: Plugin[] = [
+		{
+			name: 'vite-plugin-svelte',
+			// make sure our resolver runs before vite internal resolver to resolve svelte field correctly
+			enforce: 'pre',
+			api,
+			async config(config, configEnv): Promise<Partial<UserConfig>> {
+				// setup logger
+				if (process.env.DEBUG) {
+					log.setLevel('debug');
+				} else if (config.logLevel) {
+					log.setLevel(config.logLevel);
+				}
+				// @ts-expect-error temporarily lend the options variable until fixed in configResolved
+				options = await preResolveOptions(inlineOptions, config, configEnv);
+				// extra vite config
+				const extraViteConfig = buildExtraViteConfig(options, config);
+				log.debug('additional vite config', extraViteConfig);
+				return extraViteConfig;
+			},
+
+			async configResolved(config) {
+				options = resolveOptions(options, config);
+				patchResolvedViteConfig(config, options);
+				requestParser = buildIdParser(options);
+				compileSvelte = createCompileSvelte(options);
+				viteConfig = config;
+				// TODO deep clone to avoid mutability from outside?
+				api.options = options;
+				log.debug('resolved options', options);
+			},
+
+			async buildStart() {
+				if (!options.experimental?.prebundleSvelteLibraries) return;
+				const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
+				if (isSvelteMetadataChanged) {
+					// Force Vite to optimize again. Although we mutate the config here, it works because
+					// Vite's optimizer runs after `buildStart()`.
+					// TODO: verify this works in vite3
+					viteConfig.optimizeDeps.force = true;
+				}
+			},
+
+			configureServer(server) {
+				// eslint-disable-next-line no-unused-vars
+				options.server = server;
+				setupWatchers(options, cache, requestParser);
+			},
+
+			load(id, opts) {
+				const ssr = !!opts?.ssr;
+				const svelteRequest = requestParser(id, !!ssr);
+				if (svelteRequest) {
+					const { filename, query } = svelteRequest;
+					// virtual css module
+					if (query.svelte && query.type === 'style') {
+						const css = cache.getCSS(svelteRequest);
+						if (css) {
+							log.debug(`load returns css for ${filename}`);
+							return css;
+						}
+					}
+					// prevent vite asset plugin from loading files as url that should be compiled in transform
+					if (viteConfig.assetsInclude(filename)) {
+						log.debug(`load returns raw content for ${filename}`);
+						return fs.readFileSync(filename, 'utf-8');
+					}
+				}
+			},
+
+			async resolveId(importee, importer, opts) {
+				const ssr = !!opts?.ssr;
+				const svelteRequest = requestParser(importee, ssr);
+				if (svelteRequest?.query.svelte) {
+					if (svelteRequest.query.type === 'style') {
+						// return cssId with root prefix so postcss pipeline of vite finds the directory correctly
+						// see https://github.com/sveltejs/vite-plugin-svelte/issues/14
+						log.debug(`resolveId resolved virtual css module ${svelteRequest.cssId}`);
+						return svelteRequest.cssId;
+					}
+					log.debug(`resolveId resolved ${importee}`);
+					return importee; // query with svelte tag, an id we generated, no need for further analysis
+				}
+
+				if (ssr && importee === 'svelte') {
+					if (!resolvedSvelteSSR) {
+						resolvedSvelteSSR = this.resolve('svelte/ssr', undefined, { skipSelf: true }).then(
+							(svelteSSR) => {
+								log.debug('resolved svelte to svelte/ssr');
+								return svelteSSR;
+							},
+							(err) => {
+								log.debug(
+									'failed to resolve svelte to svelte/ssr. Update svelte to a version that exports it',
+									err
+								);
+								return null; // returning null here leads to svelte getting resolved regularly
+							}
+						);
+					}
+					return resolvedSvelteSSR;
+				}
+				try {
+					const resolved = resolveViaPackageJsonSvelte(importee, importer, cache);
+					if (resolved) {
+						log.debug(
+							`resolveId resolved ${resolved} via package.json svelte field of ${importee}`
+						);
+						return resolved;
+					}
+				} catch (e) {
+					log.debug.once(
+						`error trying to resolve ${importee} from ${importer} via package.json svelte field `,
+						e
+					);
+					// this error most likely happens due to non-svelte related importee/importers so swallow it here
+					// in case it really way a svelte library, users will notice anyway. (lib not working due to failed resolve)
+				}
+			},
+
+			async transform(code, id, opts) {
+				const ssr = !!opts?.ssr;
+				const svelteRequest = requestParser(id, ssr);
+				if (!svelteRequest || svelteRequest.query.svelte) {
+					return;
+				}
+				let compileData;
+				try {
+					compileData = await compileSvelte(svelteRequest, code, options);
+				} catch (e) {
+					cache.setError(svelteRequest, e);
+					throw toRollupError(e, options);
+				}
+				logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
+				cache.update(compileData);
+				if (compileData.dependencies?.length && options.server) {
+					compileData.dependencies.forEach((d) => {
+						ensureWatchedFile(options.server!.watcher, d, options.root);
+					});
+				}
+				log.debug(`transform returns compiled js for ${svelteRequest.filename}`);
+				return {
+					...compileData.compiled.js,
+					meta: {
+						vite: {
+							lang: compileData.lang
+						}
+					}
+				};
+			},
+
+			handleHotUpdate(ctx: HmrContext): void | Promise<Array<ModuleNode> | void> {
+				if (!options.hot || !options.emitCss) {
+					return;
+				}
+				const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
+				if (svelteRequest) {
+					try {
+						return handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options);
+					} catch (e) {
+						throw toRollupError(e, options);
+					}
+				}
+			}
+		}
+	];
+	plugins.push(svelteInspector());
+	return plugins.filter(Boolean);
+}
+
+export { loadSvelteConfig } from './utils/load-svelte-config';
+
+export {
+	Options,
+	PluginOptions,
+	SvelteOptions,
+	Preprocessor,
+	PreprocessorGroup,
+	CompileOptions,
+	CssHashGetter,
+	Arrayable,
+	MarkupPreprocessor,
+	ModuleFormat,
+	Processed,
+	Warning
+} from './utils/options';
+
+export { SvelteWarningsMessage } from './utils/log';

package/src/ui/inspector/Inspector.svelte

@@ -0,0 +1,245 @@
+<script>
+	// do not use TS here so that this component works in non-ts projects too
+	import { onMount } from 'svelte';
+	// eslint-disable-next-line node/no-missing-import
+	import options from 'virtual:svelte-inspector-options';
+	const toggle_combo = options.toggleKeyCombo?.toLowerCase().split('-');
+
+	let enabled = false;
+
+	const icon = `data:image/svg+xml;base64,${btoa(
+		`
+<svg xmlns="http://www.w3.org/2000/svg" width="21" height="25" viewBox="0 0 107 128">
+  <title>svelte-inspector-logo</title>
+  <path d="M94.1566,22.8189c-10.4-14.8851-30.94-19.2971-45.7914-9.8348L22.2825,29.6078A29.9234,29.9234,0,0,0,8.7639,49.6506a31.5136,31.5136,0,0,0,3.1076,20.2318A30.0061,30.0061,0,0,0,7.3953,81.0653a31.8886,31.8886,0,0,0,5.4473,24.1157c10.4022,14.8865,30.9423,19.2966,45.7914,9.8348L84.7167,98.3921A29.9177,29.9177,0,0,0,98.2353,78.3493,31.5263,31.5263,0,0,0,95.13,58.117a30,30,0,0,0,4.4743-11.1824,31.88,31.88,0,0,0-5.4473-24.1157" style="fill:#ff3e00"/><path d="M45.8171,106.5815A20.7182,20.7182,0,0,1,23.58,98.3389a19.1739,19.1739,0,0,1-3.2766-14.5025,18.1886,18.1886,0,0,1,.6233-2.4357l.4912-1.4978,1.3363.9815a33.6443,33.6443,0,0,0,10.203,5.0978l.9694.2941-.0893.9675a5.8474,5.8474,0,0,0,1.052,3.8781,6.2389,6.2389,0,0,0,6.6952,2.485,5.7449,5.7449,0,0,0,1.6021-.7041L69.27,76.281a5.4306,5.4306,0,0,0,2.4506-3.631,5.7948,5.7948,0,0,0-.9875-4.3712,6.2436,6.2436,0,0,0-6.6978-2.4864,5.7427,5.7427,0,0,0-1.6.7036l-9.9532,6.3449a19.0329,19.0329,0,0,1-5.2965,2.3259,20.7181,20.7181,0,0,1-22.2368-8.2427,19.1725,19.1725,0,0,1-3.2766-14.5024,17.9885,17.9885,0,0,1,8.13-12.0513L55.8833,23.7472a19.0038,19.0038,0,0,1,5.3-2.3287A20.7182,20.7182,0,0,1,83.42,29.6611a19.1739,19.1739,0,0,1,3.2766,14.5025,18.4,18.4,0,0,1-.6233,2.4357l-.4912,1.4978-1.3356-.98a33.6175,33.6175,0,0,0-10.2037-5.1l-.9694-.2942.0893-.9675a5.8588,5.8588,0,0,0-1.052-3.878,6.2389,6.2389,0,0,0-6.6952-2.485,5.7449,5.7449,0,0,0-1.6021.7041L37.73,51.719a5.4218,5.4218,0,0,0-2.4487,3.63,5.7862,5.7862,0,0,0,.9856,4.3717,6.2437,6.2437,0,0,0,6.6978,2.4864,5.7652,5.7652,0,0,0,1.602-.7041l9.9519-6.3425a18.978,18.978,0,0,1,5.2959-2.3278,20.7181,20.7181,0,0,1,22.2368,8.2427,19.1725,19.1725,0,0,1,3.2766,14.5024,17.9977,17.9977,0,0,1-8.13,12.0532L51.1167,104.2528a19.0038,19.0038,0,0,1-5.3,2.3287" style="fill:#fff"/>
+  <polygon points="0,0 15,40 40,20" stroke="#ff3e00" fill="#ff3e00"></polygon>
+</svg>
+`
+			.replace(/[\n\r\t\s]+/g, ' ')
+			.trim()
+	)}`;
+
+	// location of code in file
+	let file_loc;
+	// cursor pos and width for file_loc overlay positioning
+	let x, y, w;
+
+	let active_el;
+	let toggle_el;
+
+	let enabled_ts;
+
+	$: show_toggle =
+		options.showToggleButton === 'always' || (options.showToggleButton === 'active' && enabled);
+
+	function mousemove(event) {
+		x = event.x;
+		y = event.y;
+	}
+
+	function findMetaEl(el) {
+		while (el) {
+			const file = el.__svelte_meta?.loc?.file;
+			if (el !== toggle_el && file && !file.includes('node_modules/')) {
+				return el;
+			}
+			el = el.parentNode;
+		}
+	}
+
+	function mouseover(event) {
+		const el = findMetaEl(event.target);
+		if (options.customStyles && el !== active_el) {
+			if (active_el) {
+				active_el.classList.remove('svelte-inspector-active-target');
+			}
+			if (el) {
+				el.classList.add('svelte-inspector-active-target');
+			}
+		}
+		if (el) {
+			const { file, line, column } = el.__svelte_meta.loc;
+			file_loc = `${file}:${line + 1}:${column + 1}`;
+		} else {
+			file_loc = null;
+		}
+		active_el = el;
+	}
+
+	function click(event) {
+		if (file_loc) {
+			event.preventDefault();
+			event.stopPropagation();
+			event.stopImmediatePropagation();
+			fetch(`/__open-in-editor?file=${encodeURIComponent(file_loc)}`);
+			if (options.holdMode && is_holding()) {
+				disable();
+			}
+		}
+	}
+
+	function is_key_active(key, event) {
+		switch (key) {
+			case 'shift':
+			case 'control':
+			case 'alt':
+			case 'meta':
+				return event.getModifierState(key.charAt(0).toUpperCase() + key.slice(1));
+			default:
+				return key === event.key.toLowerCase();
+		}
+	}
+
+	function is_combo(event) {
+		return toggle_combo?.every((key) => is_key_active(key, event));
+	}
+
+	function is_holding() {
+		return enabled_ts && Date.now() - enabled_ts > 250;
+	}
+
+	function keydown(event) {
+		if (event.repeat || event.key === undefined) {
+			return;
+		}
+
+		if (is_combo(event)) {
+			toggle();
+			if (options.holdMode && enabled) {
+				enabled_ts = Date.now();
+			}
+		}
+	}
+
+	function keyup(event) {
+		if (event.repeat) {
+			return;
+		}
+		const k = event.key.toLowerCase();
+		if (enabled && is_holding() && toggle_combo.includes(k)) {
+			disable();
+		} else {
+			enabled_ts = null;
+		}
+	}
+
+	function toggle() {
+		enabled ? disable() : enable();
+	}
+
+	function listeners(body, enabled) {
+		const l = enabled ? body.addEventListener : body.removeEventListener;
+		l('mousemove', mousemove);
+		l('mouseover', mouseover);
+		l('click', click, true);
+	}
+
+	function enable() {
+		enabled = true;
+		const b = document.body;
+		if (options.customStyles) {
+			b.classList.add('svelte-inspector-enabled');
+		}
+		listeners(b, enabled);
+	}
+
+	function disable() {
+		enabled = false;
+		enabled_ts = null;
+		const b = document.body;
+		listeners(b, enabled);
+		if (options.customStyles) {
+			b.classList.remove('svelte-inspector-enabled');
+			active_el?.classList.remove('svelte-inspector-active-target');
+		}
+		active_el = null;
+	}
+
+	onMount(() => {
+		const s = document.createElement('style');
+		s.setAttribute('type', 'text/css');
+		s.setAttribute('id', 'svelte-inspector-style');
+		s.textContent = `:root { --svelte-inspector-icon: url(${icon})};`;
+		document.head.append(s);
+		if (toggle_combo) {
+			document.body.addEventListener('keydown', keydown);
+			if (options.holdMode) {
+				document.body.addEventListener('keyup', keyup);
+			}
+		}
+		return () => {
+			// make sure we get rid of everything
+			disable();
+			const s = document.head.querySelector('#svelte-inspector-style');
+			if (s) {
+				document.head.removeChild(s);
+			}
+			if (toggle_combo) {
+				document.body.removeEventListener('keydown', keydown);
+				if (options.holdMode) {
+					document.body.addEventListener('keyup', keyup);
+				}
+			}
+		};
+	});
+</script>
+
+{#if show_toggle}
+	<div
+		class="svelte-inspector-toggle"
+		class:enabled
+		style={`background-image: var(--svelte-inspector-icon);${options.toggleButtonPos
+			.split('-')
+			.map((p) => `${p}: 8px;`)
+			.join('')}`}
+		on:click={() => toggle()}
+		bind:this={toggle_el}
+	/>
+{/if}
+{#if enabled && file_loc}
+	<div
+		class="svelte-inspector-overlay"
+		style:left="{Math.min(x + 3, document.body.clientWidth - w - 10)}px"
+		style:top="{y + 30}px"
+		bind:offsetWidth={w}
+	>
+		{file_loc}
+	</div>
+{/if}
+
+<style>
+	:global(body.svelte-inspector-enabled *) {
+		cursor: var(--svelte-inspector-icon), crosshair !important;
+	}
+	:global(.svelte-inspector-active-target) {
+		outline: 2px dashed #ff3e00 !important;
+	}
+
+	.svelte-inspector-overlay {
+		position: fixed;
+		background-color: rgba(0, 0, 0, 0.8);
+		color: #fff;
+		padding: 2px 4px;
+		border-radius: 5px;
+		z-index: 999999;
+	}
+
+	.svelte-inspector-toggle {
+		border: 1px solid #ff3e00;
+		border-radius: 8px;
+		position: fixed;
+		height: 32px;
+		width: 32px;
+		background-color: white;
+		background-position: center;
+		background-repeat: no-repeat;
+		cursor: pointer;
+	}
+
+	.svelte-inspector-toggle:not(.enabled) {
+		filter: grayscale(1);
+	}
+	.svelte-inspector-toggle:hover {
+		background-color: #facece;
+	}
+</style>

package/src/ui/inspector/load-inspector.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line node/no-missing-import
+import Inspector from 'virtual:svelte-inspector-path:Inspector.svelte';
+
+function create_inspector_host() {
+	const id = 'svelte-inspector-host';
+	if (document.getElementById(id) != null) {
+		throw new Error('svelte-inspector-host element already exists');
+	}
+	const el = document.createElement('div');
+	el.setAttribute('id', id);
+	document.getElementsByTagName('body')[0].appendChild(el);
+	return el;
+}
+
+new Inspector({ target: create_inspector_host() });

package/src/ui/inspector/plugin.ts

@@ -0,0 +1,106 @@
+import { Plugin, normalizePath } from 'vite';
+import { log } from '../../utils/log';
+import { InspectorOptions } from '../../utils/options';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const defaultInspectorOptions: InspectorOptions = {
+	toggleKeyCombo: process.platform === 'win32' ? 'control-shift' : 'meta-shift',
+	holdMode: false,
+	showToggleButton: 'active',
+	toggleButtonPos: 'top-right',
+	customStyles: true
+};
+
+function getInspectorPath() {
+	const pluginPath = normalizePath(path.dirname(fileURLToPath(import.meta.url)));
+	return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, '/vite-plugin-svelte/src/ui/inspector/');
+}
+
+export function svelteInspector(): Plugin {
+	const inspectorPath = getInspectorPath();
+	log.debug.enabled && log.debug(`svelte inspector path: ${inspectorPath}`);
+	let inspectorOptions: InspectorOptions;
+	let appendTo: string | undefined;
+	let disabled = false;
+
+	return {
+		name: 'vite-plugin-svelte:inspector',
+		apply: 'serve',
+		enforce: 'pre',
+
+		configResolved(config) {
+			const vps = config.plugins.find((p) => p.name === 'vite-plugin-svelte');
+			if (vps?.api?.options?.experimental?.inspector) {
+				inspectorOptions = {
+					...defaultInspectorOptions,
+					...vps.api.options.experimental.inspector
+				};
+			}
+			if (!vps || !inspectorOptions) {
+				log.debug('inspector disabled, could not find config');
+				disabled = true;
+			} else {
+				if (vps.api.options.kit && !inspectorOptions.appendTo) {
+					const out_dir = path.basename(vps.api.options.kit.outDir || '.svelte-kit');
+					inspectorOptions.appendTo = `${out_dir}/generated/root.svelte`;
+				}
+				appendTo = inspectorOptions.appendTo;
+			}
+		},
+
+		async resolveId(importee: string, importer, options) {
+			if (options?.ssr || disabled) {
+				return;
+			}
+			if (importee.startsWith('virtual:svelte-inspector-options')) {
+				return importee;
+			} else if (importee.startsWith('virtual:svelte-inspector-path:')) {
+				const resolved = importee.replace('virtual:svelte-inspector-path:', inspectorPath);
+				log.debug.enabled && log.debug(`resolved ${importee} with ${resolved}`);
+				return resolved;
+			}
+		},
+
+		async load(id, options) {
+			if (options?.ssr || disabled) {
+				return;
+			}
+			if (id === 'virtual:svelte-inspector-options') {
+				return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
+			} else if (id.startsWith(inspectorPath)) {
+				// read file ourselves to avoid getting shut out by vites fs.allow check
+				return await fs.promises.readFile(id, 'utf-8');
+			}
+		},
+
+		transform(code: string, id: string, options?: { ssr?: boolean }) {
+			if (options?.ssr || disabled || !appendTo) {
+				return;
+			}
+			if (id.endsWith(appendTo)) {
+				return { code: `${code}\nimport 'virtual:svelte-inspector-path:load-inspector.js'` };
+			}
+		},
+		transformIndexHtml(html) {
+			if (disabled || appendTo) {
+				return;
+			}
+			return {
+				html,
+				tags: [
+					{
+						tag: 'script',
+						injectTo: 'body',
+						attrs: {
+							type: 'module',
+							// /@id/ is needed, otherwise the virtual: is seen as protocol by browser and cors error happens
+							src: '/@id/virtual:svelte-inspector-path:load-inspector.js'
+						}
+					}
+				]
+			};
+		}
+	};
+}

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

@@ -0,0 +1,43 @@
+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);
+		});
+	});
+});

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { buildMagicString, buildSourceMap } from '../sourcemap';
+
+describe('sourcemap', () => {
+	describe('buildMagicString', () => {
+		it('should return a valid magic string', async () => {
+			const from = 'h1{color: blue}\nh2{color: green}\nh3{color: red}\n';
+			const to = 'h1{color: blue}\ndiv{color: white}\nh3{color: red}\nh2{color: green}\n';
+			const m = await buildMagicString(from, to);
+			expect(m).toBeDefined();
+			expect(m.original).toBe(from);
+			expect(m.toString()).toBe(to);
+		});
+	});
+	describe('buildSourceMap', () => {
+		it('should return a map with mappings and filename', async () => {
+			const map = await buildSourceMap('foo', 'bar', 'foo.txt');
+			expect(map).toBeDefined();
+			expect(map.mappings).toBeDefined();
+			expect(map.mappings[0]).toBeDefined();
+			expect(map.mappings[0][0]).toBeDefined();
+			expect(map.sources[0]).toBe('foo.txt');
+		});
+	});
+});