@sveltejs/vite-plugin-svelte 6.0.0-next.0 → 6.0.0-next.2

package/src/utils/watch.js

@@ -6,10 +6,9 @@ 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, cache) {
 	const { server, configFile: svelteConfigFile } = options;
 	if (!server) {
 		return;
@@ -30,16 +29,7 @@ export function setupWatchers(options, cache, requestParser) {
 			}
 		});
 	};
-	/** @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) {
@@ -63,7 +53,7 @@ export function setupWatchers(options, cache, requestParser) {
 	const listenerCollection = {
 		add: [],
 		change: [emitChangeEventOnDependants],
-		unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
+		unlink: [emitChangeEventOnDependants]
 	};
 
 	if (svelteConfigFile !== false) {

package/types/index.d.ts

@@ -206,6 +206,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;iBCORC,gBAAgBA",
+	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;;;;;iBChLtBC,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;
-}