@sveltejs/vite-plugin-svelte 2.0.4 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/vite-plugin-svelte",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "license": "MIT",
   "author": "dominikg",
   "files": [
@@ -50,11 +50,11 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
-    "esbuild": "^0.17.12",
+    "esbuild": "^0.17.17",
     "rollup": "^2.79.1",
-    "svelte": "^3.57.0",
+    "svelte": "^3.58.0",
     "tsup": "^6.7.0",
-    "vite": "^4.2.1"
+    "vite": "^4.3.1"
   },
   "scripts": {
     "dev": "pnpm build:ci --sourcemap --watch src",

package/src/__tests__/fixtures/preprocess/foo.scss

@@ -0,0 +1,3 @@
+.foo {
+	color: green;
+}

package/src/__tests__/preprocess.spec.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { vitePreprocess } from '../preprocess';
+import path from 'path';
+import { normalizePath } from 'vite';
+import { fileURLToPath } from 'url';
+
+const fixtureDir = normalizePath(
+	path.join(path.dirname(fileURLToPath(import.meta.url)), 'fixtures', 'preprocess')
+);
+
+describe('vitePreprocess', () => {
+	it('returns function', () => {
+		const preprocessorGroup = vitePreprocess({ script: true, style: true });
+		expect(typeof preprocessorGroup).toBe('object');
+		expect(typeof preprocessorGroup.script).toBe('function');
+		expect(typeof preprocessorGroup.style).toBe('function');
+	});
+
+	describe('style', async () => {
+		it('produces sourcemap with relative filename', async () => {
+			const { style } = vitePreprocess({ style: { css: { devSourcemap: true } } });
+			const scss = `
+			  @import './foo';
+				.foo {
+				  &.bar {
+				    color: red;
+				  }
+				}`.replace(/\t/g, '');
+
+			const processed = await style({
+				content: scss,
+				attributes: {
+					lang: 'scss'
+				},
+				markup: '', // not read by vitePreprocess
+				filename: `${fixtureDir}/File.svelte`
+			});
+			expect(processed).toBeDefined();
+			// @ts-ignore
+			const { code, map, dependencies } = processed;
+			expect(code).toBe('.foo {\n  color: green;\n}\n\n.foo.bar {\n  color: red;\n}');
+			expect(map.file).toBe('File.svelte');
+			expect(map.sources.length).toBe(2);
+			expect(map.sources[0]).toBe('foo.scss');
+			expect(map.sources[1]).toBe('File.svelte');
+			expect(dependencies).toBeDefined();
+			expect(dependencies[0]).toBe(path.resolve(fixtureDir, 'foo.scss'));
+			expect(dependencies.length).toBe(1);
+		});
+	});
+});

package/src/index.ts

@@ -1,5 +1,13 @@
 import fs from 'fs';
-import { HmrContext, ModuleNode, Plugin, ResolvedConfig, UserConfig } from 'vite';
+import { VERSION as svelteVersion } from 'svelte/compiler';
+import {
+	HmrContext,
+	ModuleNode,
+	Plugin,
+	ResolvedConfig,
+	UserConfig,
+	version as viteVersion
+} from 'vite';
 // eslint-disable-next-line node/no-missing-import
 import { isDepExcluded } from 'vitefu';
 import { handleHotUpdate } from './handle-hot-update';
@@ -24,6 +32,7 @@ import { saveSvelteMetadata } from './utils/optimizer';
 import { svelteInspector } from './ui/inspector/plugin';
 import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache';
 import { loadRaw } from './utils/load-raw';
+import { FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE } from './utils/constants';
 
 interface PluginAPI {
 	/**
@@ -35,6 +44,9 @@ interface PluginAPI {
 	// TODO expose compile cache here so other utility plugins can use it
 }
 
+const isVite4_0 = viteVersion.startsWith('4.0');
+const isSvelte3 = svelteVersion.startsWith('3');
+
 export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 	if (process.env.DEBUG != null) {
 		log.setLevel('debug');
@@ -50,6 +62,7 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 	/* eslint-enable no-unused-vars */
 
 	let resolvedSvelteSSR: Promise<PartialResolvedId | null>;
+	let packagesWithResolveWarnings: Set<string>;
 	const api: PluginAPI = {};
 	const plugins: Plugin[] = [
 		{
@@ -73,7 +86,7 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 			},
 
 			async configResolved(config) {
-				options = resolveOptions(options, config);
+				options = resolveOptions(options, config, cache);
 				patchResolvedViteConfig(config, options);
 				requestParser = buildIdParser(options);
 				compileSvelte = createCompileSvelte(options);
@@ -84,6 +97,7 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 			},
 
 			async buildStart() {
+				packagesWithResolveWarnings = new Set<string>();
 				if (!options.prebundleSvelteLibraries) return;
 				const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
 				if (isSvelteMetadataChanged) {
@@ -135,7 +149,8 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 					}
 				}
 
-				if (ssr && importee === 'svelte') {
+				// TODO: remove this after bumping peerDep on Vite to 4.1+ or Svelte to 4.0+
+				if (isVite4_0 && isSvelte3 && ssr && importee === 'svelte') {
 					if (!resolvedSvelteSSR) {
 						resolvedSvelteSSR = this.resolve('svelte/ssr', undefined, { skipSelf: true }).then(
 							(svelteSSR) => {
@@ -164,13 +179,36 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 				// for ssr, during scanning and non-prebundled, we do it
 				if (ssr || scan || !isPrebundled) {
 					try {
+						const isFirstResolve = !cache.hasResolvedSvelteField(importee, importer);
 						const resolved = await resolveViaPackageJsonSvelte(importee, importer, cache);
-						if (resolved) {
-							log.debug(
-								`resolveId resolved ${resolved} via package.json svelte field of ${importee}`
+						if (isFirstResolve && resolved) {
+							const packageInfo = await cache.getPackageInfo(resolved);
+							const packageVersion = `${packageInfo.name}@${packageInfo.version}`;
+							log.debug.once(
+								`resolveId resolved ${importee} to ${resolved} via package.json svelte field of ${packageVersion}`
 							);
-							return resolved;
+
+							try {
+								const viteResolved = (
+									await this.resolve(importee, importer, { ...opts, skipSelf: true })
+								)?.id;
+								if (resolved !== viteResolved) {
+									packagesWithResolveWarnings.add(packageVersion);
+									log.debug.enabled &&
+										log.debug.once(
+											`resolve difference for ${packageVersion} ${importee} - svelte: "${resolved}", vite: "${viteResolved}"`
+										);
+								}
+							} catch (e) {
+								packagesWithResolveWarnings.add(packageVersion);
+								log.debug.enabled &&
+									log.debug.once(
+										`resolve error for ${packageVersion} ${importee} - svelte: "${resolved}", vite: ERROR`,
+										e
+									);
+							}
 						}
+						return resolved;
 					} catch (e) {
 						log.debug.once(
 							`error trying to resolve ${importee} from ${importer} via package.json svelte field `,
@@ -224,6 +262,16 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 			},
 			async buildEnd() {
 				await options.stats?.finishAll();
+				if (
+					!options.experimental?.disableSvelteResolveWarnings &&
+					packagesWithResolveWarnings?.size > 0
+				) {
+					log.warn(
+						`WARNING: The following packages use a svelte resolve configuration in package.json that has conflicting results and is going to cause problems future.\n\n${[
+							...packagesWithResolveWarnings
+						].join('\n')}\n\nPlease see ${FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE} for details.`
+					);
+				}
 			}
 		}
 	];

package/src/preprocess.ts

@@ -2,11 +2,13 @@ import { preprocessCSS, resolveConfig, transformWithEsbuild } from 'vite';
 import type { ESBuildOptions, InlineConfig, ResolvedConfig } from 'vite';
 // eslint-disable-next-line node/no-missing-import
 import type { Preprocessor, PreprocessorGroup } from 'svelte/types/compiler/preprocess';
-import { mapSourcesToRelative } from './utils/sourcemaps';
+import { mapToRelative, removeLangSuffix } from './utils/sourcemaps';
 
 const supportedStyleLangs = ['css', 'less', 'sass', 'scss', 'styl', 'stylus', 'postcss', 'sss'];
 const supportedScriptLangs = ['ts'];
 
+export const lang_sep = '.vite-preprocess.';
+
 export function vitePreprocess(opts?: {
 	script?: boolean;
 	style?: boolean | InlineConfig | ResolvedConfig;
@@ -39,7 +41,7 @@ function viteScript(): { script: Preprocessor } {
 				}
 			});
 
-			mapSourcesToRelative(map, filename);
+			mapToRelative(map, filename);
 
 			return {
 				code,
@@ -72,14 +74,16 @@ function viteStyle(config: InlineConfig | ResolvedConfig = {}): {
 			}
 			transform = getCssTransformFn(resolvedConfig);
 		}
-		const moduleId = `${filename}.${lang}`;
-		const { code, map } = await transform(content, moduleId);
-
-		mapSourcesToRelative(map, moduleId);
-
+		const suffix = `${lang_sep}${lang}`;
+		const moduleId = `${filename}${suffix}`;
+		const { code, map, deps } = await transform(content, moduleId);
+		removeLangSuffix(map, suffix);
+		mapToRelative(map, filename);
+		const dependencies = deps ? Array.from(deps).filter((d) => !d.endsWith(suffix)) : undefined;
 		return {
 			code,
-			map: map ?? undefined
+			map: map ?? undefined,
+			dependencies
 		};
 	};
 	// @ts-expect-error tag so can be found by v-p-s
@@ -87,8 +91,12 @@ function viteStyle(config: InlineConfig | ResolvedConfig = {}): {
 	return { style };
 }
 
-// eslint-disable-next-line no-unused-vars
-type CssTransform = (code: string, filename: string) => Promise<{ code: string; map?: any }>;
+type CssTransform = (
+	// eslint-disable-next-line no-unused-vars
+	code: string,
+	// eslint-disable-next-line no-unused-vars
+	filename: string
+) => Promise<{ code: string; map?: any; deps?: Set<string> }>;
 
 function getCssTransformFn(config: ResolvedConfig): CssTransform {
 	return async (code, filename) => {

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

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { removeLangSuffix, mapToRelative } from '../sourcemaps';
+import { lang_sep } from '../../preprocess';
+import { normalizePath } from 'vite';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const fixtureDir = normalizePath(
+	path.join(path.dirname(fileURLToPath(import.meta.url)), 'fixtures', 'preprocess')
+);
+const filename = 'File.svelte';
+
+describe('removeLangSuffix', () => {
+	it('removes suffix', () => {
+		const suffix = `${lang_sep}scss`;
+		const map = {
+			file: `${fixtureDir}/${filename}${suffix}`,
+			sources: ['foo.scss', `${fixtureDir}/${filename}${suffix}`],
+			sourceRoot: fixtureDir
+		};
+		removeLangSuffix(map, suffix);
+		expect(map.file).toBe(`${fixtureDir}/${filename}`);
+		expect(map.sourceRoot).toBe(fixtureDir);
+		expect(map.sources[0]).toBe('foo.scss');
+		expect(map.sources[1]).toBe(`${fixtureDir}/${filename}`);
+	});
+});
+
+describe('mapToRelative', () => {
+	it('converts absolute to relative', () => {
+		const file = `${fixtureDir}/File.svelte`;
+		const map = {
+			file,
+			sources: [`${fixtureDir}/foo.scss`, file]
+		};
+		mapToRelative(map, file);
+		expect(map.file).toBe('File.svelte');
+		expect(map.sources[0]).toBe('foo.scss');
+		expect(map.sources[1]).toBe('File.svelte');
+	});
+
+	it('accounts for sourceRoot', () => {
+		const file = `${fixtureDir}/File.svelte`;
+		const sourceRoot = normalizePath(path.resolve(fixtureDir, '..'));
+		const rootedBase = fixtureDir.replace(sourceRoot, '');
+		const map = {
+			file,
+			sourceRoot,
+			sources: [
+				`${rootedBase}/foo.scss`,
+				`${rootedBase}/File.svelte`,
+				`${pathToFileURL(`${fixtureDir}/bar.scss`)}`
+			]
+		};
+		mapToRelative(map, file);
+		expect(map.file).toBe('File.svelte');
+		expect(map.sources[0]).toBe('foo.scss');
+		expect(map.sources[1]).toBe('File.svelte');
+		expect(map.sources[2]).toBe('bar.scss');
+		expect(map.sources.length).toBe(3);
+		expect(map.sourceRoot).not.toBeDefined();
+	});
+
+	it('accounts for relative sourceRoot', () => {
+		const file = `${fixtureDir}/File.svelte`;
+		const map = {
+			file,
+			sourceRoot: './some-path/..',
+			sources: [`foo.scss`, `File.svelte`, `${pathToFileURL(`${fixtureDir}/bar.scss`)}`]
+		};
+		mapToRelative(map, file);
+		expect(map.file).toBe('File.svelte');
+		expect(map.sources[0]).toBe('./some-path/../foo.scss');
+		expect(map.sources[1]).toBe('./some-path/../File.svelte');
+		expect(map.sources[2]).toBe('bar.scss');
+		expect(map.sources.length).toBe(3);
+		expect(map.sourceRoot).not.toBeDefined();
+	});
+});

package/src/utils/compile.ts

@@ -9,7 +9,7 @@ import { StatCollection } from './vite-plugin-svelte-stats';
 //eslint-disable-next-line node/no-missing-import
 import type { Processed } from 'svelte/types/compiler/preprocess';
 import { createInjectScopeEverythingRulePreprocessorGroup } from './preprocess';
-import { mapSourcesToRelative } from './sourcemaps';
+import { mapToRelative } from './sourcemaps';
 
 const scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
 
@@ -95,7 +95,7 @@ const _createCompileSvelte = (makeHot: Function) => {
 			if (preprocessed.map) compileOptions.sourcemap = preprocessed.map;
 		}
 		if (typeof preprocessed?.map === 'object') {
-			mapSourcesToRelative(preprocessed?.map, filename);
+			mapToRelative(preprocessed?.map, filename);
 		}
 		if (raw && svelteRequest.query.type === 'preprocessed') {
 			// shortcut
@@ -132,8 +132,8 @@ const _createCompileSvelte = (makeHot: Function) => {
 		if (endStat) {
 			endStat();
 		}
-		mapSourcesToRelative(compiled.js?.map, filename);
-		mapSourcesToRelative(compiled.css?.map, filename);
+		mapToRelative(compiled.js?.map, filename);
+		mapToRelative(compiled.css?.map, filename);
 		if (!raw) {
 			// wire css import and code for hmr
 			const hasCss = compiled.css?.code?.trim().length > 0;

package/src/utils/constants.ts

@@ -20,3 +20,6 @@ export const SVELTE_HMR_IMPORTS = [
 ];
 
 export const SVELTE_EXPORT_CONDITIONS = ['svelte'];
+
+export const FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE =
+	'https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/faq.md#conflicts-in-svelte-resolve';

package/src/utils/log.ts

@@ -3,7 +3,6 @@ import { cyan, yellow, red } from 'kleur/colors';
 import debug from 'debug';
 import { ResolvedOptions, Warning } from './options';
 import { SvelteRequest } from './id';
-
 const levels: string[] = ['debug', 'info', 'warn', 'error', 'silent'];
 const prefix = 'vite-plugin-svelte';
 const loggers: { [key: string]: any } = {
@@ -48,14 +47,21 @@ function setLevel(level: string) {
 	}
 }
 
-function _log(logger: any, message: string, payload?: any) {
+function _log(logger: any, message: string, payload?: any, namespace?: string) {
 	if (!logger.enabled) {
 		return;
 	}
 	if (logger.isDebug) {
-		payload !== undefined ? logger.log(message, payload) : logger.log(message);
+		const log = namespace ? logger.log.extend(namespace) : logger.log;
+		payload !== undefined ? log(message, payload) : log(message);
 	} else {
-		logger.log(logger.color(`${new Date().toLocaleTimeString()} [${prefix}] ${message}`));
+		logger.log(
+			logger.color(
+				`${new Date().toLocaleTimeString()} [${prefix}${
+					namespace ? `:${namespace}` : ''
+				}] ${message}`
+			)
+		);
 		if (payload) {
 			logger.log(payload);
 		}
@@ -63,21 +69,21 @@ function _log(logger: any, message: string, payload?: any) {
 }
 
 export interface LogFn {
-	(message: string, payload?: any): void;
+	(message: string, payload?: any, namespace?: string): void;
 	enabled: boolean;
-	once: (message: string, payload?: any) => void;
+	once: (message: string, payload?: any, namespace?: string) => void;
 }
 
 function createLogger(level: string): LogFn {
 	const logger = loggers[level];
 	const logFn: LogFn = _log.bind(null, logger) as LogFn;
 	const logged = new Set<String>();
-	const once = function (message: string, payload?: any) {
-		if (logged.has(message)) {
+	const once = function (message: string, payload?: any, namespace?: string) {
+		if (!logger.enabled || logged.has(message)) {
 			return;
 		}
 		logged.add(message);
-		logFn.apply(null, [message, payload]);
+		logFn.apply(null, [message, payload, namespace]);
 	};
 	Object.defineProperty(logFn, 'enabled', {
 		get() {
@@ -209,3 +215,7 @@ export function buildExtendedLogMessage(w: Warning) {
 	}
 	return parts.join('');
 }
+
+export function isDebugNamespaceEnabled(namespace: string) {
+	return debug.enabled(`vite:${prefix}:${namespace}`);
+}

package/src/utils/options.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-unused-vars */
 import { ConfigEnv, ResolvedConfig, UserConfig, ViteDevServer, normalizePath } from 'vite';
-import { log } from './log';
+import { isDebugNamespaceEnabled, log } from './log';
 import { loadSvelteConfig } from './load-svelte-config';
 import {
 	SVELTE_EXPORT_CONDITIONS,
@@ -34,6 +34,7 @@ import {
 
 import { isCommonDepWithoutSvelteField } from './dependencies';
 import { VitePluginSvelteStats } from './vite-plugin-svelte-stats';
+import { VitePluginSvelteCache } from './vite-plugin-svelte-cache';
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -178,7 +179,8 @@ function mergeConfigs<T>(...configs: (Partial<T> | undefined)[]): T {
 // also validates the final config.
 export function resolveOptions(
 	preResolveOptions: PreResolvedOptions,
-	viteConfig: ResolvedConfig
+	viteConfig: ResolvedConfig,
+	cache: VitePluginSvelteCache
 ): ResolvedOptions {
 	const css = preResolveOptions.emitCss ? 'external' : 'injected';
 	const defaultOptions: Partial<Options> = {
@@ -206,12 +208,8 @@ export function resolveOptions(
 	enforceOptionsForHmr(merged);
 	enforceOptionsForProduction(merged);
 	// mergeConfigs would mangle functions on the stats class, so do this afterwards
-	const isLogLevelInfo = [undefined, 'info'].includes(viteConfig.logLevel);
-	const disableCompileStats = merged.experimental?.disableCompileStats;
-	const statsEnabled =
-		disableCompileStats !== true && disableCompileStats !== (merged.isBuild ? 'build' : 'dev');
-	if (statsEnabled && isLogLevelInfo) {
-		merged.stats = new VitePluginSvelteStats();
+	if (log.debug.enabled && isDebugNamespaceEnabled('stats')) {
+		merged.stats = new VitePluginSvelteStats(cache);
 	}
 	return merged;
 }
@@ -727,11 +725,11 @@ export interface ExperimentalOptions {
 	sendWarningsToBrowser?: boolean;
 
 	/**
-	 * disable svelte compile statistics
+	 * disable svelte field resolve warnings
 	 *
 	 * @default false
 	 */
-	disableCompileStats?: 'dev' | 'build' | boolean;
+	disableSvelteResolveWarnings?: boolean;
 }
 
 export interface InspectorOptions {

package/src/utils/sourcemaps.ts

@@ -1,20 +1,73 @@
 import path from 'path';
+const IS_WINDOWS = process.platform === 'win32';
+interface SourceMapFileRefs {
+	file?: string;
+	sources?: string[];
+	sourceRoot?: string;
+}
+
+/**
+ * convert absolute paths in sourcemap file refs to their relative equivalents to avoid leaking fs info
+ *
+ * map is modified in place.
+ *
+ * @param map sourcemap
+ * @param filename absolute path to file the sourcemap is for
+ */
+export function mapToRelative(map: SourceMapFileRefs | undefined, filename: string) {
+	if (!map) {
+		return;
+	}
+	const sourceRoot = map.sourceRoot;
+	const dirname = path.dirname(filename);
+	const toRelative = (s: string) => {
+		if (!s) {
+			return s;
+		}
+		let sourcePath: string;
+		if (s.startsWith('file:///')) {
+			// windows has file:///C:/foo and posix has file:///foo, so we have to remove one extra on windows
+			sourcePath = s.slice(IS_WINDOWS ? 8 : 7);
+		} else if (sourceRoot) {
+			const sep = sourceRoot[sourceRoot.length - 1] === '/' || s[0] === '/' ? '' : '/';
+			sourcePath = `${sourceRoot}${sep}${s}`;
+		} else {
+			sourcePath = s;
+		}
+		return path.isAbsolute(sourcePath) ? path.relative(dirname, sourcePath) : sourcePath;
+	};
+
+	if (map.file) {
+		map.file = path.basename(filename);
+	}
+	if (map.sources) {
+		map.sources = map.sources.map(toRelative);
+	}
+	if (map.sourceRoot) {
+		// we have prepended sourceRoot and computed relative paths from it
+		// remove it here to avoid downstream processing prepending it again
+		delete map.sourceRoot;
+	}
+}
 
 /**
- * sourcemap sources are relative to the sourcemap itself
- * assume the sourcemap location is the same as filename and turn absolute paths to relative
- * to avoid leaking fs information like vite root
+ * vitePreprocess uses an extra lang extension to tell vite about the type of preprocessor to use
+ * This function removes it afterwards to get back working file refs
+ *
+ * map is modified in place.
+ *
+ * @param map the output sourcemap
+ * @param suffix the suffix to remove
  */
-export function mapSourcesToRelative(map: { sources?: string[] }, filename: string) {
-	if (map?.sources) {
-		map.sources = map.sources.map((s) => {
-			if (path.isAbsolute(s)) {
-				const relative = path.relative(filename, s);
-				// empty string as a source is not allowed, use simple filename
-				return relative === '' ? path.basename(filename) : relative;
-			} else {
-				return s;
-			}
-		});
+export function removeLangSuffix(map: SourceMapFileRefs | undefined, suffix: string) {
+	if (!map) {
+		return;
+	}
+	const removeSuffix = (s: string) => (s?.endsWith(suffix) ? s.slice(0, -1 * suffix.length) : s);
+	if (map.file) {
+		map.file = removeSuffix(map.file);
+	}
+	if (map.sources) {
+		map.sources = map.sources.map(removeSuffix);
 	}
 }

package/src/utils/vite-plugin-svelte-cache.ts

@@ -1,5 +1,17 @@
 import { SvelteRequest } from './id';
 import { Code, CompileData } from './compile';
+import { readFileSync } from 'fs';
+import { dirname } from 'path';
+//eslint-disable-next-line node/no-missing-import
+import { findClosestPkgJsonPath } from 'vitefu';
+import { normalizePath } from 'vite';
+
+interface PackageInfo {
+	name: string;
+	version: string;
+	svelte?: string;
+	path: string;
+}
 
 export class VitePluginSvelteCache {
 	private _css = new Map<string, Code>();
@@ -8,6 +20,7 @@ export class VitePluginSvelteCache {
 	private _dependants = new Map<string, Set<string>>();
 	private _resolvedSvelteFields = new Map<string, string>();
 	private _errors = new Map<string, any>();
+	private _packageInfos: PackageInfo[] = [];
 
 	public update(compileData: CompileData) {
 		this._errors.delete(compileData.normalizedFilename);
@@ -110,6 +123,9 @@ export class VitePluginSvelteCache {
 		return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
 	}
 
+	public hasResolvedSvelteField(name: string, importer?: string) {
+		return this._resolvedSvelteFields.has(this._getResolvedSvelteFieldKey(name, importer));
+	}
 	public setResolvedSvelteField(
 		importee: string,
 		importer: string | undefined = undefined,
@@ -124,4 +140,43 @@ export class VitePluginSvelteCache {
 	private _getResolvedSvelteFieldKey(importee: string, importer?: string): string {
 		return importer ? `${importer} > ${importee}` : importee;
 	}
+
+	public async getPackageInfo(file: string): Promise<PackageInfo> {
+		let info = this._packageInfos.find((pi) => file.startsWith(pi.path));
+		if (!info) {
+			info = await findPackageInfo(file);
+			this._packageInfos.push(info);
+		}
+		return info;
+	}
+}
+
+/**
+ * utility to get some info from the closest package.json with a "name" set
+ *
+ * @param {string} file to find info for
+ * @returns {PackageInfo}
+ */
+async function findPackageInfo(file: string): Promise<PackageInfo> {
+	const info: PackageInfo = {
+		name: '$unknown',
+		version: '0.0.0-unknown',
+		path: '$unknown'
+	};
+	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+		if (pkg.name != null) {
+			info.name = pkg.name;
+			if (pkg.version != null) {
+				info.version = pkg.version;
+			}
+			info.svelte = pkg.svelte;
+			return true;
+		}
+		return false;
+	});
+	// return normalized path with appended '/' so .startsWith works for future file checks
+	path = normalizePath(dirname(path ?? file)) + '/';
+	info.path = path;
+	return info;
 }