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

package/src/utils/watch.js

@@ -5,41 +5,16 @@ import path from 'node:path';
 
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
- * @param {import('../types/id.d.ts').IdParser} requestParser
  * @returns {void}
  */
-export function setupWatchers(options, cache, requestParser) {
+export function setupWatchers(options) {
 	const { server, configFile: svelteConfigFile } = options;
 	if (!server) {
 		return;
 	}
 	const { watcher, ws } = server;
 	const { root, server: serverConfig } = server.config;
-	/** @type {(filename: string) => void} */
-	const emitChangeEventOnDependants = (filename) => {
-		const dependants = cache.getDependants(filename);
-		dependants.forEach((dependant) => {
-			if (fs.existsSync(dependant)) {
-				log.debug(
-					`emitting virtual change event for "${dependant}" because dependency "${filename}" changed`,
-					undefined,
-					'hmr'
-				);
-				watcher.emit('change', dependant);
-			}
-		});
-	};
-	/** @type {(filename: string) => void} */
-	const removeUnlinkedFromCache = (filename) => {
-		const svelteRequest = requestParser(filename, false);
-		if (svelteRequest) {
-			const removedFromCache = cache.remove(svelteRequest);
-			if (removedFromCache) {
-				log.debug(`cleared VitePluginSvelteCache for deleted file ${filename}`, undefined, 'hmr');
-			}
-		}
-	};
+
 	/** @type {(filename: string) => void} */
 	const triggerViteRestart = (filename) => {
 		if (serverConfig.middlewareMode) {
@@ -62,8 +37,8 @@ export function setupWatchers(options, cache, requestParser) {
 	/** @type {Record<string, Function[]>} */
 	const listenerCollection = {
 		add: [],
-		change: [emitChangeEventOnDependants],
-		unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
+		change: [],
+		unlink: []
 	};
 
 	if (svelteConfigFile !== false) {

package/types/index.d.ts

@@ -173,6 +173,13 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 */
 		disableSvelteResolveWarnings?: boolean;
 
+		/**
+		 * disable api.sveltePreprocess deprecation warnings
+		 *
+		 * @default false
+		 */
+		disableApiSveltePreprocessWarnings?: boolean;
+
 		compileModule?: CompileModuleOptions;
 	}
 
@@ -206,6 +213,11 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 */
 		style?: boolean | InlineConfig | ResolvedConfig;
 	}
+	/**
+	 * returns a list of plugins to handle svelte files
+	 * plugins are named `vite-plugin-svelte:<task>`
+	 *
+	 * */
 	export function svelte(inlineOptions?: Partial<Options>): import("vite").Plugin[];
 	export function vitePreprocess(opts?: VitePreprocessOptions): import("svelte/compiler").PreprocessorGroup;
 	export function loadSvelteConfig(viteConfig?: import("vite").UserConfig, inlineOptions?: Partial<Options>): Promise<Partial<SvelteConfig> | undefined>;

package/types/index.d.ts.map

@@ -26,6 +26,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;iBC/JtBC,MAAMA;iBCXNC,cAAcA;iBCFRC,gBAAgBA",
+	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;;;;;;;;WAuBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;;;;;iBCvLtBC,MAAMA;iBCMNC,cAAcA;iBCFRC,gBAAgBA",
 	"ignoreList": []
 }

package/src/handle-hot-update.js

@@ -1,145 +0,0 @@
-import { log, logCompilerWarnings } from './utils/log.js';
-import { toRollupError } from './utils/error.js';
-
-/**
- * Vite-specific HMR handling
- *
- * @param {Function} compileSvelte
- * @param {import('vite').HmrContext} ctx
- * @param {import('./types/id.d.ts').SvelteRequest} svelteRequest
- * @param {import('./utils/vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
- * @param {import('./types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<import('vite').ModuleNode[] | void>}
- */
-export async function handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options) {
-	if (!cache.has(svelteRequest)) {
-		// file hasn't been requested yet (e.g. async component)
-		log.debug(
-			`handleHotUpdate called before initial transform for ${svelteRequest.id}`,
-			undefined,
-			'hmr'
-		);
-		return;
-	}
-	const { read, server, modules } = ctx;
-
-	const cachedJS = cache.getJS(svelteRequest);
-	const cachedCss = cache.getCSS(svelteRequest);
-
-	const content = await read();
-	/** @type {import('./types/compile.d.ts').CompileData} */
-	let compileData;
-	try {
-		compileData = await compileSvelte(svelteRequest, content, options);
-		cache.update(compileData);
-	} catch (e) {
-		cache.setError(svelteRequest, e);
-		throw toRollupError(e, options);
-	}
-
-	const affectedModules = [...modules];
-
-	const cssIdx = modules.findIndex((m) => m.id === svelteRequest.cssId);
-	if (cssIdx > -1) {
-		const cssUpdated = cssChanged(cachedCss, compileData.compiled.css);
-		if (!cssUpdated) {
-			log.debug(`skipping unchanged css for ${svelteRequest.cssId}`, undefined, 'hmr');
-			affectedModules.splice(cssIdx, 1);
-		}
-	}
-	const jsIdx = modules.findIndex((m) => m.id === svelteRequest.id);
-	if (jsIdx > -1) {
-		const jsUpdated = jsChanged(cachedJS, compileData.compiled.js, svelteRequest.filename);
-		if (!jsUpdated) {
-			log.debug(`skipping unchanged js for ${svelteRequest.id}`, undefined, 'hmr');
-			affectedModules.splice(jsIdx, 1);
-			// transform won't be called, log warnings here
-			logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
-		}
-	}
-
-	// TODO is this enough? see also: https://github.com/vitejs/vite/issues/2274
-	const ssrModulesToInvalidate = affectedModules.filter((m) => !!m.ssrTransformResult);
-	if (ssrModulesToInvalidate.length > 0) {
-		log.debug(
-			`invalidating modules ${ssrModulesToInvalidate.map((m) => m.id).join(', ')}`,
-			undefined,
-			'hmr'
-		);
-		ssrModulesToInvalidate.forEach((moduleNode) => server.moduleGraph.invalidateModule(moduleNode));
-	}
-	if (affectedModules.length > 0) {
-		log.debug(
-			`handleHotUpdate for ${svelteRequest.id} result: ${affectedModules
-				.map((m) => m.id)
-				.join(', ')}`,
-			undefined,
-			'hmr'
-		);
-	}
-	return affectedModules;
-}
-
-/**
- * @param {import('./types/compile.d.ts').Code | null} [prev]
- * @param {import('./types/compile.d.ts').Code | null} [next]
- * @returns {boolean}
- */
-function cssChanged(prev, next) {
-	return !isCodeEqual(prev?.code, next?.code);
-}
-
-/**
- * @param {import('./types/compile.d.ts').Code | null} [prev]
- * @param {import('./types/compile.d.ts').Code | null} [next]
- * @param {string} [filename]
- * @returns {boolean}
- */
-function jsChanged(prev, next, filename) {
-	const prevJs = prev?.code;
-	const nextJs = next?.code;
-	const isStrictEqual = isCodeEqual(prevJs, nextJs);
-	if (isStrictEqual) {
-		return false;
-	}
-	const isLooseEqual = isCodeEqual(normalizeJsCode(prevJs), normalizeJsCode(nextJs));
-	if (!isStrictEqual && isLooseEqual) {
-		log.debug(
-			`ignoring compiler output js change for ${filename} as it is equal to previous output after normalization`,
-			undefined,
-			'hmr'
-		);
-	}
-	return !isLooseEqual;
-}
-
-/**
- * @param {string} [prev]
- * @param {string} [next]
- * @returns {boolean}
- */
-function isCodeEqual(prev, next) {
-	if (!prev && !next) {
-		return true;
-	}
-	if ((!prev && next) || (prev && !next)) {
-		return false;
-	}
-	return prev === next;
-}
-
-/**
- * remove code that only changes metadata and does not require a js update for the component to keep working
- *
- * 1) add_location() calls. These add location metadata to elements, only used by some dev tools
- * 2) ... maybe more (or less) in the future
- *
- * @param {string} [code]
- * @returns {string | undefined}
- */
-function normalizeJsCode(code) {
-	if (!code) {
-		return code;
-	}
-	return code.replace(/\s*\badd_location\s*\([^)]*\)\s*;?/g, '');
-}

package/src/utils/load-raw.js

@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import { toRollupError } from './error.js';
-import { log } from './log.js';
-
-/**
- * utility function to compile ?raw and ?direct requests in load hook
- *
- * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
- * @param {import('../types/compile.d.ts').CompileSvelte} compileSvelte
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<string>}
- */
-export async function loadRaw(svelteRequest, compileSvelte, options) {
-	const { id, filename, query } = svelteRequest;
-
-	// raw svelte subrequest, compile on the fly and return requested subpart
-	let compileData;
-	const source = fs.readFileSync(filename, 'utf-8');
-	try {
-		//avoid compileSvelte doing extra ssr stuff unless requested
-		svelteRequest.ssr = query.compilerOptions?.generate === 'server';
-		compileData = await compileSvelte(svelteRequest, source, {
-			...options,
-			// don't use dynamic vite-plugin-svelte defaults here to ensure stable result between ssr,dev and build
-			compilerOptions: {
-				dev: false,
-				css: 'external',
-				hmr: false,
-				...svelteRequest.query.compilerOptions
-			},
-			emitCss: true
-		});
-	} catch (e) {
-		throw toRollupError(e, options);
-	}
-	let result;
-	if (query.type === 'style') {
-		result = compileData.compiled.css ?? { code: '', map: null };
-	} else if (query.type === 'script') {
-		result = compileData.compiled.js;
-	} else if (query.type === 'preprocessed') {
-		result = compileData.preprocessed;
-	} else if (query.type === 'all' && query.raw) {
-		return allToRawExports(compileData, source);
-	} else {
-		throw new Error(
-			`invalid "type=${query.type}" in ${id}. supported are script, style, preprocessed, all`
-		);
-	}
-	if (query.direct) {
-		const supportedDirectTypes = ['script', 'style'];
-		if (!supportedDirectTypes.includes(query.type)) {
-			throw new Error(
-				`invalid "type=${
-					query.type
-				}" combined with direct in ${id}. supported are: ${supportedDirectTypes.join(', ')}`
-			);
-		}
-		log.debug(`load returns direct result for ${id}`, undefined, 'load');
-		let directOutput = result.code;
-		// @ts-expect-error might not be SourceMap but toUrl check should suffice
-		if (query.sourcemap && result.map?.toUrl) {
-			// @ts-expect-error toUrl might not exist
-			const map = `sourceMappingURL=${result.map.toUrl()}`;
-			if (query.type === 'style') {
-				directOutput += `\n\n/*# ${map} */\n`;
-			} else if (query.type === 'script') {
-				directOutput += `\n\n//# ${map}\n`;
-			}
-		}
-		return directOutput;
-	} else if (query.raw) {
-		log.debug(`load returns raw result for ${id}`, undefined, 'load');
-		return toRawExports(result);
-	} else {
-		throw new Error(`invalid raw mode in ${id}, supported are raw, direct`);
-	}
-}
-
-/**
- * turn compileData and source into a flat list of raw exports
- *
- * @param {import('../types/compile.d.ts').CompileData} compileData
- * @param {string} source
- */
-function allToRawExports(compileData, source) {
-	// flatten CompileData
-	/** @type {Partial<import('../types/compile.d.ts').CompileData & { source: string }>} */
-	const exports = {
-		...compileData,
-		...compileData.compiled,
-		source
-	};
-	delete exports.compiled;
-	delete exports.filename; // absolute path, remove to avoid it in output
-	return toRawExports(exports);
-}
-
-/**
- * turn object into raw exports.
- *
- * every prop is returned as a const export, and if prop 'code' exists it is additionally added as default export
- *
- * eg {'foo':'bar','code':'baz'} results in
- *
- *  ```js
- *  export const code='baz'
- *  export const foo='bar'
- *  export default code
- *  ```
- * @param {object} object
- * @returns {string}
- */
-function toRawExports(object) {
-	let exports =
-		Object.entries(object)
-			.filter(([_key, value]) => typeof value !== 'function') // preprocess output has a toString function that's enumerable
-			.sort(([a], [b]) => (a < b ? -1 : a === b ? 0 : 1))
-			.map(([key, value]) => `export const ${key}=${JSON.stringify(value)}`)
-			.join('\n') + '\n';
-	if (Object.prototype.hasOwnProperty.call(object, 'code')) {
-		exports += 'export default code\n';
-	}
-	return exports;
-}

package/src/utils/optimizer.js

@@ -1,53 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-// List of options that changes the prebundling result
-/** @type {(keyof import('../types/options.d.ts').ResolvedOptions)[]} */
-const PREBUNDLE_SENSITIVE_OPTIONS = [
-	'compilerOptions',
-	'configFile',
-	'experimental',
-	'extensions',
-	'ignorePluginPreprocessors',
-	'preprocess'
-];
-
-/**
- * @param {string} cacheDir
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Promise<boolean>} Whether the Svelte metadata has changed
- */
-export async function saveSvelteMetadata(cacheDir, options) {
-	const svelteMetadata = generateSvelteMetadata(options);
-	const svelteMetadataPath = path.resolve(cacheDir, '_svelte_metadata.json');
-
-	const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
-		// Handle preprocessors
-		return typeof value === 'function' ? value.toString() : value;
-	});
-
-	/** @type {string | undefined} */
-	let existingSvelteMetadata;
-	try {
-		existingSvelteMetadata = await fs.readFile(svelteMetadataPath, 'utf8');
-	} catch {
-		// ignore
-	}
-
-	await fs.mkdir(cacheDir, { recursive: true });
-	await fs.writeFile(svelteMetadataPath, currentSvelteMetadata);
-	return currentSvelteMetadata !== existingSvelteMetadata;
-}
-
-/**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {Partial<import('../types/options.d.ts').ResolvedOptions>}
- */
-function generateSvelteMetadata(options) {
-	/** @type {Record<string, any>} */
-	const metadata = {};
-	for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
-		metadata[key] = options[key];
-	}
-	return metadata;
-}

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

@@ -1,212 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { findClosestPkgJsonPath } from 'vitefu';
-import { normalizePath } from 'vite';
-
-/**
- * @typedef {{
- * 	name: string;
- * 	version: string;
- * 	svelte?: string;
- * 	path: string;
- * }} PackageInfo
- */
-
-/**
- * @class
- */
-export class VitePluginSvelteCache {
-	/** @type {Map<string, import('../types/compile.d.ts').Code | null>} */
-	#css = new Map();
-	/** @type {Map<string, import('../types/compile.d.ts').Code | null>} */
-	#js = new Map();
-	/** @type {Map<string, string[]>} */
-	#dependencies = new Map();
-	/** @type {Map<string, Set<string>>} */
-	#dependants = new Map();
-	/** @type {Map<string, any>} */
-	#errors = new Map();
-	/** @type {PackageInfo[]} */
-	#packageInfos = [];
-
-	/**
-	 * @param {import('../types/compile.d.ts').CompileData} compileData
-	 */
-	update(compileData) {
-		this.#errors.delete(compileData.normalizedFilename);
-		this.#updateCSS(compileData);
-		this.#updateJS(compileData);
-		this.#updateDependencies(compileData);
-	}
-
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @returns {boolean}
-	 */
-	has(svelteRequest) {
-		const id = svelteRequest.normalizedFilename;
-		return this.#errors.has(id) || this.#js.has(id) || this.#css.has(id);
-	}
-
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @param {any} error
-	 */
-	setError(svelteRequest, error) {
-		// keep dependency info, otherwise errors in dependants would not trigger an update after fixing
-		// because they are no longer watched
-		this.remove(svelteRequest, true);
-		this.#errors.set(svelteRequest.normalizedFilename, error);
-	}
-
-	/**
-	 * @param {import('../types/compile.d.ts').CompileData} compileData
-	 */
-	#updateCSS(compileData) {
-		this.#css.set(compileData.normalizedFilename, compileData.compiled.css);
-	}
-
-	/**
-	 * @param {import('../types/compile.d.ts').CompileData} compileData
-	 */
-	#updateJS(compileData) {
-		if (!compileData.ssr) {
-			// do not cache SSR js
-			this.#js.set(compileData.normalizedFilename, compileData.compiled.js);
-		}
-	}
-
-	/**
-	 * @param {import('../types/compile.d.ts').CompileData} compileData
-	 */
-	#updateDependencies(compileData) {
-		const id = compileData.normalizedFilename;
-		const prevDependencies = this.#dependencies.get(id) || [];
-		const dependencies = compileData.dependencies;
-		this.#dependencies.set(id, dependencies);
-		const removed = prevDependencies.filter((d) => !dependencies.includes(d));
-		const added = dependencies.filter((d) => !prevDependencies.includes(d));
-		added.forEach((d) => {
-			if (!this.#dependants.has(d)) {
-				this.#dependants.set(d, new Set());
-			}
-			/** @type {Set<string>} */ (this.#dependants.get(d)).add(compileData.filename);
-		});
-		removed.forEach((d) => {
-			/** @type {Set<string>} */ (this.#dependants.get(d)).delete(compileData.filename);
-		});
-	}
-
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @param {boolean} [keepDependencies]
-	 * @returns {boolean}
-	 */
-	remove(svelteRequest, keepDependencies = false) {
-		const id = svelteRequest.normalizedFilename;
-		let removed = false;
-		if (this.#errors.delete(id)) {
-			removed = true;
-		}
-		if (this.#js.delete(id)) {
-			removed = true;
-		}
-		if (this.#css.delete(id)) {
-			removed = true;
-		}
-		if (!keepDependencies) {
-			const dependencies = this.#dependencies.get(id);
-			if (dependencies) {
-				removed = true;
-				dependencies.forEach((d) => {
-					const dependants = this.#dependants.get(d);
-					if (dependants && dependants.has(svelteRequest.filename)) {
-						dependants.delete(svelteRequest.filename);
-					}
-				});
-				this.#dependencies.delete(id);
-			}
-		}
-
-		return removed;
-	}
-
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @returns {import('../types/compile.d.ts').Code | undefined | null}
-	 */
-	getCSS(svelteRequest) {
-		return this.#css.get(svelteRequest.normalizedFilename);
-	}
-
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @returns {import('../types/compile.d.ts').Code | undefined | null}
-	 */
-	getJS(svelteRequest) {
-		if (!svelteRequest.ssr) {
-			// SSR js isn't cached
-			return this.#js.get(svelteRequest.normalizedFilename);
-		}
-	}
-	/**
-	 * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
-	 * @returns {any}
-	 */
-	getError(svelteRequest) {
-		return this.#errors.get(svelteRequest.normalizedFilename);
-	}
-
-	/**
-	 * @param {string} path
-	 * @returns {string[]}
-	 */
-	getDependants(path) {
-		const dependants = this.#dependants.get(path);
-		return dependants ? [...dependants] : [];
-	}
-
-	/**
-	 * @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;
-	}
-}
-
-/**
- * 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;
-}