sonda 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,12 +1,11 @@
 import { styleText } from "util";
 import { access, mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { basename, dirname, extname, format, join, parse, posix, relative, resolve, win32 } from "path";
+import { basename, dirname, extname, format, isAbsolute, join, parse, posix, relative, resolve, win32 } from "path";
 import { isBuiltin } from "module";
-import open from "open";
+import open from "tiny-open";
 import { fileURLToPath } from "url";
 import { brotliCompressSync, gzipSync } from "zlib";
-import { readFileSync } from "fs";
-import { loadCodeAndMap } from "load-source-map";
+import { existsSync, readFileSync, statSync } from "fs";
 import remapping from "@jridgewell/remapping";
 //#region src/config.ts
 var Config = class Config {
@@ -169,7 +168,7 @@ function hasIgnoredExtension(name) {
 }
 //#endregion
 //#region package.json
-var version = "0.12.0";
+var version = "0.13.0";
 //#endregion
 //#region src/report/formatters/Formatter.ts
 var Formatter = class {
@@ -230,6 +229,108 @@ var JsonFormatter = class extends Formatter {
 	}
 };
 //#endregion
+//#region ../load-source-map/dist/index.js
+/**
+* Strip any JSON XSSI avoidance prefix from the string (as documented in the source maps specification),
+* and parses the string as JSON.
+*
+* https://github.com/mozilla/source-map/blob/3cb92cc3b73bfab27c146bae4ef2bc09dbb4e5ed/lib/util.js#L162-L164
+*/
+function parseSourceMapInput(str) {
+	return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+}
+/**
+sourceMappingURL=data:application/json;charset=utf-8;base64,data
+sourceMappingURL=data:application/json;base64,data
+sourceMappingURL=data:application/json;uri,data
+sourceMappingURL=map-file-comment.css.map
+sourceMappingURL=map-file-comment.css.map?query=value
+*/
+const sourceMappingRegExp = /[@#]\s*sourceMappingURL=(\S+)\b/g;
+/**
+* Checks if the given path is a file.
+*/
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Default path normalizer that resolves the path relative to the source root.
+*/
+function defaultPathNormalizer(path, sourceRoot) {
+	return isAbsolute(path) ? path : resolve(sourceRoot, path);
+}
+function loadCodeAndMap(codePath, sourcesPathNormalizer) {
+	if (!isFile(codePath)) return null;
+	const code = readFileSync(codePath, "utf-8");
+	const maybeMap = loadMap(codePath, code);
+	if (!maybeMap) return { code };
+	const { map, mapPath } = maybeMap;
+	const sourceRoot = resolve(dirname(mapPath), map.sourceRoot ?? ".");
+	const normalizer = sourcesPathNormalizer || defaultPathNormalizer;
+	map.sources = map.sources.map((source) => source && normalizer(source, sourceRoot));
+	map.sourcesContent = loadMissingSourcesContent(map);
+	delete map.sourceRoot;
+	return {
+		code,
+		map
+	};
+}
+function loadMap(codePath, code) {
+	/**
+	* Because in most cases the source map has the same name as the code file,
+	* we can try to append `.map` to the code path and check if the file exists.
+	*/
+	try {
+		const possibleMapPath = codePath + ".map";
+		return {
+			map: parseSourceMapInput(readFileSync(possibleMapPath, "utf-8")),
+			mapPath: possibleMapPath
+		};
+	} catch {}
+	/**
+	* If the source map is not found by file name, we can try to extract it from the code.
+	* The path to the source map is usually in a comment at the end of the file, but it can
+	* also be inlined in the code itself.
+	*/
+	const extractedComment = code.includes("sourceMappingURL") && Array.from(code.matchAll(sourceMappingRegExp)).at(-1);
+	if (!extractedComment || !extractedComment.length) return null;
+	const sourceMappingURL = extractedComment[1];
+	if (sourceMappingURL.startsWith("data:")) return {
+		map: parseSourceMapInput(parseDataUrl(sourceMappingURL)),
+		mapPath: codePath
+	};
+	const sourceMapFilename = new URL(sourceMappingURL, "file://").pathname;
+	const mapPath = join(dirname(codePath), sourceMapFilename);
+	if (!existsSync(mapPath)) return null;
+	return {
+		map: parseSourceMapInput(readFileSync(mapPath, "utf-8")),
+		mapPath
+	};
+}
+function parseDataUrl(url) {
+	const [prefix, payload] = url.split(",");
+	const encoding = prefix.split(";").at(-1);
+	switch (encoding) {
+		case "base64": return Buffer.from(payload, "base64").toString();
+		case "uri": return decodeURIComponent(payload);
+		default: throw new Error("Unsupported source map encoding: " + encoding);
+	}
+}
+/**
+* Loop through the sources and try to load missing `sourcesContent` from the file system.
+*/
+function loadMissingSourcesContent(map) {
+	return map.sources.map((source, index) => {
+		if (map.sourcesContent?.[index]) return map.sourcesContent[index];
+		if (source && existsSync(source)) return readFileSync(source, "utf-8");
+		return null;
+	});
+}
+//#endregion
 //#region src/report/processors/sourcemap.ts
 const UNASSIGNED = "[unassigned]";
 function getBytesPerSource(code, map, assetSizes, config) {
@@ -586,10 +687,16 @@ function SondaRollupPlugin(userOptions = {}) {
 	const options = new Config(userOptions, { integration: "rollup" });
 	if (!options.enabled) return { name: "sonda/rollup" };
 	const report = new Report(options);
+	const dynamicImportSources = /* @__PURE__ */ new Set();
 	return {
 		name: "sonda/rollup",
+		resolveDynamicImport(specifier, importer) {
+			if (typeof specifier === "string") dynamicImportSources.add(connectionKey(importer, specifier));
+			return null;
+		},
 		async resolveId(source, importer, options) {
 			if (!importer) return;
+			if (dynamicImportSources.has(connectionKey(importer, source))) return;
 			const resolved = await this.resolve(source, importer, {
 				...options,
 				skipSelf: true
@@ -612,6 +719,18 @@ function SondaRollupPlugin(userOptions = {}) {
 				uncompressed: module.code ? Buffer.byteLength(module.code) : 0
 			});
 		},
+		buildEnd() {
+			for (const id of this.getModuleIds()) {
+				const module = this.getModuleInfo(id);
+				if (!module) continue;
+				for (const target of module.dynamicallyImportedIds) report.addConnection({
+					kind: "dynamic-import",
+					source: normalizePath(module.id),
+					target: normalizePath(target),
+					original: null
+				});
+			}
+		},
 		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);
@@ -622,6 +741,9 @@ function SondaRollupPlugin(userOptions = {}) {
 		}
 	};
 }
+function connectionKey(importer, source) {
+	return `${importer}\0${source}`;
+}
 function getModuleFormat(name, module) {
 	if (getTypeByName(name) !== "script") return "other";
 	const ext = extname(module.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonda",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Universal bundle analyzer and visualizer that works with most popular bundlers and frameworks.",
   "keywords": [
     "analyzer",
@@ -91,9 +91,24 @@
   },
   "dependencies": {
     "@jridgewell/remapping": "^2.3.5",
-    "open": "^11.0.0"
+    "tiny-open": "^1.3.0"
   },
   "engines": {
     "node": ">=22.12"
+  },
+  "compatiblePackages": {
+    "schemaVersion": 1,
+    "vite": {
+      "type": "compatible",
+      "versions": "^7.0.0 || ^8.0.0"
+    },
+    "rollup": {
+      "type": "compatible",
+      "versions": "^4.0.0"
+    },
+    "rolldown": {
+      "type": "compatible",
+      "versions": "^1.0.0"
+    }
   }
 }