@sveltejs/vite-plugin-svelte 2.3.0 → 2.4.0

package/src/utils/{vite-plugin-svelte-stats.ts → vite-plugin-svelte-stats.js}

@@ -1,54 +1,29 @@
-import { log } from './log';
+import { log } from './log.js';
 import { performance } from 'perf_hooks';
 import { normalizePath } from 'vite';
-import { VitePluginSvelteCache } from './vite-plugin-svelte-cache';
 
-interface Stat {
-	file: string;
-	pkg?: string;
-	start: number;
-	end: number;
-}
-
-export interface StatCollection {
-	name: string;
-	options: CollectionOptions;
-	//eslint-disable-next-line no-unused-vars
-	start: (file: string) => () => void;
-	stats: Stat[];
-	packageStats?: PackageStats[];
-	collectionStart: number;
-	duration?: number;
-	finish: () => Promise<void> | void;
-	finished: boolean;
-}
-
-interface PackageStats {
-	pkg: string;
-	files: number;
-	duration: number;
-}
-
-export interface CollectionOptions {
-	//eslint-disable-next-line no-unused-vars
-	logInProgress: (collection: StatCollection, now: number) => boolean;
-	//eslint-disable-next-line no-unused-vars
-	logResult: (collection: StatCollection) => boolean;
-}
-
-const defaultCollectionOptions: CollectionOptions = {
+/** @type {import('../types/vite-plugin-svelte-stats.d.ts').CollectionOptions} */
+const defaultCollectionOptions = {
 	// log after 500ms and more than one file processed
 	logInProgress: (c, now) => now - c.collectionStart > 500 && c.stats.length > 1,
 	// always log results
 	logResult: () => true
 };
 
-function humanDuration(n: number) {
+/**
+ * @param {number} n
+ * @returns
+ */
+function humanDuration(n) {
 	// 99.9ms  0.10s
 	return n < 100 ? `${n.toFixed(1)}ms` : `${(n / 1000).toFixed(2)}s`;
 }
 
-function formatPackageStats(pkgStats: PackageStats[]) {
+/**
+ * @param {import('../types/vite-plugin-svelte-stats.d.ts').PackageStats[]} pkgStats
+ * @returns {string}
+ */
+function formatPackageStats(pkgStats) {
 	const statLines = pkgStats.map((pkgStat) => {
 		const duration = pkgStat.duration;
 		const avg = duration / pkgStat.files;
@@ -56,7 +31,7 @@ function formatPackageStats(pkgStats: PackageStats[]) {
 	});
 	statLines.unshift(['package', 'files', 'time', 'avg']);
 	const columnWidths = statLines.reduce(
-		(widths: number[], row) => {
+		(widths, row) => {
 			for (let i = 0; i < row.length; i++) {
 				const cell = row[i];
 				if (widths[i] < cell.length) {
@@ -69,9 +44,9 @@ function formatPackageStats(pkgStats: PackageStats[]) {
 	);
 
 	const table = statLines
-		.map((row: string[]) =>
+		.map((row) =>
 			row
-				.map((cell: string, i: number) => {
+				.map((cell, i) => {
 					if (i === 0) {
 						return cell.padEnd(columnWidths[i], ' ');
 					} else {
@@ -84,23 +59,40 @@ function formatPackageStats(pkgStats: PackageStats[]) {
 	return table;
 }
 
+/**
+ * @class
+ */
 export class VitePluginSvelteStats {
 	// package directory -> package name
-	private _cache: VitePluginSvelteCache;
-	private _collections: StatCollection[] = [];
-	constructor(cache: VitePluginSvelteCache) {
-		this._cache = cache;
+	/** @type {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} */
+	#cache;
+	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection[]} */
+	#collections = [];
+
+	/**
+	 * @param {import('./vite-plugin-svelte-cache.js').VitePluginSvelteCache} cache
+	 */
+	constructor(cache) {
+		this.#cache = cache;
 	}
-	startCollection(name: string, opts?: Partial<CollectionOptions>) {
+
+	/**
+	 * @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}
+	 */
+	startCollection(name, opts) {
 		const options = {
 			...defaultCollectionOptions,
 			...opts
 		};
-		const stats: Stat[] = [];
+		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').Stat[]} */
+		const stats = [];
 		const collectionStart = performance.now();
 		const _this = this;
 		let hasLoggedProgress = false;
-		const collection: StatCollection = {
+		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} */
+		const collection = {
 			name,
 			options,
 			stats,
@@ -112,7 +104,8 @@ export class VitePluginSvelteStats {
 				}
 				file = normalizePath(file);
 				const start = performance.now();
-				const stat: Stat = { file, start, end: start };
+				/** @type {import('../types/vite-plugin-svelte-stats.d.ts').Stat} */
+				const stat = { file, start, end: start };
 				return () => {
 					const now = performance.now();
 					stat.end = now;
@@ -124,34 +117,41 @@ export class VitePluginSvelteStats {
 				};
 			},
 			async finish() {
-				await _this._finish(collection);
+				await _this.#finish(collection);
 			}
 		};
-		_this._collections.push(collection);
+		_this.#collections.push(collection);
 		return collection;
 	}
 
-	public async finishAll() {
-		await Promise.all(this._collections.map((c) => c.finish()));
+	async finishAll() {
+		await Promise.all(this.#collections.map((c) => c.finish()));
 	}
 
-	private async _finish(collection: StatCollection) {
+	/**
+	 * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} collection
+	 */
+	async #finish(collection) {
 		try {
 			collection.finished = true;
 			const now = performance.now();
 			collection.duration = now - collection.collectionStart;
 			const logResult = collection.options.logResult(collection);
 			if (logResult) {
-				await this._aggregateStatsResult(collection);
+				await this.#aggregateStatsResult(collection);
 				log.debug(
-					`${collection.name} done.\n${formatPackageStats(collection.packageStats!)}`,
+					`${collection.name} done.\n${formatPackageStats(
+						/** @type {import('../types/vite-plugin-svelte-stats.d.ts').PackageStats[]}*/ (
+							collection.packageStats
+						)
+					)}`,
 					undefined,
 					'stats'
 				);
 			}
 			// cut some ties to free it for garbage collection
-			const index = this._collections.indexOf(collection);
-			this._collections.splice(index, 1);
+			const index = this.#collections.indexOf(collection);
+			this.#collections.splice(index, 1);
 			collection.stats.length = 0;
 			collection.stats = [];
 			if (collection.packageStats) {
@@ -166,16 +166,20 @@ export class VitePluginSvelteStats {
 		}
 	}
 
-	private async _aggregateStatsResult(collection: StatCollection) {
+	/**
+	 * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} collection
+	 */
+	async #aggregateStatsResult(collection) {
 		const stats = collection.stats;
 		for (const stat of stats) {
-			stat.pkg = (await this._cache.getPackageInfo(stat.file)).name;
+			stat.pkg = (await this.#cache.getPackageInfo(stat.file)).name;
 		}
 
 		// group stats
-		const grouped: { [key: string]: PackageStats } = {};
+		/** @type {Record<string, import('../types/vite-plugin-svelte-stats.d.ts').PackageStats>} */
+		const grouped = {};
 		stats.forEach((stat) => {
-			const pkg = stat.pkg!;
+			const pkg = /** @type {string} */ (stat.pkg);
 			let group = grouped[pkg];
 			if (!group) {
 				group = grouped[pkg] = {

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

@@ -1,25 +1,23 @@
-import { VitePluginSvelteCache } from './vite-plugin-svelte-cache';
 import fs from 'fs';
-import { log } from './log';
-import { IdParser } from './id';
-import { ResolvedOptions } from './options';
-import { knownSvelteConfigNames } from './load-svelte-config';
+import { log } from './log.js';
+import { knownSvelteConfigNames } from './load-svelte-config.js';
 import path from 'path';
-import { FSWatcher } from 'vite';
 
-export function setupWatchers(
-	options: ResolvedOptions,
-	cache: VitePluginSvelteCache,
-	requestParser: IdParser
-) {
+/**
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @param {import('./vite-plugin-svelte-cache').VitePluginSvelteCache} cache
+ * @param {import('../types/id.d.ts').IdParser} requestParser
+ * @returns {void}
+ */
+export function setupWatchers(options, cache, requestParser) {
 	const { server, configFile: svelteConfigFile } = options;
 	if (!server) {
 		return;
 	}
 	const { watcher, ws } = server;
 	const { root, server: serverConfig } = server.config;
-
-	const emitChangeEventOnDependants = (filename: string) => {
+	/** @type {(filename: string) => void} */
+	const emitChangeEventOnDependants = (filename) => {
 		const dependants = cache.getDependants(filename);
 		dependants.forEach((dependant) => {
 			if (fs.existsSync(dependant)) {
@@ -30,8 +28,8 @@ export function setupWatchers(
 			}
 		});
 	};
-
-	const removeUnlinkedFromCache = (filename: string) => {
+	/** @type {(filename: string) => void} */
+	const removeUnlinkedFromCache = (filename) => {
 		const svelteRequest = requestParser(filename, false);
 		if (svelteRequest) {
 			const removedFromCache = cache.remove(svelteRequest);
@@ -40,8 +38,8 @@ export function setupWatchers(
 			}
 		}
 	};
-
-	const triggerViteRestart = (filename: string) => {
+	/** @type {(filename: string) => void} */
+	const triggerViteRestart = (filename) => {
 		if (serverConfig.middlewareMode) {
 			// in middlewareMode we can't restart the server automatically
 			// show the user an overlay instead
@@ -59,8 +57,9 @@ export function setupWatchers(
 	};
 
 	// collection of watcher listeners by event
+	/** @type {Record<string, Function[]>} */
 	const listenerCollection = {
-		add: [] as Array<Function>,
+		add: [],
 		change: [emitChangeEventOnDependants],
 		unlink: [removeUnlinkedFromCache, emitChangeEventOnDependants]
 	};
@@ -68,13 +67,15 @@ export function setupWatchers(
 	if (svelteConfigFile !== false) {
 		// configFile false means we ignore the file and external process is responsible
 		const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path.join(root, cfg));
-		const restartOnConfigAdd = (filename: string) => {
+		/** @type {(filename: string) => void} */
+		const restartOnConfigAdd = (filename) => {
 			if (possibleSvelteConfigs.includes(filename)) {
 				triggerViteRestart(filename);
 			}
 		};
 
-		const restartOnConfigChange = (filename: string) => {
+		/** @type {(filename: string) => void} */
+		const restartOnConfigChange = (filename) => {
 			if (filename === svelteConfigFile) {
 				triggerViteRestart(filename);
 			}
@@ -94,8 +95,15 @@ export function setupWatchers(
 		}
 	});
 }
-// taken from vite utils
-export function ensureWatchedFile(watcher: FSWatcher, file: string | null, root: string): void {
+
+/**
+ * taken from vite utils
+ * @param {import('vite').FSWatcher} watcher
+ * @param {string | null} file
+ * @param {string} root
+ * @returns {void}
+ */
+export function ensureWatchedFile(watcher, file, root) {
 	if (
 		file &&
 		// only need to watch if out of root

package/dist/index.d.ts

@@ -1,193 +0,0 @@
-import { InlineConfig, ResolvedConfig, UserConfig, Plugin } from 'vite';
-import { CompileOptions, Warning } from 'svelte/types/compiler/interfaces';
-export { CompileOptions, Warning } from 'svelte/types/compiler/interfaces';
-import { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
-export { MarkupPreprocessor, Preprocessor, PreprocessorGroup, Processed } from 'svelte/types/compiler/preprocess';
-import { Options as Options$1 } 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 true
-     */
-    inspector?: Options$1 | 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[];
-
-declare function vitePreprocess(opts?: {
-    script?: boolean;
-    style?: boolean | InlineConfig | ResolvedConfig;
-}): PreprocessorGroup;
-
-declare function loadSvelteConfig(viteConfig?: UserConfig, inlineOptions?: Partial<Options>): Promise<Partial<SvelteOptions> | undefined>;
-
-type SvelteWarningsMessage = {
-    id: string;
-    filename: string;
-    normalizedFilename: string;
-    timestamp: number;
-    warnings: Warning[];
-    allWarnings: Warning[];
-    rawWarnings: Warning[];
-};
-
-declare function svelte(inlineOptions?: Partial<Options>): Plugin[];
-
-export { Arrayable, CssHashGetter, ModuleFormat, Options, PluginOptions, SvelteOptions, SvelteWarningsMessage, loadSvelteConfig, svelte, vitePreprocess };