@sveltejs/vite-plugin-svelte 4.0.0-next.2 → 4.0.0-next.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/vite-plugin-svelte",
-  "version": "4.0.0-next.2",
+  "version": "4.0.0-next.4",
   "license": "MIT",
   "author": "dominikg",
   "files": [
@@ -37,7 +37,7 @@
   "homepage": "https://github.com/sveltejs/vite-plugin-svelte#readme",
   "dependencies": {
     "@sveltejs/vite-plugin-svelte-inspector": "^3.0.0-next.0||^3.0.0",
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
     "deepmerge": "^4.3.1",
     "kleur": "^4.1.5",
     "magic-string": "^0.30.10",
@@ -49,10 +49,10 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "esbuild": "^0.21.3",
-    "sass": "^1.77.2",
-    "svelte": "^5.0.0-next.141",
-    "vite": "^5.2.11"
+    "esbuild": "^0.23.0",
+    "sass": "^1.77.6",
+    "svelte": "^5.0.0-next.178",
+    "vite": "^5.3.3"
   },
   "scripts": {
     "check:publint": "publint --strict",

package/src/index.js

@@ -39,7 +39,6 @@ export function svelte(inlineOptions) {
 	let viteConfig;
 	/** @type {import('./types/compile.d.ts').CompileSvelte} */
 	let compileSvelte;
-	/* eslint-enable no-unused-vars */
 	/** @type {import('./types/plugin-api.d.ts').PluginAPI} */
 	const api = {};
 	/** @type {import('vite').Plugin[]} */

package/src/preprocess.js

@@ -98,15 +98,16 @@ async function createCssTransform(style, config) {
 	let resolvedConfig;
 	// @ts-expect-error special prop added if running in v-p-s
 	if (style.__resolvedConfig) {
-		// @ts-expect-error
+		// @ts-expect-error not typed
 		resolvedConfig = style.__resolvedConfig;
 	} else if (isResolvedConfig(config)) {
 		resolvedConfig = config;
 	} else {
-		resolvedConfig = await resolveConfig(
-			config,
-			process.env.NODE_ENV === 'production' ? 'build' : 'serve'
-		);
+		// default to "build" if no NODE_ENV is set to avoid running in dev mode for svelte-check etc.
+		const useBuild = !process.env.NODE_ENV || process.env.NODE_ENV === 'production';
+		const command = useBuild ? 'build' : 'serve';
+		const defaultMode = useBuild ? 'production' : 'development';
+		resolvedConfig = await resolveConfig(config, command, defaultMode, defaultMode, false);
 	}
 	return async (code, filename) => {
 		return preprocessCSS(code, filename, resolvedConfig);

package/src/public.d.ts

@@ -1,7 +1,5 @@
 import type { InlineConfig, ResolvedConfig } from 'vite';
-import type { CompileOptions } from 'svelte/compiler';
-import type { Warning } from 'svelte/compiler';
-import type { PreprocessorGroup } from 'svelte/compiler';
+import type { CompileOptions, Warning, PreprocessorGroup } from 'svelte/compiler';
 import type { Options as InspectorOptions } from '@sveltejs/vite-plugin-svelte-inspector';
 
 export type Options = Omit<SvelteConfig, 'vitePlugin'> & PluginOptionsInline;

package/src/types/log.d.ts

@@ -1,14 +1,14 @@
 import type { Warning } from 'svelte/compiler';
 
 export interface LogFn extends SimpleLogFn {
-	(message: string, payload?: any, namespace?: string): void;
+	(message: string, payload?: unknown, namespace?: string): void;
 
 	enabled: boolean;
 	once: SimpleLogFn;
 }
 
 export interface SimpleLogFn {
-	(message: string, payload?: any, namespace?: string): void;
+	(message: string, payload?: unknown, namespace?: string): void;
 }
 
 export type SvelteWarningsMessage = {

package/src/utils/compile.js

@@ -132,7 +132,7 @@ export function createCompileSvelte() {
 		/** @type {import('svelte/compiler').CompileResult} */
 		let compiled;
 		try {
-			compiled = svelte.compile(finalCode, { ...finalCompileOptions, filename: filename });
+			compiled = svelte.compile(finalCode, { ...finalCompileOptions, filename });
 			// patch output with partial accept until svelte does it
 			// TODO remove later
 			if (
@@ -182,7 +182,6 @@ export function createCompileSvelte() {
 			filename,
 			normalizedFilename,
 			lang,
-			// @ts-ignore
 			compiled,
 			ssr,
 			dependencies,

package/src/utils/constants.js

@@ -1,20 +1,24 @@
+import { createRequire } from 'node:module';
+
 export const VITE_RESOLVE_MAIN_FIELDS = ['browser', 'module', 'jsnext:main', 'jsnext'];
 
 export const SVELTE_RESOLVE_MAIN_FIELDS = ['svelte'];
 
-export const SVELTE_IMPORTS = [
-	'svelte/animate',
-	'svelte/easing',
-	'svelte/internal',
-	'svelte/internal/disclose-version',
-	'svelte/motion',
-	'svelte/store',
-	'svelte/transition',
-	'svelte/server',
-	'svelte/internal/server',
-	'svelte/legacy',
-	'svelte'
-];
+export const SVELTE_IMPORTS = Object.entries(
+	createRequire(import.meta.url)('svelte/package.json').exports
+)
+	.map(([name, config]) => {
+		// ignore type only
+		if (typeof config === 'object' && Object.keys(config).length === 1 && config.types) {
+			return '';
+		}
+		// ignore names
+		if (name === './package.json' || name === './compiler') {
+			return '';
+		}
+		return name.replace(/^\./, 'svelte');
+	})
+	.filter((s) => s.length > 0);
 
 export const SVELTE_EXPORT_CONDITIONS = ['svelte'];
 

package/src/utils/id.js

@@ -1,5 +1,6 @@
 import { createFilter, normalizePath } from 'vite';
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { log } from './log.js';
 import { DEFAULT_SVELTE_MODULE_EXT, DEFAULT_SVELTE_MODULE_INFIX } from './constants.js';
 
@@ -90,7 +91,7 @@ function parseRequestQuery(rawQuery) {
 	const query = Object.fromEntries(new URLSearchParams(rawQuery));
 	for (const key in query) {
 		if (query[key] === '') {
-			// @ts-ignore
+			// @ts-expect-error not boolean
 			query[key] = true;
 		}
 	}
@@ -179,10 +180,15 @@ function buildFilter(include, exclude, extensions) {
  */
 function buildModuleFilter(include, exclude, infixes, extensions) {
 	const rollupFilter = createFilter(include, exclude);
-	return (filename) =>
-		rollupFilter(filename) &&
-		infixes.some((infix) => filename.includes(infix)) &&
-		extensions.some((ext) => filename.endsWith(ext));
+	return (filename) => {
+		const basename = path.basename(filename);
+
+		return (
+			rollupFilter(filename) &&
+			infixes.some((infix) => basename.includes(infix)) &&
+			extensions.some((ext) => basename.endsWith(ext))
+		);
+	};
 }
 
 /**

package/src/utils/load-raw.js

@@ -60,7 +60,7 @@ export async function loadRaw(svelteRequest, compileSvelte, options) {
 		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
+			// @ts-expect-error toUrl might not exist
 			const map = `sourceMappingURL=${result.map.toUrl()}`;
 			if (query.type === 'style') {
 				directOutput += `\n\n/*# ${map} */\n`;
@@ -114,8 +114,7 @@ function allToRawExports(compileData, source) {
 function toRawExports(object) {
 	let exports =
 		Object.entries(object)
-			//eslint-disable-next-line no-unused-vars
-			.filter(([key, value]) => typeof value !== 'function') // preprocess output has a toString function that's enumerable
+			.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';

package/src/utils/log.js

@@ -72,7 +72,11 @@ function _log(logger, message, payload, namespace) {
 			}
 			log = logger.log.extend(namespace);
 		}
-		payload !== undefined ? log(message, payload) : log(message);
+		if (payload !== undefined) {
+			log(message, payload);
+		} else {
+			log(message);
+		}
 	} else {
 		logger.log(
 			logger.color(
@@ -222,14 +226,14 @@ function buildExtraWarnings(warnings, isBuild) {
  * @param {import('svelte/compiler').Warning} w
  */
 function warnDev(w) {
-	log.info.enabled && log.info(buildExtendedLogMessage(w));
+	if (log.info.enabled) log.info(buildExtendedLogMessage(w));
 }
 
 /**
  * @param {import('svelte/compiler').Warning & {frame?: string}} w
  */
 function warnBuild(w) {
-	log.warn.enabled && log.warn(buildExtendedLogMessage(w), w.frame);
+	if (log.warn.enabled) log.warn(buildExtendedLogMessage(w), w.frame);
 }
 
 /**

package/src/utils/options.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import { normalizePath } from 'vite';
 import { isDebugNamespaceEnabled, log } from './log.js';
 import { loadSvelteConfig } from './load-svelte-config.js';
@@ -30,7 +29,6 @@ import {
 
 import { isCommonDepWithoutSvelteField } from './dependencies.js';
 import { VitePluginSvelteStats } from './vite-plugin-svelte-stats.js';
-import { VitePluginSvelteCache } from './vite-plugin-svelte-cache.js';
 
 const allowedPluginOptions = new Set([
 	'include',
@@ -109,7 +107,7 @@ function convertPluginOptions(config) {
 			)}`
 		);
 		unknownPluginOptions.forEach((unkownOption) => {
-			// @ts-ignore
+			// @ts-expect-error not typed
 			delete pluginOptions[unkownOption];
 		});
 	}
@@ -191,7 +189,7 @@ function mergeConfigs(...configs) {
  *
  * @param {import('../types/options.d.ts').PreResolvedOptions} preResolveOptions
  * @param {import('vite').ResolvedConfig} viteConfig
- * @param {VitePluginSvelteCache} cache
+ * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
  * @returns {import('../types/options.d.ts').ResolvedOptions}
  */
 export function resolveOptions(preResolveOptions, viteConfig, cache) {
@@ -352,7 +350,6 @@ export async function buildExtraViteConfig(options, config) {
 		}
 		// this option is still awaiting a PR in vite to be supported
 		// see https://github.com/sveltejs/vite-plugin-svelte/issues/60
-		// @ts-ignore
 		// knownJsSrcExtensions: options.extensions
 	};
 
@@ -394,7 +391,6 @@ export async function buildExtraViteConfig(options, config) {
 		extraViteConfig.optimizeDeps = {
 			...extraViteConfig.optimizeDeps,
 			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			// @ts-ignore
 			extensions: options.extensions ?? ['.svelte'],
 			// Add esbuild plugin to prebundle Svelte files.
 			// Currently a placeholder as more information is needed after Vite config is resolved,
@@ -557,7 +553,9 @@ function buildExtraConfigForSvelte(config) {
 	/** @type {string[]} */
 	const exclude = [];
 	if (!isDepExcluded('svelte', config.optimizeDeps?.exclude ?? [])) {
-		const svelteImportsToInclude = SVELTE_IMPORTS;
+		const svelteImportsToInclude = SVELTE_IMPORTS.filter(
+			(si) => !(si.endsWith('/server') || si.includes('/server/'))
+		);
 		log.debug(
 			`adding bare svelte packages to optimizeDeps.include: ${svelteImportsToInclude.join(', ')} `,
 			undefined,

package/src/utils/preprocess.js

@@ -42,7 +42,7 @@ function buildExtraPreprocessors(options, config) {
 	/** @type {import('svelte/compiler').PreprocessorGroup[]} */
 	const appendPreprocessors = [];
 
-	// @ts-ignore
+	// @ts-expect-error not typed
 	const pluginsWithPreprocessorsDeprecated = config.plugins.filter((p) => p?.sveltePreprocess);
 	if (pluginsWithPreprocessorsDeprecated.length > 0) {
 		log.warn(
@@ -56,7 +56,7 @@ function buildExtraPreprocessors(options, config) {
 				p.api = {};
 			}
 			if (p.api.sveltePreprocess === undefined) {
-				// @ts-ignore
+				// @ts-expect-error not typed
 				p.api.sveltePreprocess = p.sveltePreprocess;
 			} else {
 				log.error(

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

@@ -89,6 +89,7 @@ export class VitePluginSvelteStats {
 		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').Stat[]} */
 		const stats = [];
 		const collectionStart = performance.now();
+
 		const _this = this;
 		let hasLoggedProgress = false;
 		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} */

package/src/utils/watch.js

@@ -22,7 +22,7 @@ export function setupWatchers(options, cache, requestParser) {
 		dependants.forEach((dependant) => {
 			if (fs.existsSync(dependant)) {
 				log.debug(
-					`emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`,
+					`emitting virtual change event for "${dependant}" because dependency "${filename}" changed`,
 					undefined,
 					'hmr'
 				);

package/types/index.d.ts

@@ -202,9 +202,11 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 */
 		style?: boolean | InlineConfig | ResolvedConfig;
 	}
-	export function svelte(inlineOptions?: Partial<Options> | undefined): import('vite').Plugin[];
-	export function vitePreprocess(opts?: VitePreprocessOptions | undefined): import('svelte/compiler').PreprocessorGroup;
+	export function svelte(inlineOptions?: Partial<Options> | undefined): import("vite").Plugin[];
+	export function vitePreprocess(opts?: VitePreprocessOptions | undefined): import("svelte/compiler").PreprocessorGroup;
 	export function loadSvelteConfig(viteConfig?: import("vite").UserConfig | undefined, inlineOptions?: Partial<Options> | undefined): Promise<Partial<SvelteConfig> | undefined>;
+
+	export {};
 }
 
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -21,5 +21,5 @@
 		null,
 		null
 	],
-	"mappings": ";;;;aAMYA,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6GFC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8EZC,qBAAqBA;;;;;;;;;;;;;iBCzKtBC,MAAMA;iBCTNC,cAAcA;iBCgBRC,gBAAgBA"
+	"mappings": ";;;;aAIYA,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6GFC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8EZC,qBAAqBA;;;;;;;;;;;;;iBCvKtBC,MAAMA;iBCTNC,cAAcA;iBCgBRC,gBAAgBA"
 }