@sveltejs/vite-plugin-svelte 7.0.0 → 7.1.0

package/src/utils/options.js

@@ -1,3 +1,8 @@
+/** @import { Options, SvelteConfig } from '../public.js' */
+/** @import { PreResolvedOptions, ResolvedOptions } from '../types/options.js' */
+/** @import { ConfigEnv, EnvironmentOptions, Plugin, ResolvedConfig, UserConfig } from 'vite' */
+/** @import { CrawlFrameworkPkgsResult } from 'vitefu' */
+
 import process from 'node:process';
 import * as vite from 'vite';
 const {
@@ -16,7 +21,8 @@ import {
 	FAQ_LINK_MISSING_EXPORTS_CONDITION,
 	LINK_TRANSFORM_WITH_PLUGIN,
 	SVELTE_EXPORT_CONDITIONS,
-	SVELTE_IMPORTS,
+	SVELTE_CLIENT_IMPORTS,
+	SVELTE_DEDUPED_IMPORTS,
 	SVELTE_RUNTIME_DEPENDENCIES
 } from './constants.js';
 
@@ -48,7 +54,7 @@ const knownRootOptions = new Set(['extensions', 'compilerOptions', 'preprocess',
 const allowedInlineOptions = new Set(['configFile', ...allowedPluginOptions, ...knownRootOptions]);
 
 /**
- * @param {Partial<import('../public.d.ts').Options>} [inlineOptions]
+ * @param {Partial<Options>} [inlineOptions]
  */
 export function validateInlineOptions(inlineOptions) {
 	const invalidKeys = Object.keys(inlineOptions || {}).filter(
@@ -60,8 +66,8 @@ export function validateInlineOptions(inlineOptions) {
 }
 
 /**
- * @param {Partial<import('../public.d.ts').SvelteConfig>} [config]
- * @returns {Partial<import('../public.d.ts').Options> | undefined}
+ * @param {Partial<SvelteConfig>} [config]
+ * @returns {Partial<Options> | undefined}
  */
 function convertPluginOptions(config) {
 	if (!config) {
@@ -111,7 +117,7 @@ function convertPluginOptions(config) {
 			delete pluginOptions[unkownOption];
 		});
 	}
-	/** @type {import('../public.d.ts').Options} */
+	/** @type {Options} */
 	const result = {
 		...config,
 		...pluginOptions
@@ -124,22 +130,22 @@ function convertPluginOptions(config) {
 
 /**
  * used in config phase, merges the default options, svelte config, and inline options
- * @param {Partial<import('../public.d.ts').Options> | undefined} inlineOptions
- * @param {import('vite').UserConfig} viteUserConfig
- * @param {import('vite').ConfigEnv} viteEnv
- * @returns {Promise<import('../types/options.d.ts').PreResolvedOptions>}
+ * @param {Partial<Options> | undefined} inlineOptions
+ * @param {UserConfig} viteUserConfig
+ * @param {ConfigEnv} viteEnv
+ * @returns {Promise<PreResolvedOptions>}
  */
 export async function preResolveOptions(inlineOptions, viteUserConfig, viteEnv) {
 	if (!inlineOptions) {
 		inlineOptions = {};
 	}
-	/** @type {import('vite').UserConfig} */
+	/** @type {UserConfig} */
 	const viteConfigWithResolvedRoot = {
 		...viteUserConfig,
 		root: resolveViteRoot(viteUserConfig)
 	};
 	const isBuild = viteEnv.command === 'build';
-	/** @type {Partial<import('../types/options.d.ts').PreResolvedOptions>} */
+	/** @type {Partial<PreResolvedOptions>} */
 	const defaultOptions = {
 		extensions: DEFAULT_SVELTE_EXT,
 		emitCss: true,
@@ -148,7 +154,7 @@ export async function preResolveOptions(inlineOptions, viteUserConfig, viteEnv)
 	const svelteConfig = convertPluginOptions(
 		await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions)
 	);
-	/** @type {Partial<import('../types/options.d.ts').PreResolvedOptions>} */
+	/** @type {Partial<PreResolvedOptions>} */
 	const extraOptions = {
 		root: viteConfigWithResolvedRoot.root,
 		isBuild,
@@ -156,7 +162,7 @@ export async function preResolveOptions(inlineOptions, viteUserConfig, viteEnv)
 		isDebug: process.env.DEBUG != null
 	};
 
-	const merged = /** @type {import('../types/options.d.ts').PreResolvedOptions} */ (
+	const merged = /** @type {PreResolvedOptions} */ (
 		mergeConfigs(defaultOptions, svelteConfig, inlineOptions, extraOptions)
 	);
 	// configFile of svelteConfig contains the absolute path it was loaded from,
@@ -187,13 +193,13 @@ function mergeConfigs(...configs) {
 /**
  * used in configResolved phase, merges a contextual default config, pre-resolved options, and some preprocessors. also validates the final config.
  *
- * @param {import('../types/options.d.ts').PreResolvedOptions} preResolveOptions
- * @param {import('vite').ResolvedConfig} viteConfig
- * @returns {import('../types/options.d.ts').ResolvedOptions}
+ * @param {PreResolvedOptions} preResolveOptions
+ * @param {ResolvedConfig} viteConfig
+ * @returns {ResolvedOptions}
  */
 export function resolveOptions(preResolveOptions, viteConfig) {
 	const css = preResolveOptions.emitCss ? 'external' : 'injected';
-	/** @type {Partial<import('../public.d.ts').Options>} */
+	/** @type {Partial<Options>} */
 	const defaultOptions = {
 		compilerOptions: {
 			css,
@@ -206,12 +212,12 @@ export function resolveOptions(preResolveOptions, viteConfig) {
 		}
 	};
 
-	/** @type {Partial<import('../types/options.d.ts').ResolvedOptions>} */
+	/** @type {Partial<ResolvedOptions>} */
 	const extraOptions = {
 		root: viteConfig.root,
 		isProduction: viteConfig.isProduction
 	};
-	const merged = /** @type {import('../types/options.d.ts').ResolvedOptions}*/ (
+	const merged = /** @type {ResolvedOptions}*/ (
 		mergeConfigs(defaultOptions, preResolveOptions, extraOptions)
 	);
 
@@ -225,8 +231,8 @@ export function resolveOptions(preResolveOptions, viteConfig) {
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @param {import('vite').ResolvedConfig} viteConfig
+ * @param {ResolvedOptions} options
+ * @param {ResolvedConfig} viteConfig
  */
 function enforceOptionsForHmr(options, viteConfig) {
 	if (options.compilerOptions.hmr && viteConfig.server?.hmr === false) {
@@ -265,7 +271,7 @@ function enforceOptionsForHmr(options, viteConfig) {
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  */
 function enforceOptionsForProduction(options) {
 	if (options.isProduction) {
@@ -285,7 +291,7 @@ function enforceOptionsForProduction(options) {
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  */
 function removeIgnoredOptions(options) {
 	const ignoredCompilerOptions = ['generate', 'format', 'filename'];
@@ -305,7 +311,7 @@ function removeIgnoredOptions(options) {
 }
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  */
 function handleDeprecatedOptions(options) {
 	const experimental = /** @type {Record<string, any>} */ (options.experimental);
@@ -324,10 +330,10 @@ function handleDeprecatedOptions(options) {
 }
 
 /**
- * @param {import('vite').ResolvedConfig} config
+ * @param {ResolvedConfig} config
  */
 function logRemovedPluginAPI(config) {
-	/** @type {import('vite').Plugin[]} */
+	/** @type {Plugin[]} */
 	const pluginsWithPreprocessors = config.plugins.filter((p) => p?.api?.sveltePreprocess);
 
 	if (pluginsWithPreprocessors.length > 0) {
@@ -348,7 +354,7 @@ function logRemovedPluginAPI(config) {
  * @see https://github.com/sveltejs/vite-plugin-svelte/issues/113
  * @see https://github.com/vitejs/vite/blob/43c957de8a99bb326afd732c962f42127b0a4d1e/packages/vite/src/node/config.ts#L293
  *
- * @param {import('vite').UserConfig} viteConfig
+ * @param {UserConfig} viteConfig
  * @returns {string | undefined}
  */
 function resolveViteRoot(viteConfig) {
@@ -356,15 +362,15 @@ function resolveViteRoot(viteConfig) {
 }
 
 /**
- * @param {import('../types/options.d.ts').PreResolvedOptions} options
- * @param {import('vite').UserConfig} config
- * @returns {Promise<Partial<import('vite').UserConfig>>}
+ * @param {PreResolvedOptions} options
+ * @param {UserConfig} config
+ * @returns {Promise<Partial<UserConfig>>}
  */
 export async function buildExtraViteConfig(options, config) {
-	/** @type {Partial<import('vite').UserConfig>} */
+	/** @type {Partial<UserConfig>} */
 	const extraViteConfig = {
 		resolve: {
-			dedupe: [...SVELTE_IMPORTS]
+			dedupe: [...SVELTE_DEDUPED_IMPORTS]
 		}
 		// this option is still awaiting a PR in vite to be supported
 		// see https://github.com/sveltejs/vite-plugin-svelte/issues/60
@@ -414,9 +420,9 @@ export async function buildExtraViteConfig(options, config) {
 }
 
 /**
- * @param {Partial<import('vite').UserConfig>} extraViteConfig
- * @param {import('vite').UserConfig} config
- * @param {import('../types/options.d.ts').PreResolvedOptions} options
+ * @param {Partial<UserConfig>} extraViteConfig
+ * @param {UserConfig} config
+ * @param {PreResolvedOptions} options
  */
 function validateViteConfig(extraViteConfig, config, options) {
 	const { prebundleSvelteLibraries, isBuild } = options;
@@ -465,9 +471,9 @@ function validateViteConfig(extraViteConfig, config, options) {
 }
 
 /**
- * @param {import('../types/options.d.ts').PreResolvedOptions} options
- * @param {import('vite').UserConfig} config
- * @returns {Promise<import('vitefu').CrawlFrameworkPkgsResult>}
+ * @param {PreResolvedOptions} options
+ * @param {UserConfig} config
+ * @returns {Promise<CrawlFrameworkPkgsResult>}
  */
 async function buildExtraConfigForDependencies(options, config) {
 	// extra handling for svelte dependencies in the project
@@ -557,8 +563,8 @@ async function buildExtraConfigForDependencies(options, config) {
 }
 
 /**
- * @param {import('vite').UserConfig} config
- * @returns {import('vite').UserConfig & { optimizeDeps: { include: string[], exclude:string[] }, ssr: { noExternal:(string|RegExp)[], external: string[] } } }
+ * @param {UserConfig} config
+ * @returns {UserConfig & { optimizeDeps: { include: string[], exclude:string[] }, ssr: { noExternal:(string|RegExp)[], external: string[] } } }
  */
 function buildExtraConfigForSvelte(config) {
 	// include svelte imports for optimization unless explicitly excluded
@@ -567,9 +573,7 @@ function buildExtraConfigForSvelte(config) {
 	/** @type {string[]} */
 	const exclude = [];
 	if (!isDepExcluded('svelte', config.optimizeDeps?.exclude ?? [])) {
-		const svelteImportsToInclude = SVELTE_IMPORTS.filter(
-			(si) => !(si.endsWith('/server') || si.includes('/server/'))
-		);
+		const svelteImportsToInclude = [...SVELTE_CLIENT_IMPORTS];
 		svelteImportsToInclude.push(...SVELTE_RUNTIME_DEPENDENCIES.map((dep) => `svelte > ${dep}`));
 		log.debug(
 			`adding bare svelte packages and runtime dependencies to optimizeDeps.include: ${svelteImportsToInclude.join(', ')} `,
@@ -604,7 +608,7 @@ function buildExtraConfigForSvelte(config) {
 /**
  * Mutates `config` to ensure `resolve.mainFields` is set. If unset, it emulates Vite's default fallback.
  * @param {string} name
- * @param {import('vite').EnvironmentOptions} config
+ * @param {EnvironmentOptions} config
  * @param {{ isSsrTargetWebworker?: boolean }} opts
  */
 export function ensureConfigEnvironmentMainFields(name, config, opts) {
@@ -622,7 +626,7 @@ export function ensureConfigEnvironmentMainFields(name, config, opts) {
 /**
  * Mutates `config` to ensure `resolve.conditions` is set. If unset, it emulates Vite's default fallback.
  * @param {string} name
- * @param {import('vite').EnvironmentOptions} config
+ * @param {EnvironmentOptions} config
  * @param {{ isSsrTargetWebworker?: boolean }} opts
  */
 export function ensureConfigEnvironmentConditions(name, config, opts) {

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

@@ -1,3 +1,5 @@
+/** @import { CollectionOptions, PackageStats, Stat, StatCollection } from '../types/vite-plugin-svelte-stats.js' */
+
 import { log } from './log.js';
 import { performance } from 'node:perf_hooks';
 import { normalizePath } from 'vite';
@@ -5,7 +7,7 @@ import { findClosestPkgJsonPath } from 'vitefu';
 import { readFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 
-/** @type {import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions} */
+/** @type {CollectionOptions} */
 const defaultCollectionOptions = {
 	// log after 500ms and more than one file processed
 	logInProgress: (c, now) => now - c.collectionStart > 500 && c.stats.length > 1,
@@ -23,7 +25,7 @@ function humanDuration(n) {
 }
 
 /**
- * @param {import('../types/vite-plugin-svelte-stats.d.ts').PackageStats[]} pkgStats
+ * @param {PackageStats[]} pkgStats
  * @returns {string}
  */
 function formatPackageStats(pkgStats) {
@@ -69,26 +71,26 @@ export class VitePluginSvelteStats {
 	/** @type {PackageInfo[]} */
 	#packageInfos = [];
 
-	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection[]} */
+	/** @type {StatCollection[]} */
 	#collections = [];
 
 	/**
 	 * @param {string} name
-	 * @param {Partial<import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions>} [opts]
-	 * @returns {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection}
+	 * @param {Partial<CollectionOptions>} [opts]
+	 * @returns {StatCollection}
 	 */
 	startCollection(name, opts) {
 		const options = {
 			...defaultCollectionOptions,
 			...opts
 		};
-		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').Stat[]} */
+		/** @type {Stat[]} */
 		const stats = [];
 		const collectionStart = performance.now();
 
 		const _this = this;
 		let hasLoggedProgress = false;
-		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} */
+		/** @type {StatCollection} */
 		const collection = {
 			name,
 			options,
@@ -101,7 +103,7 @@ export class VitePluginSvelteStats {
 				}
 				file = normalizePath(file);
 				const start = performance.now();
-				/** @type {import('../types/vite-plugin-svelte-stats.d.ts').Stat} */
+				/** @type {Stat} */
 				const stat = { file, start, end: start };
 				return () => {
 					const now = performance.now();
@@ -126,7 +128,7 @@ export class VitePluginSvelteStats {
 	}
 
 	/**
-	 * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} collection
+	 * @param {StatCollection} collection
 	 */
 	async #finish(collection) {
 		try {
@@ -138,9 +140,7 @@ export class VitePluginSvelteStats {
 				await this.#aggregateStatsResult(collection);
 				log.debug(
 					`${collection.name} done.\n${formatPackageStats(
-						/** @type {import('../types/vite-plugin-svelte-stats.d.ts').PackageStats[]}*/ (
-							collection.packageStats
-						)
+						/** @type {PackageStats[]}*/ (collection.packageStats)
 					)}`,
 					undefined,
 					'stats'
@@ -164,7 +164,7 @@ export class VitePluginSvelteStats {
 	}
 
 	/**
-	 * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} collection
+	 * @param {StatCollection} collection
 	 */
 	async #aggregateStatsResult(collection) {
 		const stats = collection.stats;
@@ -173,7 +173,7 @@ export class VitePluginSvelteStats {
 		}
 
 		// group stats
-		/** @type {Record<string, import('../types/vite-plugin-svelte-stats.d.ts').PackageStats>} */
+		/** @type {Record<string, PackageStats>} */
 		const grouped = {};
 		stats.forEach((stat) => {
 			const pkg = /** @type {string} */ (stat.pkg);

package/src/utils/watch.js

@@ -1,10 +1,13 @@
+/** @import { ResolvedOptions } from '../types/options.js' */
+/** @import { FSWatcher } from 'vite' */
+
 import fs from 'node:fs';
 import { log } from './log.js';
 import { knownSvelteConfigNames } from './load-svelte-config.js';
 import path from 'node:path';
 
 /**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {ResolvedOptions} options
  * @returns {void}
  */
 export function setupWatchers(options) {
@@ -75,7 +78,7 @@ export function setupWatchers(options) {
 
 /**
  * taken from vite utils
- * @param {import('vite').FSWatcher} watcher
+ * @param {FSWatcher} watcher
  * @param {string | null} file
  * @param {string} root
  * @returns {void}

package/types/index.d.ts

@@ -1,5 +1,5 @@
 declare module '@sveltejs/vite-plugin-svelte' {
-	import type { InlineConfig, ResolvedConfig } from 'vite';
+	import type { InlineConfig, ResolvedConfig, Plugin, UserConfig } from 'vite';
 	import type { CompileOptions, Warning, PreprocessorGroup } from 'svelte/compiler';
 	export type Options = Omit<SvelteConfig, 'vitePlugin'> & PluginOptionsInline;
 
@@ -270,9 +270,9 @@ declare module '@sveltejs/vite-plugin-svelte' {
 	 * 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>;
+	export function svelte(inlineOptions?: Partial<Options>): Plugin[];
+	export function vitePreprocess(opts?: VitePreprocessOptions): PreprocessorGroup;
+	export function loadSvelteConfig(viteConfig?: UserConfig, inlineOptions?: Partial<Options>): Promise<Partial<SvelteConfig> | undefined>;
 
 	export {};
 }

package/types/index.d.ts.map

@@ -27,6 +27,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;aAGYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgFbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;kBAcrBC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC7KjBC,MAAMA;iBCGNC,cAAcA;iBCCRC,gBAAgBA",
+	"mappings": ";;;aAGYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgFbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;;kBAcrBC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCzKjBC,MAAMA;iBCGNC,cAAcA;iBCARC,gBAAgBA",
 	"ignoreList": []
 }