sonda 0.13.0 → 0.14.0

package/dist/index.js

@@ -168,7 +168,7 @@ function hasIgnoredExtension(name) {
 }
 //#endregion
 //#region package.json
-var version = "0.13.0";
+var version = "0.14.0";
 //#endregion
 //#region src/report/formatters/Formatter.ts
 var Formatter = class {
@@ -414,6 +414,7 @@ const parentMap = {};
 * Update the report with the output assets and their sources from the source map.
 */
 function updateOutput(report, path, entrypoints) {
+	if (!existsSync(path)) return;
 	const type = getTypeByName(path);
 	RESOURCE_TYPES_TO_ANALYZE.includes(type) ? addAnalyzableType(report, path, entrypoints, type) : addNonAnalyzableType(report, path, type);
 }
@@ -539,6 +540,7 @@ const packageNameRegExp = /(.*)(?:.*node_modules\/)(@[^\/]+\/[^\/]+|[^\/]+)/;
 function updateDependencies(report) {
 	const dependencies = {};
 	report.resources.map((file) => packageNameRegExp.exec(file.name)).filter((match) => match !== null).forEach(([path, , name]) => {
+		if (!existsSync(path)) return;
 		const paths = dependencies[name] ??= [];
 		if (!paths.includes(path)) paths.push(path);
 	});
@@ -548,6 +550,127 @@ function updateDependencies(report) {
 	}));
 }
 //#endregion
+//#region src/report/processors/issues.ts
+const MAX_CIRCULAR_IMPORT_ISSUES = 100;
+const IMPORT_CONNECTION_KINDS = /* @__PURE__ */ new Set([
+	"import",
+	"require",
+	"dynamic-import"
+]);
+/**
+* Finds common issues in the report data.
+*/
+function updateIssues(dependencies, connections) {
+	return [...findDuplicatedDependencies(dependencies), ...findCircularImports(connections)];
+}
+function findDuplicatedDependencies(dependencies) {
+	return dependencies.filter((dependency) => dependency.paths.length > 1).map((dependency) => ({
+		type: "duplicated-dependency",
+		severity: "warning",
+		message: `Dependency "${dependency.name}" appears to be bundled from multiple paths.`,
+		data: {
+			name: dependency.name,
+			paths: dependency.paths
+		}
+	}));
+}
+function findCircularImports(connections) {
+	const graph = createImportGraph(connections);
+	return findStronglyConnectedComponents(graph).filter((component) => component.length > 1 || hasSelfReference(graph, component[0])).toSorted(compareComponents).slice(0, MAX_CIRCULAR_IMPORT_ISSUES).map((component) => {
+		const cycle = findCycleInComponent(graph, component);
+		return {
+			type: "circular-import",
+			severity: "warning",
+			message: `Circular import detected between ${cycle.length - 1} modules.`,
+			data: { cycle }
+		};
+	});
+}
+function createImportGraph(connections) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const connection of connections) {
+		if (!IMPORT_CONNECTION_KINDS.has(connection.kind)) continue;
+		const targets = graph.get(connection.source) ?? /* @__PURE__ */ new Set();
+		targets.add(connection.target);
+		graph.set(connection.source, targets);
+		if (!graph.has(connection.target)) graph.set(connection.target, /* @__PURE__ */ new Set());
+	}
+	return new Map([...graph].map(([node, targets]) => [node, [...targets].toSorted()]));
+}
+function findStronglyConnectedComponents(graph) {
+	let index = 0;
+	const stack = [];
+	const indexes = /* @__PURE__ */ new Map();
+	const lowLinks = /* @__PURE__ */ new Map();
+	const stacked = /* @__PURE__ */ new Set();
+	const components = [];
+	function visit(node) {
+		indexes.set(node, index);
+		lowLinks.set(node, index);
+		index++;
+		stack.push(node);
+		stacked.add(node);
+		for (const next of graph.get(node) ?? []) if (!indexes.has(next)) {
+			visit(next);
+			lowLinks.set(node, Math.min(lowLinks.get(node), lowLinks.get(next)));
+		} else if (stacked.has(next)) lowLinks.set(node, Math.min(lowLinks.get(node), indexes.get(next)));
+		if (lowLinks.get(node) !== indexes.get(node)) return;
+		const component = [];
+		let current;
+		do {
+			current = stack.pop();
+			if (current === void 0) break;
+			stacked.delete(current);
+			component.push(current);
+		} while (current !== node);
+		components.push(component.toSorted());
+	}
+	for (const node of [...graph.keys()].toSorted()) if (!indexes.has(node)) visit(node);
+	return components;
+}
+function findCycleInComponent(graph, component) {
+	const nodes = new Set(component);
+	const start = component[0];
+	if (hasSelfReference(graph, start)) return [start, start];
+	for (const next of graph.get(start) ?? []) {
+		if (!nodes.has(next)) continue;
+		const path = findPath(graph, next, start, nodes);
+		if (path) return [start, ...path];
+	}
+	return [start, start];
+}
+function findPath(graph, source, target, allowedNodes) {
+	const queue = [source];
+	const visited = /* @__PURE__ */ new Set([source]);
+	const previous = /* @__PURE__ */ new Map();
+	for (let index = 0; index < queue.length; index++) {
+		const current = queue[index];
+		if (current === target) return reconstructPath(previous, source, target);
+		for (const next of graph.get(current) ?? []) {
+			if (!allowedNodes.has(next) || visited.has(next)) continue;
+			visited.add(next);
+			previous.set(next, current);
+			queue.push(next);
+		}
+	}
+	return null;
+}
+function reconstructPath(previous, source, target) {
+	const path = [target];
+	let current = target;
+	while (current !== source) {
+		current = previous.get(current);
+		path.push(current);
+	}
+	return path.reverse();
+}
+function hasSelfReference(graph, node) {
+	return graph.get(node)?.includes(node) ?? false;
+}
+function compareComponents(a, b) {
+	return a[0] < b[0] ? -1 : Number(a[0] > b[0]);
+}
+//#endregion
 //#region src/report/report.ts
 const formatters = {
 	html: HtmlFormatter,
@@ -602,8 +725,9 @@ var Report = class {
 		this.assets[name] = entrypoints;
 	}
 	async generate() {
-		Object.entries(this.assets).filter(([_, entrypoints]) => !!entrypoints).forEach(([path, entrypoints]) => updateOutput(this, path, entrypoints));
+		Object.entries(this.assets).filter(([_, entrypoints]) => entrypoints !== void 0).forEach(([path, entrypoints]) => updateOutput(this, path, entrypoints));
 		this.dependencies = updateDependencies(this);
+		this.issues = updateIssues(this.dependencies, this.connections);
 		const outputs = [];
 		for (const format of this.config.format) {
 			const path = await new formatters[format](this.config).write(this.#getFormattedData());
@@ -625,7 +749,7 @@ var Report = class {
 			resources: sortByKey(this.resources, "name"),
 			connections: this.connections,
 			dependencies: sortByKey(this.dependencies, "name"),
-			issues: this.issues,
+			issues: sortByKey(this.issues, "message"),
 			sourcemaps: this.sourcemaps
 		};
 	}
@@ -733,7 +857,7 @@ function SondaRollupPlugin(userOptions = {}) {
 		},
 		async writeBundle({ dir, file }, bundle) {
 			const outputDir = resolve(process.cwd(), dir ?? dirname(file));
-			for (const [path, asset] of Object.entries(bundle)) report.addAsset(resolve(outputDir, path), asset.type === "chunk" && asset.facadeModuleId ? [asset.facadeModuleId] : void 0);
+			for (const [path, asset] of Object.entries(bundle)) report.addAsset(resolve(outputDir, path), asset.type === "chunk" ? asset.facadeModuleId ? [asset.facadeModuleId] : [] : void 0);
 		},
 		async closeBundle() {
 			const reportPaths = await report.generate();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonda",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Universal bundle analyzer and visualizer that works with most popular bundlers and frameworks.",
   "keywords": [
     "analyzer",