@sveltejs/vite-plugin-svelte 2.2.0 → 2.4.0

package/package.json

@@ -1,22 +1,19 @@
 {
   "name": "@sveltejs/vite-plugin-svelte",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "license": "MIT",
   "author": "dominikg",
   "files": [
-    "dist",
-    "src",
-    "*.d.ts"
+    "src"
   ],
   "type": "module",
-  "types": "dist/index.d.ts",
+  "types": "src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
     },
-    "./package.json": "./package.json",
-    "./src/ui/*": "./src/ui/*"
+    "./package.json": "./package.json"
   },
   "engines": {
     "node": "^14.18.0 || >= 16"
@@ -42,7 +39,8 @@
     "kleur": "^4.1.5",
     "magic-string": "^0.30.0",
     "svelte-hmr": "^0.15.1",
-    "vitefu": "^0.2.4"
+    "vitefu": "^0.2.4",
+    "@sveltejs/vite-plugin-svelte-inspector": "^1.0.1"
   },
   "peerDependencies": {
     "svelte": "^3.54.0",
@@ -51,14 +49,11 @@
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "esbuild": "^0.17.18",
-    "rollup": "^3.21.2",
-    "svelte": "^3.58.0",
-    "tsup": "^6.7.0",
-    "vite": "^4.3.3"
+    "svelte": "^3.59.1",
+    "vite": "^4.3.5"
   },
   "scripts": {
-    "dev": "pnpm build:ci --sourcemap --watch src",
-    "build:ci": "rimraf dist && tsup-node src/index.ts --format esm",
-    "build": "pnpm build:ci --dts --sourcemap"
+    "check:publint": "publint --strict",
+    "check:types": "tsc --noEmit"
   }
 }

package/src/{handle-hot-update.ts → handle-hot-update.js}

@@ -1,21 +1,17 @@
-import { ModuleNode, HmrContext } from 'vite';
-import { Code, CompileData } from './utils/compile';
-import { log, logCompilerWarnings } from './utils/log';
-import { SvelteRequest } from './utils/id';
-import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache';
-import { ResolvedOptions } from './utils/options';
-import { toRollupError } from './utils/error';
+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').VitePluginSvelteCache} cache
+ * @param {import('./types/options.d.ts').ResolvedOptions} options
+ * @returns {Promise<import('vite').ModuleNode[] | void>}
  */
-export async function handleHotUpdate(
-	compileSvelte: Function,
-	ctx: HmrContext,
-	svelteRequest: SvelteRequest,
-	cache: VitePluginSvelteCache,
-	options: ResolvedOptions
-): Promise<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}`);
@@ -27,7 +23,8 @@ export async function handleHotUpdate(
 	const cachedCss = cache.getCSS(svelteRequest);
 
 	const content = await read();
-	let compileData: CompileData;
+	/** @type {import('./types/compile.d.ts').CompileData} */
+	let compileData;
 	try {
 		compileData = await compileSvelte(svelteRequest, content, options);
 		cache.update(compileData);
@@ -73,11 +70,22 @@ export async function handleHotUpdate(
 	return affectedModules;
 }
 
-function cssChanged(prev?: Code, next?: Code): boolean {
+/**
+ * @param {import('./types/compile.d.ts').Code} [prev]
+ * @param {import('./types/compile.d.ts').Code} [next]
+ * @returns {boolean}
+ */
+function cssChanged(prev, next) {
 	return !isCodeEqual(prev?.code, next?.code);
 }
 
-function jsChanged(prev?: Code, next?: Code, filename?: string): boolean {
+/**
+ * @param {import('./types/compile.d.ts').Code} [prev]
+ * @param {import('./types/compile.d.ts').Code} [next]
+ * @param {string} [filename]
+ * @returns {boolean}
+ */
+function jsChanged(prev, next, filename) {
 	const prevJs = prev?.code;
 	const nextJs = next?.code;
 	const isStrictEqual = isCodeEqual(prevJs, nextJs);
@@ -93,7 +101,12 @@ function jsChanged(prev?: Code, next?: Code, filename?: string): boolean {
 	return !isLooseEqual;
 }
 
-function isCodeEqual(prev?: string, next?: string): boolean {
+/**
+ * @param {string} [prev]
+ * @param {string} [next]
+ * @returns {boolean}
+ */
+function isCodeEqual(prev, next) {
 	if (!prev && !next) {
 		return true;
 	}
@@ -108,9 +121,11 @@ function isCodeEqual(prev?: string, next?: string): boolean {
  *
  * 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 code
+ *
+ * @param {string} [code]
+ * @returns {string | undefined}
  */
-function normalizeJsCode(code?: string): string | undefined {
+function normalizeJsCode(code) {
 	if (!code) {
 		return code;
 	}

package/src/index.d.ts

@@ -0,0 +1,215 @@
+import type { InlineConfig, ResolvedConfig, UserConfig, Plugin } from 'vite';
+import type { CompileOptions, Warning } from 'svelte/types/compiler/interfaces';
+import type { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
+import type { Options as InspectorOptions } from '@sveltejs/vite-plugin-svelte-inspector';
+
+type Options = Omit<SvelteOptions, 'vitePlugin'> & PluginOptionsInline;
+
+interface PluginOptionsInline extends PluginOptions {
+	/**
+	 * Path to a svelte config file, either absolute or relative to Vite root
+	 *
+	 * set to `false` to ignore the svelte config file
+	 *
+	 * @see https://vitejs.dev/config/#root
+	 */
+	configFile?: string | false;
+}
+
+interface PluginOptions {
+	/**
+	 * A `picomatch` pattern, or array of patterns, which specifies the files the plugin should
+	 * operate on. By default, all svelte files are included.
+	 *
+	 * @see https://github.com/micromatch/picomatch
+	 */
+	include?: Arrayable<string>;
+	/**
+	 * A `picomatch` pattern, or array of patterns, which specifies the files to be ignored by the
+	 * plugin. By default, no files are ignored.
+	 *
+	 * @see https://github.com/micromatch/picomatch
+	 */
+	exclude?: Arrayable<string>;
+	/**
+	 * Emit Svelte styles as virtual CSS files for Vite and other plugins to process
+	 *
+	 * @default true
+	 */
+	emitCss?: boolean;
+	/**
+	 * Enable or disable Hot Module Replacement.
+	 *
+	 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	 *
+	 * DO NOT CUSTOMIZE SVELTE-HMR OPTIONS UNLESS YOU KNOW EXACTLY WHAT YOU ARE DOING
+	 *
+	 *                             YOU HAVE BEEN WARNED
+	 *
+	 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	 *
+	 * Set an object to pass custom options to svelte-hmr
+	 *
+	 * @see https://github.com/rixo/svelte-hmr#options
+	 * @default true for development, always false for production
+	 */
+	hot?:
+		| boolean
+		| {
+				injectCss?: boolean;
+				partialAccept?: boolean;
+				[key: string]: any;
+		  };
+	/**
+	 * Some Vite plugins can contribute additional preprocessors by defining `api.sveltePreprocess`.
+	 * If you don't want to use them, set this to true to ignore them all or use an array of strings
+	 * with plugin names to specify which.
+	 *
+	 * @default false
+	 */
+	ignorePluginPreprocessors?: boolean | string[];
+	/**
+	 * vite-plugin-svelte automatically handles excluding svelte libraries and reinclusion of their dependencies
+	 * in vite.optimizeDeps.
+	 *
+	 * `disableDependencyReinclusion: true` disables all reinclusions
+	 * `disableDependencyReinclusion: ['foo','bar']` disables reinclusions for dependencies of foo and bar
+	 *
+	 * This should be used for hybrid packages that contain both node and browser dependencies, eg Routify
+	 *
+	 * @default false
+	 */
+	disableDependencyReinclusion?: boolean | string[];
+	/**
+	 * Enable support for Vite's dependency optimization to prebundle Svelte libraries.
+	 *
+	 * To disable prebundling for a specific library, add it to `optimizeDeps.exclude`.
+	 *
+	 * @default true for dev, false for build
+	 */
+	prebundleSvelteLibraries?: boolean;
+	/**
+	 * toggle/configure Svelte Inspector
+	 *
+	 * @default unset for dev, always false for build
+	 */
+	inspector?: InspectorOptions | boolean;
+	/**
+	 * These options are considered experimental and breaking changes to them can occur in any release
+	 */
+	experimental?: ExperimentalOptions;
+}
+
+interface SvelteOptions {
+	/**
+	 * A list of file extensions to be compiled by Svelte
+	 *
+	 * @default ['.svelte']
+	 */
+	extensions?: string[];
+	/**
+	 * An array of preprocessors to transform the Svelte source code before compilation
+	 *
+	 * @see https://svelte.dev/docs#svelte_preprocess
+	 */
+	preprocess?: Arrayable<PreprocessorGroup>;
+	/**
+	 * The options to be passed to the Svelte compiler. A few options are set by default,
+	 * including `dev` and `css`. However, some options are non-configurable, like
+	 * `filename`, `format`, `generate`, and `cssHash` (in dev).
+	 *
+	 * @see https://svelte.dev/docs#svelte_compile
+	 */
+	compilerOptions?: Omit<CompileOptions, 'filename' | 'format' | 'generate'>;
+	/**
+	 * Handles warning emitted from the Svelte compiler
+	 */
+	onwarn?: (warning: Warning, defaultHandler?: (warning: Warning) => void) => void;
+	/**
+	 * Options for vite-plugin-svelte
+	 */
+	vitePlugin?: PluginOptions;
+}
+
+/**
+ * These options are considered experimental and breaking changes to them can occur in any release
+ */
+interface ExperimentalOptions {
+	/**
+	 * A function to update `compilerOptions` before compilation
+	 *
+	 * `data.filename` - The file to be compiled
+	 * `data.code` - The preprocessed Svelte code
+	 * `data.compileOptions` - The current compiler options
+	 *
+	 * To change part of the compiler options, return an object with the changes you need.
+	 *
+	 * @example
+	 * ```
+	 * ({ filename, compileOptions }) => {
+	 *   // Dynamically set hydration per Svelte file
+	 *   if (compileWithHydratable(filename) && !compileOptions.hydratable) {
+	 *     return { hydratable: true };
+	 *   }
+	 * }
+	 * ```
+	 */
+	dynamicCompileOptions?: (data: {
+		filename: string;
+		code: string;
+		compileOptions: Partial<CompileOptions>;
+	}) => Promise<Partial<CompileOptions> | void> | Partial<CompileOptions> | void;
+	/**
+	 * send a websocket message with svelte compiler warnings during dev
+	 *
+	 */
+	sendWarningsToBrowser?: boolean;
+	/**
+	 * disable svelte field resolve warnings
+	 *
+	 * @default false
+	 */
+	disableSvelteResolveWarnings?: boolean;
+}
+
+type ModuleFormat = NonNullable<CompileOptions['format']>;
+type CssHashGetter = NonNullable<CompileOptions['cssHash']>;
+type Arrayable<T> = T | T[];
+
+interface VitePreprocessOptions {
+	script?: boolean;
+	style?: boolean | InlineConfig | ResolvedConfig;
+}
+
+declare function vitePreprocess(opts?: VitePreprocessOptions): PreprocessorGroup;
+
+declare function loadSvelteConfig(
+	viteConfig?: UserConfig,
+	inlineOptions?: Partial<Options>
+): Promise<Partial<SvelteOptions> | undefined>;
+
+declare function svelte(inlineOptions?: Partial<Options>): Plugin[];
+
+export {
+	Arrayable,
+	CssHashGetter,
+	ModuleFormat,
+	Options,
+	PluginOptions,
+	SvelteOptions,
+	loadSvelteConfig,
+	svelte,
+	VitePreprocessOptions,
+	vitePreprocess
+};
+
+// reexported types
+
+export { CompileOptions, Warning } from 'svelte/types/compiler/interfaces';
+
+export {
+	MarkupPreprocessor,
+	Preprocessor,
+	PreprocessorGroup,
+	Processed
+} from 'svelte/types/compiler/preprocess';

package/src/{index.ts → index.js}

@@ -1,76 +1,67 @@
 import fs from 'fs';
 import { VERSION as svelteVersion } from 'svelte/compiler';
-import {
-	HmrContext,
-	ModuleNode,
-	Plugin,
-	ResolvedConfig,
-	UserConfig,
-	version as viteVersion
-} from 'vite';
-// eslint-disable-next-line node/no-missing-import
+import { version as viteVersion } from 'vite';
+
+import { svelteInspector } from '@sveltejs/vite-plugin-svelte-inspector';
+
 import { isDepExcluded } from 'vitefu';
-import { handleHotUpdate } from './handle-hot-update';
-import { log, logCompilerWarnings } from './utils/log';
-import { type CompileSvelte, createCompileSvelte } from './utils/compile';
-import { buildIdParser, IdParser } from './utils/id';
+import { handleHotUpdate } from './handle-hot-update.js';
+import { log, logCompilerWarnings } from './utils/log.js';
+import { createCompileSvelte } from './utils/compile.js';
+import { buildIdParser } from './utils/id.js';
 import {
 	buildExtraViteConfig,
 	validateInlineOptions,
-	Options,
-	ResolvedOptions,
 	resolveOptions,
 	patchResolvedViteConfig,
 	preResolveOptions
-} from './utils/options';
+} from './utils/options.js';
 
-import { ensureWatchedFile, setupWatchers } from './utils/watch';
-import { resolveViaPackageJsonSvelte } from './utils/resolve';
-import { PartialResolvedId } from 'rollup';
-import { toRollupError } from './utils/error';
-import { saveSvelteMetadata } from './utils/optimizer';
-import { svelteInspector } from './ui/inspector/plugin';
-import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache';
-import { loadRaw } from './utils/load-raw';
-import { FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE } from './utils/constants';
+import { ensureWatchedFile, setupWatchers } from './utils/watch.js';
+import { resolveViaPackageJsonSvelte } from './utils/resolve.js';
 
-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
-}
+import { toRollupError } from './utils/error.js';
+import { saveSvelteMetadata } from './utils/optimizer.js';
+import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache.js';
+import { loadRaw } from './utils/load-raw.js';
+import { FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE } from './utils/constants.js';
 
 const isVite4_0 = viteVersion.startsWith('4.0');
 const isSvelte3 = svelteVersion.startsWith('3');
 
-export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
+/** @type {import('./index.d.ts').svelte} */
+export function svelte(inlineOptions) {
 	if (process.env.DEBUG != null) {
 		log.setLevel('debug');
 	}
 	validateInlineOptions(inlineOptions);
 	const cache = new VitePluginSvelteCache();
 	// updated in configResolved hook
-	let requestParser: IdParser;
-	let options: ResolvedOptions;
-	let viteConfig: ResolvedConfig;
-	/* eslint-disable no-unused-vars */
-	let compileSvelte: CompileSvelte;
+	/** @type {import('./types/id.d.ts').IdParser} */
+	let requestParser;
+	/** @type {import('./types/options.d.ts').ResolvedOptions} */
+	let options;
+	/** @type {import('vite').ResolvedConfig} */
+	let viteConfig;
+
+	/** @type {import('./types/compile.d.ts').CompileSvelte} */
+	let compileSvelte;
 	/* eslint-enable no-unused-vars */
 
-	let resolvedSvelteSSR: Promise<PartialResolvedId | null>;
-	let packagesWithResolveWarnings: Set<string>;
-	const api: PluginAPI = {};
-	const plugins: Plugin[] = [
+	/** @type {Promise<import('vite').Rollup.PartialResolvedId | null>} */
+	let resolvedSvelteSSR;
+	/** @type {Set<string>} */
+	let packagesWithResolveWarnings;
+	/** @type {import('./types/plugin-api.d.ts').PluginAPI} */
+	const api = {};
+	/** @type {import('vite').Plugin[]} */
+	const plugins = [
 		{
 			name: 'vite-plugin-svelte',
 			// make sure our resolver runs before vite internal resolver to resolve svelte field correctly
 			enforce: 'pre',
 			api,
-			async config(config, configEnv): Promise<Partial<UserConfig>> {
+			async config(config, configEnv) {
 				// setup logger
 				if (process.env.DEBUG) {
 					log.setLevel('debug');
@@ -97,7 +88,7 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 			},
 
 			async buildStart() {
-				packagesWithResolveWarnings = new Set<string>();
+				packagesWithResolveWarnings = new Set();
 				if (!options.prebundleSvelteLibraries) return;
 				const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
 				if (isSvelteMetadataChanged) {
@@ -108,7 +99,6 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 			},
 
 			configureServer(server) {
-				// eslint-disable-next-line no-unused-vars
 				options.server = server;
 				setupWatchers(options, cache, requestParser);
 			},
@@ -235,10 +225,16 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 				}
 				logCompilerWarnings(svelteRequest, compileData.compiled.warnings, options);
 				cache.update(compileData);
-				if (compileData.dependencies?.length && options.server) {
-					compileData.dependencies.forEach((d) => {
-						ensureWatchedFile(options.server!.watcher, d, options.root);
-					});
+				if (compileData.dependencies?.length) {
+					if (options.server) {
+						for (const dep of compileData.dependencies) {
+							ensureWatchedFile(options.server.watcher, dep, options.root);
+						}
+					} else if (options.isBuild && viteConfig.build.watch) {
+						for (const dep of compileData.dependencies) {
+							this.addWatchFile(dep);
+						}
+					}
 				}
 				log.debug(`transform returns compiled js for ${svelteRequest.filename}`);
 				return {
@@ -251,7 +247,7 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 				};
 			},
 
-			handleHotUpdate(ctx: HmrContext): void | Promise<Array<ModuleNode> | void> {
+			handleHotUpdate(ctx) {
 				if (!options.hot || !options.emitCss) {
 					return;
 				}
@@ -279,22 +275,5 @@ export function svelte(inlineOptions?: Partial<Options>): Plugin[] {
 	return plugins;
 }
 
-export { vitePreprocess } from './preprocess';
-export { loadSvelteConfig } from './utils/load-svelte-config';
-
-export {
-	Options,
-	PluginOptions,
-	SvelteOptions,
-	Preprocessor,
-	PreprocessorGroup,
-	CompileOptions,
-	CssHashGetter,
-	Arrayable,
-	MarkupPreprocessor,
-	ModuleFormat,
-	Processed,
-	Warning
-} from './utils/options';
-
-export { SvelteWarningsMessage } from './utils/log';
+export { vitePreprocess } from './preprocess.js';
+export { loadSvelteConfig } from './utils/load-svelte-config.js';

package/src/{preprocess.ts → preprocess.js}

@@ -1,19 +1,19 @@
 import { preprocessCSS, resolveConfig, transformWithEsbuild } from 'vite';
-import type { ESBuildOptions, InlineConfig, ResolvedConfig } from 'vite';
-// eslint-disable-next-line node/no-missing-import
-import type { Preprocessor, PreprocessorGroup } from 'svelte/types/compiler/preprocess';
-import { mapToRelative, removeLangSuffix } from './utils/sourcemaps';
+import { mapToRelative, removeLangSuffix } from './utils/sourcemaps.js';
+
+/**
+ * @typedef {(code: string, filename: string) => Promise<{ code: string; map?: any; deps?: Set<string> }>} CssTransform
+ */
 
 const supportedStyleLangs = ['css', 'less', 'sass', 'scss', 'styl', 'stylus', 'postcss', 'sss'];
 const supportedScriptLangs = ['ts'];
 
 export const lang_sep = '.vite-preprocess.';
 
-export function vitePreprocess(opts?: {
-	script?: boolean;
-	style?: boolean | InlineConfig | ResolvedConfig;
-}) {
-	const preprocessor: PreprocessorGroup = {};
+/** @type {import('./index.d.ts').vitePreprocess} */
+export function vitePreprocess(opts) {
+	/** @type {import('svelte/types/compiler/preprocess').PreprocessorGroup} */
+	const preprocessor = {};
 	if (opts?.script !== false) {
 		preprocessor.script = viteScript().script;
 	}
@@ -24,13 +24,16 @@ export function vitePreprocess(opts?: {
 	return preprocessor;
 }
 
-function viteScript(): { script: Preprocessor } {
+/**
+ * @returns {{ script: import('svelte/types/compiler/preprocess').Preprocessor }}
+ */
+function viteScript() {
 	return {
 		async script({ attributes, content, filename = '' }) {
-			const lang = attributes.lang as string;
+			const lang = /** @type {string} */ (attributes.lang);
 			if (!supportedScriptLangs.includes(lang)) return;
 			const { code, map } = await transformWithEsbuild(content, filename, {
-				loader: lang as ESBuildOptions['loader'],
+				loader: /** @type {import('vite').ESBuildOptions['loader']} */ (lang),
 				target: 'esnext',
 				tsconfigRaw: {
 					compilerOptions: {
@@ -51,15 +54,20 @@ function viteScript(): { script: Preprocessor } {
 	};
 }
 
-function viteStyle(config: InlineConfig | ResolvedConfig = {}): {
-	style: Preprocessor;
-} {
-	let transform: CssTransform;
-	const style: Preprocessor = async ({ attributes, content, filename = '' }) => {
-		const lang = attributes.lang as string;
+/**
+ * @param {import('vite').ResolvedConfig | import('vite').InlineConfig} config
+ * @returns {{ style: import('svelte/types/compiler/preprocess').Preprocessor }}
+ */
+function viteStyle(config = {}) {
+	/** @type {CssTransform} */
+	let transform;
+	/** @type {import('svelte/types/compiler/preprocess').Preprocessor} */
+	const style = async ({ attributes, content, filename = '' }) => {
+		const lang = /** @type {string} */ (attributes.lang);
 		if (!supportedStyleLangs.includes(lang)) return;
 		if (!transform) {
-			let resolvedConfig: ResolvedConfig;
+			/** @type {import('vite').ResolvedConfig} */
+			let resolvedConfig;
 			// @ts-expect-error special prop added if running in v-p-s
 			if (style.__resolvedConfig) {
 				// @ts-expect-error
@@ -91,19 +99,20 @@ function viteStyle(config: InlineConfig | ResolvedConfig = {}): {
 	return { style };
 }
 
-type CssTransform = (
-	// eslint-disable-next-line no-unused-vars
-	code: string,
-	// eslint-disable-next-line no-unused-vars
-	filename: string
-) => Promise<{ code: string; map?: any; deps?: Set<string> }>;
-
-function getCssTransformFn(config: ResolvedConfig): CssTransform {
+/**
+ * @param {import('vite').ResolvedConfig} config
+ * @returns {CssTransform}
+ */
+function getCssTransformFn(config) {
 	return async (code, filename) => {
 		return preprocessCSS(code, filename, config);
 	};
 }
 
-function isResolvedConfig(config: any): config is ResolvedConfig {
+/**
+ * @param {any} config
+ * @returns {config is import('vite').ResolvedConfig}
+ */
+function isResolvedConfig(config) {
 	return !!config.inlineConfig;
 }