@sveltejs/vite-plugin-svelte 2.0.4 → 2.1.1

package/src/utils/vite-plugin-svelte-cache.ts

@@ -1,5 +1,17 @@
 import { SvelteRequest } from './id';
 import { Code, CompileData } from './compile';
+import { readFileSync } from 'fs';
+import { dirname } from 'path';
+//eslint-disable-next-line node/no-missing-import
+import { findClosestPkgJsonPath } from 'vitefu';
+import { normalizePath } from 'vite';
+
+interface PackageInfo {
+	name: string;
+	version: string;
+	svelte?: string;
+	path: string;
+}
 
 export class VitePluginSvelteCache {
 	private _css = new Map<string, Code>();
@@ -8,6 +20,7 @@ export class VitePluginSvelteCache {
 	private _dependants = new Map<string, Set<string>>();
 	private _resolvedSvelteFields = new Map<string, string>();
 	private _errors = new Map<string, any>();
+	private _packageInfos: PackageInfo[] = [];
 
 	public update(compileData: CompileData) {
 		this._errors.delete(compileData.normalizedFilename);
@@ -110,6 +123,9 @@ export class VitePluginSvelteCache {
 		return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
 	}
 
+	public hasResolvedSvelteField(name: string, importer?: string) {
+		return this._resolvedSvelteFields.has(this._getResolvedSvelteFieldKey(name, importer));
+	}
 	public setResolvedSvelteField(
 		importee: string,
 		importer: string | undefined = undefined,
@@ -124,4 +140,43 @@ export class VitePluginSvelteCache {
 	private _getResolvedSvelteFieldKey(importee: string, importer?: string): string {
 		return importer ? `${importer} > ${importee}` : importee;
 	}
+
+	public async getPackageInfo(file: string): Promise<PackageInfo> {
+		let info = this._packageInfos.find((pi) => file.startsWith(pi.path));
+		if (!info) {
+			info = await findPackageInfo(file);
+			this._packageInfos.push(info);
+		}
+		return info;
+	}
+}
+
+/**
+ * utility to get some info from the closest package.json with a "name" set
+ *
+ * @param {string} file to find info for
+ * @returns {PackageInfo}
+ */
+async function findPackageInfo(file: string): Promise<PackageInfo> {
+	const info: PackageInfo = {
+		name: '$unknown',
+		version: '0.0.0-unknown',
+		path: '$unknown'
+	};
+	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+		if (pkg.name != null) {
+			info.name = pkg.name;
+			if (pkg.version != null) {
+				info.version = pkg.version;
+			}
+			info.svelte = pkg.svelte;
+			return true;
+		}
+		return false;
+	});
+	// return normalized path with appended '/' so .startsWith works for future file checks
+	path = normalizePath(dirname(path ?? file)) + '/';
+	info.path = path;
+	return info;
 }

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

@@ -1,10 +1,7 @@
 import { log } from './log';
-//eslint-disable-next-line node/no-missing-import
-import { findClosestPkgJsonPath } from 'vitefu';
-import { readFileSync } from 'fs';
-import { dirname } from 'path';
 import { performance } from 'perf_hooks';
 import { normalizePath } from 'vite';
+import { VitePluginSvelteCache } from './vite-plugin-svelte-cache';
 
 interface Stat {
 	file: string;
@@ -87,31 +84,13 @@ function formatPackageStats(pkgStats: PackageStats[]) {
 	return table;
 }
 
-/**
- * utility to get the package name a file belongs to
- *
- * @param {string} file to find package for
- * @returns {path:string,name:string} tuple of path,name where name is the parsed package name and path is the normalized path to it
- */
-async function getClosestNamedPackage(file: string): Promise<{ name: string; path: string }> {
-	let name = '$unknown';
-	let path = await findClosestPkgJsonPath(file, (pkgPath) => {
-		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-		if (pkg.name != null) {
-			name = pkg.name;
-			return true;
-		}
-		return false;
-	});
-	// return normalized path with appended '/' so .startsWith works for future file checks
-	path = normalizePath(dirname(path ?? file)) + '/';
-	return { name, path };
-}
-
 export class VitePluginSvelteStats {
 	// package directory -> package name
-	private _packages: { path: string; name: string }[] = [];
+	private _cache: VitePluginSvelteCache;
 	private _collections: StatCollection[] = [];
+	constructor(cache: VitePluginSvelteCache) {
+		this._cache = cache;
+	}
 	startCollection(name: string, opts?: Partial<CollectionOptions>) {
 		const options = {
 			...defaultCollectionOptions,
@@ -140,7 +119,7 @@ export class VitePluginSvelteStats {
 					stats.push(stat);
 					if (!hasLoggedProgress && options.logInProgress(collection, now)) {
 						hasLoggedProgress = true;
-						log.info(`${name} in progress ...`);
+						log.debug(`${name} in progress ...`, undefined, 'stats');
 					}
 				};
 			},
@@ -164,7 +143,11 @@ export class VitePluginSvelteStats {
 			const logResult = collection.options.logResult(collection);
 			if (logResult) {
 				await this._aggregateStatsResult(collection);
-				log.info(`${collection.name} done.`, formatPackageStats(collection.packageStats!));
+				log.debug(
+					`${collection.name} done.\n${formatPackageStats(collection.packageStats!)}`,
+					undefined,
+					'stats'
+				);
 			}
 			// cut some ties to free it for garbage collection
 			const index = this._collections.indexOf(collection);
@@ -179,19 +162,14 @@ export class VitePluginSvelteStats {
 			collection.finish = () => {};
 		} catch (e) {
 			// this should not happen, but stats taking also should not break the process
-			log.debug.once(`failed to finish stats for ${collection.name}`, e);
+			log.debug.once(`failed to finish stats for ${collection.name}\n`, e, 'stats');
 		}
 	}
 
 	private async _aggregateStatsResult(collection: StatCollection) {
 		const stats = collection.stats;
 		for (const stat of stats) {
-			let pkg = this._packages.find((p) => stat.file.startsWith(p.path));
-			if (!pkg) {
-				pkg = await getClosestNamedPackage(stat.file);
-				this._packages.push(pkg);
-			}
-			stat.pkg = pkg.name;
+			stat.pkg = (await this._cache.getPackageInfo(stat.file)).name;
 		}
 
 		// group stats