@sveltejs/vite-plugin-svelte 6.0.0-next.1 → 6.0.0-next.3

package/src/types/compile.d.ts

@@ -1,14 +1,21 @@
 import type { Processed, CompileResult } from 'svelte/compiler';
 import type { SvelteRequest } from './id.d.ts';
 import type { ResolvedOptions } from './options.d.ts';
-import type { CustomPluginOptionsVite } from 'vite';
+import type { CustomPluginOptionsVite, Rollup } from 'vite';
 
 export type CompileSvelte = (
 	svelteRequest: SvelteRequest,
 	code: string,
-	options: Partial<ResolvedOptions>
+	options: Partial<ResolvedOptions>,
+	sourcemap?: Rollup.SourceMap
 ) => Promise<CompileData>;
 
+export type PreprocessSvelte = (
+	svelteRequest: SvelteRequest,
+	code: string,
+	options: Partial<ResolvedOptions>
+) => Promise<Processed | undefined>;
+
 export interface Code {
 	code: string;
 	map?: any;
@@ -23,9 +30,8 @@ export interface Code {
 export interface CompileData {
 	filename: string;
 	normalizedFilename: string;
+	cssId: string;
 	lang: string;
 	compiled: CompileResult;
 	ssr: boolean | undefined;
-	dependencies: string[];
-	preprocessed: Processed;
 }

package/src/types/id.d.ts

@@ -1,16 +1,9 @@
-import type { CompileOptions } from 'svelte/compiler';
-
-export type SvelteQueryTypes = 'style' | 'script' | 'preprocessed' | 'all';
+export type SvelteQueryTypes = 'style';
 
 export interface RequestQuery {
 	// our own
 	svelte?: boolean;
 	type?: SvelteQueryTypes;
-	sourcemap?: boolean;
-	compilerOptions?: Pick<
-		CompileOptions,
-		'generate' | 'dev' | 'css' | 'customElement' | 'immutable'
-	>;
 	// vite specific
 	url?: boolean;
 	raw?: boolean;

package/src/types/plugin-api.d.ts

@@ -1,11 +1,10 @@
 import type { ResolvedOptions } from './options.d.ts';
+import type { IdFilter, IdParser } from './id.d.ts';
+import type { CompileSvelte } from './compile.d.ts';
 
 export 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
+	options: ResolvedOptions;
+	idFilter: IdFilter;
+	idParser: IdParser;
+	compileSvelte: CompileSvelte;
 }

package/src/utils/compile.js

@@ -2,10 +2,6 @@ import * as svelte from 'svelte/compiler';
 import { safeBase64Hash } from './hash.js';
 import { log } from './log.js';
 
-import {
-	checkPreprocessDependencies,
-	createInjectScopeEverythingRulePreprocessorGroup
-} from './preprocess.js';
 import { mapToRelative } from './sourcemaps.js';
 import { enhanceCompileError } from './error.js';
 
@@ -21,13 +17,10 @@ const scriptLangRE =
 export function createCompileSvelte() {
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
 	let stats;
-	const devStylePreprocessor = createInjectScopeEverythingRulePreprocessorGroup();
 	/** @type {import('../types/compile.d.ts').CompileSvelte} */
-	return async function compileSvelte(svelteRequest, code, options) {
+	return async function compileSvelte(svelteRequest, code, options, sourcemap) {
 		const { filename, normalizedFilename, cssId, ssr, raw } = svelteRequest;
 		const { emitCss = true } = options;
-		/** @type {string[]} */
-		const dependencies = [];
 		/** @type {import('svelte/compiler').Warning[]} */
 		const warnings = [];
 
@@ -55,6 +48,7 @@ export function createCompileSvelte() {
 				// also they for hmr updates too
 			}
 		}
+
 		/** @type {import('svelte/compiler').CompileOptions} */
 		const compileOptions = {
 			...options.compilerOptions,
@@ -62,53 +56,18 @@ export function createCompileSvelte() {
 			generate: ssr ? 'server' : 'client'
 		};
 
+		let finalCode = code;
 		if (compileOptions.hmr && options.emitCss) {
 			const hash = `s-${safeBase64Hash(normalizedFilename)}`;
 			compileOptions.cssHash = () => hash;
-		}
-
-		let preprocessed;
-		let preprocessors = options.preprocess;
-		if (!options.isBuild && options.emitCss && compileOptions.hmr) {
-			// inject preprocessor that ensures css hmr works better
-			if (!Array.isArray(preprocessors)) {
-				preprocessors = preprocessors
-					? [preprocessors, devStylePreprocessor]
-					: [devStylePreprocessor];
-			} else {
-				preprocessors = preprocessors.concat(devStylePreprocessor);
+			const closeStylePos = code.lastIndexOf('</style>');
+			if (closeStylePos > -1) {
+				// inject rule that forces compile to attach scope class to every node in the template
+				// this reduces the amount of js hot updates when editing css in .svelte files
+				finalCode = finalCode.slice(0, closeStylePos) + ' *{}' + finalCode.slice(closeStylePos);
 			}
 		}
-		if (preprocessors) {
-			try {
-				preprocessed = await svelte.preprocess(code, preprocessors, { filename }); // full filename here so postcss works
-			} catch (e) {
-				e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ''}`;
-				throw e;
-			}
 
-			if (preprocessed.dependencies?.length) {
-				const checked = checkPreprocessDependencies(filename, preprocessed.dependencies);
-				if (checked.warnings.length) {
-					warnings.push(...checked.warnings);
-				}
-				if (checked.dependencies.length) {
-					dependencies.push(...checked.dependencies);
-				}
-			}
-
-			if (preprocessed.map) compileOptions.sourcemap = preprocessed.map;
-		}
-		if (typeof preprocessed?.map === 'object') {
-			mapToRelative(preprocessed?.map, filename);
-		}
-		if (raw && svelteRequest.query.type === 'preprocessed') {
-			// @ts-expect-error shortcut
-			return /** @type {import('../types/compile.d.ts').CompileData} */ {
-				preprocessed: preprocessed ?? { code }
-			};
-		}
-		const finalCode = preprocessed ? preprocessed.code : code;
 		const dynamicCompileOptions = await options?.dynamicCompileOptions?.({
 			filename,
 			code: finalCode,
@@ -127,6 +86,9 @@ export function createCompileSvelte() {
 					...dynamicCompileOptions
 				}
 			: compileOptions;
+		if (sourcemap) {
+			finalCompileOptions.sourcemap = sourcemap;
+		}
 		const endStat = stats?.start(filename);
 		/** @type {import('svelte/compiler').CompileResult} */
 		let compiled;
@@ -145,7 +107,7 @@ export function createCompileSvelte() {
 				);
 			}
 		} catch (e) {
-			enhanceCompileError(e, code, preprocessors);
+			enhanceCompileError(e, code, options.preprocess);
 			throw e;
 		}
 
@@ -181,11 +143,10 @@ export function createCompileSvelte() {
 		return {
 			filename,
 			normalizedFilename,
+			cssId,
 			lang,
 			compiled,
-			ssr,
-			dependencies,
-			preprocessed: preprocessed ?? { code }
+			ssr
 		};
 	};
 }

package/src/utils/constants.js

@@ -26,11 +26,11 @@ export const SVELTE_EXPORT_CONDITIONS = ['svelte'];
 export const FAQ_LINK_MISSING_EXPORTS_CONDITION =
 	'https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/faq.md#missing-exports-condition';
 
+export const LINK_TRANSFORM_WITH_PLUGIN =
+	'https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/advanced-usage.md#transform-svelte-files-with-vite-plugins';
+
 export const DEFAULT_SVELTE_EXT = ['.svelte'];
 export const DEFAULT_SVELTE_MODULE_INFIX = ['.svelte.'];
 export const DEFAULT_SVELTE_MODULE_EXT = ['.js', '.ts'];
 
-export const SVELTE_VIRTUAL_STYLE_SUFFIX = '?svelte&type=style&lang.css';
-export const SVELTE_VIRTUAL_STYLE_ID_REGEX = new RegExp(
-	`${SVELTE_VIRTUAL_STYLE_SUFFIX.replace(/[?.]/g, '\\$&')}$`
-);
+export const SVELTE_VIRTUAL_STYLE_ID_REGEX = /[?&]svelte&type=style&lang.css$/;

package/src/utils/dependencies.js

@@ -1,32 +1,3 @@
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { findDepPkgJsonPath } from 'vitefu';
-
-/**
- * @typedef {{
- *  dir: string;
- *	pkg: Record<string, any>;
- * }} DependencyData
- */
-
-/**
- * @param {string} dep
- * @param {string} parent
- * @returns {Promise<DependencyData | undefined>}
- */
-export async function resolveDependencyData(dep, parent) {
-	const depDataPath = await findDepPkgJsonPath(dep, parent);
-	if (!depDataPath) return undefined;
-	try {
-		return {
-			dir: path.dirname(depDataPath),
-			pkg: JSON.parse(await fs.readFile(depDataPath, 'utf-8'))
-		};
-	} catch {
-		return undefined;
-	}
-}
-
 const COMMON_DEPENDENCIES_WITHOUT_SVELTE_FIELD = [
 	'@lukeed/uuid',
 	'@playwright/test',

package/src/utils/id.js

@@ -5,7 +5,8 @@ import { log } from './log.js';
 import {
 	DEFAULT_SVELTE_EXT,
 	DEFAULT_SVELTE_MODULE_EXT,
-	DEFAULT_SVELTE_MODULE_INFIX
+	DEFAULT_SVELTE_MODULE_INFIX,
+	SVELTE_VIRTUAL_STYLE_ID_REGEX
 } from './constants.js';
 import { arraify } from './options.js';
 
@@ -179,13 +180,15 @@ export function buildIdFilter(options) {
 			.map(escapeRE)
 			.join('|')})(?:[?#]|$)`
 	);
-	const filter = {
+	return {
 		id: {
 			include: [extensionsRE, .../**@type {Array<string|RegExp>}*/ arraify(include)],
-			exclude: /**@type {Array<string|RegExp>}*/ arraify(exclude)
+			exclude: /**@type {Array<string|RegExp>}*/ [
+				SVELTE_VIRTUAL_STYLE_ID_REGEX, // exclude from regular pipeline, we load it in a separate plugin
+				...arraify(exclude)
+			]
 		}
 	};
-	return filter;
 }
 
 /**

package/src/utils/options.js

@@ -6,10 +6,9 @@ const {
 	defaultClientConditions,
 	defaultServerConditions,
 	normalizePath,
-	//@ts-expect-error rolldownVersion not in type
-	rolldownVersion
+	searchForWorkspaceRoot
 } = vite;
-import { isDebugNamespaceEnabled, log } from './log.js';
+import { log } from './log.js';
 import { loadSvelteConfig } from './load-svelte-config.js';
 import {
 	DEFAULT_SVELTE_EXT,
@@ -20,12 +19,6 @@ import {
 } from './constants.js';
 
 import path from 'node:path';
-import {
-	optimizeSvelteModulePluginName,
-	optimizeSveltePluginName,
-	patchESBuildOptimizerPlugin,
-	patchRolldownOptimizerPlugin
-} from './optimizer-plugins.js';
 import { addExtraPreprocessors } from './preprocess.js';
 import deepmerge from 'deepmerge';
 import {
@@ -37,7 +30,6 @@ import {
 } from 'vitefu';
 
 import { isCommonDepWithoutSvelteField } from './dependencies.js';
-import { VitePluginSvelteStats } from './vite-plugin-svelte-stats.js';
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -198,10 +190,9 @@ function mergeConfigs(...configs) {
  *
  * @param {import('../types/options.d.ts').PreResolvedOptions} preResolveOptions
  * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
  * @returns {import('../types/options.d.ts').ResolvedOptions}
  */
-export function resolveOptions(preResolveOptions, viteConfig, cache) {
+export function resolveOptions(preResolveOptions, viteConfig) {
 	const css = preResolveOptions.emitCss ? 'external' : 'injected';
 	/** @type {Partial<import('../public.d.ts').Options>} */
 	const defaultOptions = {
@@ -230,10 +221,7 @@ export function resolveOptions(preResolveOptions, viteConfig, cache) {
 	addExtraPreprocessors(merged, viteConfig);
 	enforceOptionsForHmr(merged, viteConfig);
 	enforceOptionsForProduction(merged);
-	// mergeConfigs would mangle functions on the stats class, so do this afterwards
-	if (log.debug.enabled && isDebugNamespaceEnabled('stats')) {
-		merged.stats = new VitePluginSvelteStats(cache);
-	}
+
 	return merged;
 }
 
@@ -384,46 +372,6 @@ export async function buildExtraViteConfig(options, config) {
 		]
 	};
 
-	// handle prebundling for svelte files
-	if (options.prebundleSvelteLibraries) {
-		extraViteConfig.optimizeDeps = {
-			...extraViteConfig.optimizeDeps,
-			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			extensions: options.extensions ?? ['.svelte']
-		};
-		// Add optimizer plugins to prebundle Svelte files.
-		// Currently a placeholder as more information is needed after Vite config is resolved,
-		// the added plugins are patched in `patchResolvedViteConfig()`
-		if (rolldownVersion) {
-			/**
-			 *
-			 * @param {string} name
-			 * @returns {import('vite').Rollup.Plugin}
-			 */
-			const placeholderRolldownOptimizerPlugin = (name) => ({
-				name,
-				options() {},
-				buildStart() {},
-				buildEnd() {},
-				transform: { filter: { id: /^$/ }, handler() {} }
-			});
-			//@ts-expect-error rolldown types not finished
-			extraViteConfig.optimizeDeps.rollupOptions = {
-				plugins: [
-					placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
-					placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
-				]
-			};
-		} else {
-			extraViteConfig.optimizeDeps.esbuildOptions = {
-				plugins: [
-					{ name: optimizeSveltePluginName, setup: () => {} },
-					{ name: optimizeSvelteModulePluginName, setup: () => {} }
-				]
-			};
-		}
-	}
-
 	// enable hmrPartialAccept if not explicitly disabled
 	if (config.experimental?.hmrPartialAccept !== false) {
 		log.debug('enabling "experimental.hmrPartialAccept" in vite config', undefined, 'config');
@@ -482,6 +430,7 @@ async function buildExtraConfigForDependencies(options, config) {
 	const packagesWithoutSvelteExportsCondition = new Set();
 	const depsConfig = await crawlFrameworkPkgs({
 		root: options.root,
+		workspaceRoot: searchForWorkspaceRoot(options.root),
 		isBuild: options.isBuild,
 		viteUserConfig: config,
 		isFrameworkPkgByJson(pkgJson) {
@@ -514,11 +463,12 @@ async function buildExtraConfigForDependencies(options, config) {
 		}
 	});
 	if (
+		!options.isBuild &&
 		!options.experimental?.disableSvelteResolveWarnings &&
 		packagesWithoutSvelteExportsCondition?.size > 0
 	) {
-		log.warn(
-			`WARNING: The following packages have a svelte field in their package.json but no exports condition for svelte.\n\n${[
+		log.info.once(
+			`The following packages have a svelte field in their package.json but no exports condition for svelte.\n\n${[
 				...packagesWithoutSvelteExportsCondition
 			].join('\n')}\n\nPlease see ${FAQ_LINK_MISSING_EXPORTS_CONDITION} for details.`
 		);
@@ -607,38 +557,6 @@ function buildExtraConfigForSvelte(config) {
 	return { optimizeDeps: { include, exclude }, ssr: { noExternal, external } };
 }
 
-/**
- * @param {import('vite').ResolvedConfig} viteConfig
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- */
-export function patchResolvedViteConfig(viteConfig, options) {
-	if (options.preprocess) {
-		for (const preprocessor of arraify(options.preprocess)) {
-			if (preprocessor.style && '__resolvedConfig' in preprocessor.style) {
-				preprocessor.style.__resolvedConfig = viteConfig;
-			}
-		}
-	}
-	if (rolldownVersion) {
-		const plugins =
-			// @ts-expect-error not typed
-			viteConfig.optimizeDeps.rollupOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchRolldownOptimizerPlugin(plugin, options);
-		}
-	} else {
-		const plugins =
-			viteConfig.optimizeDeps.esbuildOptions?.plugins?.filter((p) =>
-				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
-			) ?? [];
-		for (const plugin of plugins) {
-			patchESBuildOptimizerPlugin(plugin, options);
-		}
-	}
-}
-
 /**
  * Mutates `config` to ensure `resolve.mainFields` is set. If unset, it emulates Vite's default fallback.
  * @param {string} name

package/src/utils/preprocess.js

@@ -1,32 +1,5 @@
-import MagicString from 'magic-string';
 import { log } from './log.js';
-import path from 'node:path';
-import { normalizePath } from 'vite';
-
-/**
- * this appends a *{} rule to component styles to force the svelte compiler to add style classes to all nodes
- * That means adding/removing class rules from <style> node won't trigger js updates as the scope classes are not changed
- *
- * only used during dev with enabled css hmr
- *
- * @returns {import('svelte/compiler').PreprocessorGroup}
- */
-export function createInjectScopeEverythingRulePreprocessorGroup() {
-	return {
-		name: 'inject-scope-everything-rule',
-		style({ content, filename }) {
-			const s = new MagicString(content);
-			s.append(' *{}');
-			return {
-				code: s.toString(),
-				map: s.generateDecodedMap({
-					source: filename ? path.basename(filename) : undefined,
-					hires: true
-				})
-			};
-		}
-	};
-}
+import { LINK_TRANSFORM_WITH_PLUGIN } from './constants.js';
 
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
@@ -42,32 +15,24 @@ function buildExtraPreprocessors(options, config) {
 	/** @type {import('svelte/compiler').PreprocessorGroup[]} */
 	const appendPreprocessors = [];
 
-	// @ts-expect-error not typed
-	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.sveltePreprocess);
-	if (pluginsWithPreprocessorsDeprecated.length > 0) {
-		log.warn(
-			`The following plugins use the deprecated 'plugin.sveltePreprocess' field. Please contact their maintainers and ask them to move it to 'plugin.api.sveltePreprocess': ${pluginsWithPreprocessorsDeprecated
+	/** @type {import('vite').Plugin[]} */
+	const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
+
+	if (
+		!options.isBuild &&
+		!options.experimental?.disableApiSveltePreprocessWarnings &&
+		pluginsWithPreprocessors.length > 0
+	) {
+		log.info.once(
+			`The following plugins use the deprecated 'plugin.api.sveltePreprocess' field: ${pluginsWithPreprocessors
 				.map((p) => p.name)
-				.join(', ')}`
+				.join(', ')}
+				Please contact their maintainers and ask them to use a vite plugin transform instead.
+				See ${LINK_TRANSFORM_WITH_PLUGIN} for more information.
+				`.replace(/\t+/g, '\t')
 		);
-		// patch plugin to avoid breaking
-		pluginsWithPreprocessorsDeprecated.forEach((p) => {
-			if (!p.api) {
-				p.api = {};
-			}
-			if (p.api.sveltePreprocess === undefined) {
-				// @ts-expect-error not typed
-				p.api.sveltePreprocess = p.sveltePreprocess;
-			} else {
-				log.error(
-					`ignoring plugin.sveltePreprocess of ${p.name} because it already defined plugin.api.sveltePreprocess.`
-				);
-			}
-		});
 	}
 	/** @type {import('vite').Plugin[]} */
-	const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
-	/** @type {import('vite').Plugin[]} */
 	const ignored = [];
 	/** @type {import('vite').Plugin[]} */
 	const included = [];
@@ -122,52 +87,3 @@ export function addExtraPreprocessors(options, config) {
 		}
 	}
 }
-
-/**
- *
- * @param filename {string}
- * @param dependencies  {string[]}
- * @returns {({dependencies: string[], warnings:import('svelte/compiler').Warning[] })}
- */
-export function checkPreprocessDependencies(filename, dependencies) {
-	/** @type {import('svelte/compiler').Warning[]} */
-	const warnings = [];
-
-	// to find self, we have to compare normalized filenames, but must keep the original values in `dependencies`
-	// because otherwise file watching on windows doesn't work
-	// so we track idx and filter by that in the end
-	/** @type {number[]} */
-	const selfIdx = [];
-	const normalizedFullFilename = normalizePath(filename);
-	const normalizedDeps = dependencies.map(normalizePath);
-	for (let i = 0; i < normalizedDeps.length; i++) {
-		if (normalizedDeps[i] === normalizedFullFilename) {
-			selfIdx.push(i);
-		}
-	}
-	const hasSelfDependency = selfIdx.length > 0;
-	if (hasSelfDependency) {
-		warnings.push({
-			code: 'vite-plugin-svelte-preprocess-depends-on-self',
-			message:
-				'svelte.preprocess returned this file as a dependency of itself. This can be caused by an invalid configuration or importing generated code that depends on .svelte files (eg. tailwind base css)',
-			filename
-		});
-	}
-
-	if (dependencies.length > 10) {
-		warnings.push({
-			code: 'vite-plugin-svelte-preprocess-many-dependencies',
-			message: `svelte.preprocess depends on more than 10 external files which can cause slow builds and poor DX, try to reduce them. Found: ${dependencies.join(
-				', '
-			)}`,
-			filename
-		});
-	}
-	return {
-		dependencies: hasSelfDependency
-			? dependencies.filter((_, i) => !selfIdx.includes(i)) // remove self dependency
-			: dependencies,
-		warnings
-	};
-}

package/src/utils/vite-plugin-svelte-stats.js

@@ -1,6 +1,9 @@
 import { log } from './log.js';
 import { performance } from 'node:perf_hooks';
 import { normalizePath } from 'vite';
+import { findClosestPkgJsonPath } from 'vitefu';
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 /** @type {import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions} */
 const defaultCollectionOptions = {
@@ -63,19 +66,12 @@ function formatPackageStats(pkgStats) {
  * @class
  */
 export class VitePluginSvelteStats {
-	// package directory -> package name
-	/** @type {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} */
-	#cache;
+	/** @type {PackageInfo[]} */
+	#packageInfos = [];
+
 	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection[]} */
 	#collections = [];
 
-	/**
-	 * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
-	 */
-	constructor(cache) {
-		this.#cache = cache;
-	}
-
 	/**
 	 * @param {string} name
 	 * @param {Partial<import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions>} [opts]
@@ -173,7 +169,7 @@ export class VitePluginSvelteStats {
 	async #aggregateStatsResult(collection) {
 		const stats = collection.stats;
 		for (const stat of stats) {
-			stat.pkg = (await this.#cache.getPackageInfo(stat.file)).name;
+			stat.pkg = (await this.#getPackageInfo(stat.file)).name;
 		}
 
 		// group stats
@@ -197,4 +193,56 @@ export class VitePluginSvelteStats {
 		groups.sort((a, b) => b.duration - a.duration);
 		collection.packageStats = groups;
 	}
+	/**
+	 * @param {string} file
+	 * @returns {Promise<PackageInfo>}
+	 */
+	async #getPackageInfo(file) {
+		let info = this.#packageInfos.find((pi) => file.startsWith(pi.path));
+		if (!info) {
+			info = await findPackageInfo(file);
+			this.#packageInfos.push(info);
+		}
+		return info;
+	}
+}
+
+/**
+ * @typedef {{
+ * 	name: string;
+ * 	version: string;
+ * 	svelte?: string;
+ * 	path: string;
+ * }} PackageInfo
+ */
+
+/**
+ * utility to get some info from the closest package.json with a "name" set
+ *
+ * @param {string} file to find info for
+ * @returns {Promise<PackageInfo>}
+ */
+async function findPackageInfo(file) {
+	/** @type {PackageInfo} */
+	const info = {
+		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;
 }