@sveltejs/vite-plugin-svelte 2.2.0 → 2.4.0

package/src/utils/{id.ts → id.js}

@@ -1,11 +1,6 @@
-/* eslint-disable no-unused-vars */
-import { createFilter } from 'vite';
-import { Arrayable, ResolvedOptions } from './options';
-import { normalizePath } from 'vite';
+import { createFilter, normalizePath } from 'vite';
 import * as fs from 'fs';
-//eslint-disable-next-line node/no-missing-import
-import { CompileOptions } from 'svelte/types/compiler/interfaces';
-import { log } from './log';
+import { log } from './log.js';
 
 const VITE_FS_PREFIX = '/@fs/';
 const IS_WINDOWS = process.platform === 'win32';
@@ -21,49 +16,27 @@ const SUPPORTED_COMPILER_OPTIONS = [
 ];
 const TYPES_WITH_COMPILER_OPTIONS = ['style', 'script', 'all'];
 
-export type SvelteQueryTypes = 'style' | 'script' | 'preprocessed' | 'all';
-
-export interface RequestQuery {
-	// our own
-	svelte?: boolean;
-	type?: SvelteQueryTypes;
-	sourcemap?: boolean;
-	compilerOptions?: Pick<
-		CompileOptions,
-		'generate' | 'dev' | 'css' | 'hydratable' | 'customElement' | 'immutable' | 'enableSourcemap'
-	>;
-	// vite specific
-	url?: boolean;
-	raw?: boolean;
-	direct?: boolean;
-}
-
-export interface SvelteRequest {
-	id: string;
-	cssId: string;
-	filename: string;
-	normalizedFilename: string;
-	query: RequestQuery;
-	timestamp: number;
-	ssr: boolean;
-	raw: boolean;
-}
-
-function splitId(id: string) {
+/**
+ * @param {string} id
+ * @returns {{ filename: string, rawQuery: string }}
+ */
+function splitId(id) {
 	const parts = id.split(`?`, 2);
 	const filename = parts[0];
 	const rawQuery = parts[1];
 	return { filename, rawQuery };
 }
 
-function parseToSvelteRequest(
-	id: string,
-	filename: string,
-	rawQuery: string,
-	root: string,
-	timestamp: number,
-	ssr: boolean
-): SvelteRequest | undefined {
+/**
+ * @param {string} id
+ * @param {string} filename
+ * @param {string} rawQuery
+ * @param {string} root
+ * @param {number} timestamp
+ * @param {boolean} ssr
+ * @returns {import('../types/id.d.ts').SvelteRequest | undefined}
+ */
+function parseToSvelteRequest(id, filename, rawQuery, root, timestamp, ssr) {
 	const query = parseRequestQuery(rawQuery);
 	const rawOrDirect = !!(query.raw || query.direct);
 	if (query.url || (!query.svelte && rawOrDirect)) {
@@ -86,7 +59,13 @@ function parseToSvelteRequest(
 	};
 }
 
-function createVirtualImportId(filename: string, root: string, type: SvelteQueryTypes) {
+/**
+ * @param {string} filename
+ * @param {string} root
+ * @param {import('../types/id.d.ts').SvelteQueryTypes} type
+ * @returns {string}
+ */
+function createVirtualImportId(filename, root, type) {
 	const parts = ['svelte', `type=${type}`];
 	if (type === 'style') {
 		parts.push('lang.css');
@@ -102,7 +81,11 @@ function createVirtualImportId(filename: string, root: string, type: SvelteQuery
 	return `${filename}?${parts.join('&')}`;
 }
 
-function parseRequestQuery(rawQuery: string): RequestQuery {
+/**
+ * @param {string} rawQuery
+ * @returns {import('../types/id.d.ts').RequestQuery}
+ */
+function parseRequestQuery(rawQuery) {
 	const query = Object.fromEntries(new URLSearchParams(rawQuery));
 	for (const key in query) {
 		if (query[key] === '') {
@@ -138,46 +121,62 @@ function parseRequestQuery(rawQuery: string): RequestQuery {
 		}
 	}
 
-	return query as RequestQuery;
+	return /** @type {import('../types/id.d.ts').RequestQuery}*/ query;
 }
 
 /**
  * posixify and remove root at start
  *
- * @param filename
- * @param normalizedRoot
+ * @param {string} filename
+ * @param {string} normalizedRoot
+ * @returns {string}
  */
-function normalize(filename: string, normalizedRoot: string) {
+function normalize(filename, normalizedRoot) {
 	return stripRoot(normalizePath(filename), normalizedRoot);
 }
 
-function existsInRoot(filename: string, root: string) {
+/**
+ * @param {string} filename
+ * @param {string} root
+ * @returns {boolean}
+ */
+function existsInRoot(filename, root) {
 	if (filename.startsWith(VITE_FS_PREFIX)) {
 		return false; // vite already tagged it as out of root
 	}
 	return fs.existsSync(root + filename);
 }
 
-function stripRoot(normalizedFilename: string, normalizedRoot: string) {
+/**
+ * @param {string} normalizedFilename
+ * @param {string} normalizedRoot
+ * @returns {string}
+ */
+function stripRoot(normalizedFilename, normalizedRoot) {
 	return normalizedFilename.startsWith(normalizedRoot + '/')
 		? normalizedFilename.slice(normalizedRoot.length)
 		: normalizedFilename;
 }
 
-function buildFilter(
-	include: Arrayable<string> | undefined,
-	exclude: Arrayable<string> | undefined,
-	extensions: string[]
-): (filename: string) => boolean {
+/**
+ * @param {import('../index.d.ts').Arrayable<string> | undefined} include
+ * @param {import('../index.d.ts').Arrayable<string> | undefined} exclude
+ * @param {string[]} extensions
+ * @returns {(filename: string) => boolean}
+ */
+function buildFilter(include, exclude, extensions) {
 	const rollupFilter = createFilter(include, exclude);
 	return (filename) => rollupFilter(filename) && extensions.some((ext) => filename.endsWith(ext));
 }
 
-export type IdParser = (id: string, ssr: boolean, timestamp?: number) => SvelteRequest | undefined;
-export function buildIdParser(options: ResolvedOptions): IdParser {
+/**
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @returns {import('../types/id.d.ts').IdParser}
+ */
+export function buildIdParser(options) {
 	const { include, exclude, extensions, root } = options;
 	const normalizedRoot = normalizePath(root);
-	const filter = buildFilter(include, exclude, extensions!);
+	const filter = buildFilter(include, exclude, extensions ?? []);
 	return (id, ssr, timestamp = Date.now()) => {
 		const { filename, rawQuery } = splitId(id);
 		if (filter(filename)) {

package/src/utils/{load-raw.ts → load-raw.js}

@@ -1,18 +1,16 @@
-import { ResolvedOptions } from './options';
 import fs from 'fs';
-import { toRollupError } from './error';
-import { log } from './log';
-import type { SvelteRequest } from './id';
-import { type CompileData, CompileSvelte } from './compile';
+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: SvelteRequest,
-	compileSvelte: CompileSvelte,
-	options: ResolvedOptions
-) {
+export async function loadRaw(svelteRequest, compileSvelte, options) {
 	const { id, filename, query } = svelteRequest;
 
 	// raw svelte subrequest, compile on the fly and return requested subpart
@@ -88,12 +86,13 @@ export async function loadRaw(
 /**
  * turn compileData and source into a flat list of raw exports
  *
- * @param compileData
- * @param source
+ * @param {import('../types/compile.d.ts').CompileData} compileData
+ * @param {string} source
  */
-function allToRawExports(compileData: CompileData, source: string) {
+function allToRawExports(compileData, source) {
 	// flatten CompileData
-	const exports: Partial<CompileData & { source: string }> = {
+	/** @type {Partial<import('../types/compile.d.ts').CompileData & { source: string }>} */
+	const exports = {
 		...compileData,
 		...compileData.compiled,
 		source
@@ -115,9 +114,10 @@ function allToRawExports(compileData: CompileData, source: string) {
  *  export const foo='bar'
  *  export default code
  *  ```
- * @param object
+ * @param {object} object
+ * @returns {string}
  */
-function toRawExports(object: object) {
+function toRawExports(object) {
 	let exports =
 		Object.entries(object)
 			//eslint-disable-next-line no-unused-vars

package/src/utils/{load-svelte-config.ts → load-svelte-config.js}

@@ -2,14 +2,13 @@ import { createRequire } from 'module';
 import path from 'path';
 import fs from 'fs';
 import { pathToFileURL } from 'url';
-import { log } from './log';
-import { Options, SvelteOptions } from './options';
-import { UserConfig } from 'vite';
+import { log } from './log.js';
 
 // used to require cjs config in esm.
 // NOTE dynamic import() cjs technically works, but timestamp query cache bust
 // have no effect, likely because it has another internal cache?
-let esmRequire: NodeRequire;
+/** @type {NodeRequire}*/
+let esmRequire;
 
 export const knownSvelteConfigNames = [
 	'svelte.config.js',
@@ -26,10 +25,8 @@ const dynamicImportDefault = new Function(
 	'return import(path + "?t=" + timestamp).then(m => m.default)'
 );
 
-export async function loadSvelteConfig(
-	viteConfig?: UserConfig,
-	inlineOptions?: Partial<Options>
-): Promise<Partial<SvelteOptions> | undefined> {
+/** @type {import('../index.d.ts').loadSvelteConfig} */
+export async function loadSvelteConfig(viteConfig, inlineOptions) {
 	if (inlineOptions?.configFile === false) {
 		return;
 	}
@@ -61,7 +58,7 @@ export async function loadSvelteConfig(
 			try {
 				// identify which require function to use (esm and cjs mode)
 				const _require = import.meta.url
-					? (esmRequire ??= createRequire(import.meta.url))
+					? esmRequire ?? (esmRequire = createRequire(import.meta.url))
 					: require;
 
 				// avoid loading cached version on reload
@@ -87,7 +84,12 @@ export async function loadSvelteConfig(
 	}
 }
 
-function findConfigToLoad(viteConfig?: UserConfig, inlineOptions?: Partial<Options>) {
+/**
+ * @param {import('vite').UserConfig | undefined} viteConfig
+ * @param {Partial<import('../index.d.ts').Options> | undefined} inlineOptions
+ * @returns {string | undefined}
+ */
+function findConfigToLoad(viteConfig, inlineOptions) {
 	const root = viteConfig?.root || process.cwd();
 	if (inlineOptions?.configFile) {
 		const abolutePath = path.isAbsolute(inlineOptions.configFile)

package/src/utils/{log.ts → log.js}

@@ -1,11 +1,12 @@
-/* eslint-disable no-unused-vars,no-console */
-import { cyan, yellow, red } from 'kleur/colors';
+/* eslint-disable no-console */
+import { cyan, red, yellow } from 'kleur/colors';
 import debug from 'debug';
-import { ResolvedOptions, Warning } from './options';
-import { SvelteRequest } from './id';
-const levels: string[] = ['debug', 'info', 'warn', 'error', 'silent'];
+
+/** @type {import('../types/log.d.ts').LogLevel[]} */
+const levels = ['debug', 'info', 'warn', 'error', 'silent'];
 const prefix = 'vite-plugin-svelte';
-const loggers: { [key: string]: any } = {
+/** @type {Record<import('../types/log.d.ts').LogLevel, any>} */
+const loggers = {
 	debug: {
 		log: debug(`vite:${prefix}`),
 		enabled: false,
@@ -31,8 +32,13 @@ const loggers: { [key: string]: any } = {
 	}
 };
 
-let _level: string = 'info';
-function setLevel(level: string) {
+/** @type {import('../types/log.d.ts').LogLevel} */
+let _level = 'info';
+/**
+ * @param {import('../types/log.d.ts').LogLevel} level
+ * @returns {void}
+ */
+function setLevel(level) {
 	if (level === _level) {
 		return;
 	}
@@ -47,7 +53,14 @@ function setLevel(level: string) {
 	}
 }
 
-function _log(logger: any, message: string, payload?: any, namespace?: string) {
+/**
+ * @param {any} logger
+ * @param {string} message
+ * @param {any} [payload]
+ * @param {string} [namespace]
+ * @returns
+ */
+function _log(logger, message, payload, namespace) {
 	if (!logger.enabled) {
 		return;
 	}
@@ -68,17 +81,17 @@ function _log(logger: any, message: string, payload?: any, namespace?: string) {
 	}
 }
 
-export interface LogFn {
-	(message: string, payload?: any, namespace?: string): void;
-	enabled: boolean;
-	once: (message: string, payload?: any, namespace?: string) => void;
-}
-
-function createLogger(level: string): LogFn {
+/**
+ * @param {import('../types/log.d.ts').LogLevel} level
+ * @returns {import('../types/log.d.ts').LogFn}
+ */
+function createLogger(level) {
 	const logger = loggers[level];
-	const logFn: LogFn = _log.bind(null, logger) as LogFn;
-	const logged = new Set<String>();
-	const once = function (message: string, payload?: any, namespace?: string) {
+	const logFn = /** @type {import('../types/log.d.ts').LogFn} */ (_log.bind(null, logger));
+	/** @type {Set<string>} */
+	const logged = new Set();
+	/** @type {import('../types/log.d.ts').SimpleLogFn} */
+	const once = function (message, payload, namespace) {
 		if (!logger.enabled || logged.has(message)) {
 			return;
 		}
@@ -106,31 +119,24 @@ export const log = {
 	setLevel
 };
 
-export type SvelteWarningsMessage = {
-	id: string;
-	filename: string;
-	normalizedFilename: string;
-	timestamp: number;
-	warnings: Warning[]; // allWarnings filtered by warnings where onwarn did not call the default handler
-	allWarnings: Warning[]; // includes warnings filtered by onwarn and our extra vite plugin svelte warnings
-	rawWarnings: Warning[]; // raw compiler output
-};
-
-export function logCompilerWarnings(
-	svelteRequest: SvelteRequest,
-	warnings: Warning[],
-	options: ResolvedOptions
-) {
+/**
+ * @param {import('../types/id.d.ts').SvelteRequest} svelteRequest
+ * @param {import('svelte/types/compiler/interfaces').Warning[]} warnings
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ */
+export function logCompilerWarnings(svelteRequest, warnings, options) {
 	const { emitCss, onwarn, isBuild } = options;
 	const sendViaWS = !isBuild && options.experimental?.sendWarningsToBrowser;
 	let warn = isBuild ? warnBuild : warnDev;
-	const handledByDefaultWarn: Warning[] = [];
+	/** @type {import('svelte/types/compiler/interfaces').Warning[]} */
+	const handledByDefaultWarn = [];
 	const notIgnored = warnings?.filter((w) => !ignoreCompilerWarning(w, isBuild, emitCss));
 	const extra = buildExtraWarnings(warnings, isBuild);
 	const allWarnings = [...notIgnored, ...extra];
 	if (sendViaWS) {
 		const _warn = warn;
-		warn = (w: Warning) => {
+		/** @type {(w: import('svelte/types/compiler/interfaces').Warning) => void} */
+		warn = (w) => {
 			handledByDefaultWarn.push(w);
 			_warn(w);
 		};
@@ -143,7 +149,8 @@ export function logCompilerWarnings(
 		}
 	});
 	if (sendViaWS) {
-		const message: SvelteWarningsMessage = {
+		/** @type {import('../types/log.d.ts').SvelteWarningsMessage} */
+		const message = {
 			id: svelteRequest.id,
 			filename: svelteRequest.filename,
 			normalizedFilename: svelteRequest.normalizedFilename,
@@ -157,23 +164,36 @@ export function logCompilerWarnings(
 	}
 }
 
-function ignoreCompilerWarning(
-	warning: Warning,
-	isBuild: boolean,
-	emitCss: boolean | undefined
-): boolean {
+/**
+ * @param {import('svelte/types/compiler/interfaces').Warning} warning
+ * @param {boolean} isBuild
+ * @param {boolean} [emitCss]
+ * @returns {boolean}
+ */
+function ignoreCompilerWarning(warning, isBuild, emitCss) {
 	return (
 		(!emitCss && warning.code === 'css-unused-selector') || // same as rollup-plugin-svelte
 		(!isBuild && isNoScopableElementWarning(warning))
 	);
 }
 
-function isNoScopableElementWarning(warning: Warning) {
+/**
+ *
+ * @param {import('svelte/types/compiler/interfaces').Warning} warning
+ * @returns {boolean}
+ */
+function isNoScopableElementWarning(warning) {
 	// see https://github.com/sveltejs/vite-plugin-svelte/issues/153
 	return warning.code === 'css-unused-selector' && warning.message.includes('"*"');
 }
 
-function buildExtraWarnings(warnings: Warning[], isBuild: boolean): Warning[] {
+/**
+ *
+ * @param {import('svelte/types/compiler/interfaces').Warning[]} warnings
+ * @param {boolean} isBuild
+ * @returns {import('svelte/types/compiler/interfaces').Warning[]}
+ */
+function buildExtraWarnings(warnings, isBuild) {
 	const extraWarnings = [];
 	if (!isBuild) {
 		const noScopableElementWarnings = warnings.filter((w) => isNoScopableElementWarning(w));
@@ -191,15 +211,24 @@ function buildExtraWarnings(warnings: Warning[], isBuild: boolean): Warning[] {
 	return extraWarnings;
 }
 
-function warnDev(w: Warning) {
+/**
+ * @param {import('svelte/types/compiler/interfaces').Warning} w
+ */
+function warnDev(w) {
 	log.info.enabled && log.info(buildExtendedLogMessage(w));
 }
 
-function warnBuild(w: Warning) {
+/**
+ * @param {import('svelte/types/compiler/interfaces').Warning} w
+ */
+function warnBuild(w) {
 	log.warn.enabled && log.warn(buildExtendedLogMessage(w), w.frame);
 }
 
-export function buildExtendedLogMessage(w: Warning) {
+/**
+ * @param {import('svelte/types/compiler/interfaces').Warning} w
+ */
+export function buildExtendedLogMessage(w) {
 	const parts = [];
 	if (w.filename) {
 		parts.push(w.filename);
@@ -216,6 +245,10 @@ export function buildExtendedLogMessage(w: Warning) {
 	return parts.join('');
 }
 
-export function isDebugNamespaceEnabled(namespace: string) {
+/**
+ * @param {string} namespace
+ * @returns {boolean}
+ */
+export function isDebugNamespaceEnabled(namespace) {
 	return debug.enabled(`vite:${prefix}:${namespace}`);
 }

package/src/utils/{optimizer.ts → optimizer.js}

@@ -1,9 +1,9 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import { ResolvedOptions } from './options';
 
 // List of options that changes the prebundling result
-const PREBUNDLE_SENSITIVE_OPTIONS: (keyof ResolvedOptions)[] = [
+/** @type {(keyof import('../types/options.d.ts').ResolvedOptions)[]} */
+const PREBUNDLE_SENSITIVE_OPTIONS = [
 	'compilerOptions',
 	'configFile',
 	'experimental',
@@ -13,9 +13,11 @@ const PREBUNDLE_SENSITIVE_OPTIONS: (keyof ResolvedOptions)[] = [
 ];
 
 /**
- * @returns Whether the Svelte metadata has changed
+ * @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: string, options: ResolvedOptions) {
+export async function saveSvelteMetadata(cacheDir, options) {
 	const svelteMetadata = generateSvelteMetadata(options);
 	const svelteMetadataPath = path.resolve(cacheDir, '_svelte_metadata.json');
 
@@ -24,7 +26,8 @@ export async function saveSvelteMetadata(cacheDir: string, options: ResolvedOpti
 		return typeof value === 'function' ? value.toString() : value;
 	});
 
-	let existingSvelteMetadata: string | undefined;
+	/** @type {string | undefined} */
+	let existingSvelteMetadata;
 	try {
 		existingSvelteMetadata = await fs.readFile(svelteMetadataPath, 'utf8');
 	} catch {
@@ -36,8 +39,13 @@ export async function saveSvelteMetadata(cacheDir: string, options: ResolvedOpti
 	return currentSvelteMetadata !== existingSvelteMetadata;
 }
 
-function generateSvelteMetadata(options: ResolvedOptions) {
-	const metadata: Record<string, any> = {};
+/**
+ * @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];
 	}