nuxt-layerscope 0.1.3 → 0.1.4

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { a as Context, c as Layer, d as Reference, f as ReferenceKind, g as SourceOption, h as Severity, i as BaselineResult, l as LayerRule, m as RuleName, n as AnalyzeResult, o as Edge, p as ResolutionSource, r as BaselineEntry, s as Finding, t as defineConfig, u as LayerscopeConfig } from "./define-DNRGLVG_.mjs";
-import { t as ProjectConfig } from "./effective-Dqg4EwH_.mjs";
+import { a as Context, c as Layer, d as Reference, f as ReferenceKind, g as SourceOption, h as Severity, i as BaselineResult, l as LayerRule, m as RuleName, n as AnalyzeResult, o as Edge, p as ResolutionSource, r as BaselineEntry, s as Finding, t as defineConfig, u as LayerscopeConfig } from "./define-DDg4HQRH.mjs";
+import { t as ProjectConfig } from "./effective-BPMNHe9A.mjs";
 //#region src/module/index.d.ts
 interface ModuleOptions extends ProjectConfig {
   /** Write `.nuxt/layerscope/registry.json`. Defaults to `true`. */

package/dist/index.mjs

@@ -1,13 +1,15 @@
-import { l as REGISTRY_FILE, p as pickProjectConfig, r as layerFromNuxt } from "./layer-factory-DFh7nkFH.mjs";
-import { t as summarize } from "./summary-DiUYKMPe.mjs";
+import { o as REGISTRY_FILE, r as layerFromNuxt, x as pickProjectConfig } from "./layer-factory-DVSf2Wj4.mjs";
 import { i as plural, t as compareStrings } from "./strings-CrOjNZmB.mjs";
-import { t as packageVersion } from "./version-DFWOUgi5.mjs";
-import { t as globComponents } from "./component-files-DgOXNE6l.mjs";
+import { i as BASELINE_FILE, n as AnalysisCache, t as globComponents } from "./component-files-B_qvkKwv.mjs";
+import { t as summarize } from "./summary-DiUYKMPe.mjs";
+import { t as packageVersion } from "./version-D5JrgoO_.mjs";
 import { t as defineConfig } from "./define-l62B9fVk.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { addDevServerHandler, defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
 import { dirname, isAbsolute, join, relative, resolve } from "pathe";
-import { defineEventHandler, getQuery, setResponseHeader } from "h3";
+import { readdirSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { defineEventHandler, getHeader, getQuery, setResponseHeader, setResponseStatus } from "h3";
 //#region src/module/nuxt.ts
 /** `nitro:init` is typed by Nuxt's Nitro integration, not by `@nuxt/schema`. */
 function onNitroInit(nuxt, handler) {
@@ -18,6 +20,111 @@ function onDevtoolsCustomTabs(nuxt, handler) {
 	nuxt.hook("devtools:customTabs", handler);
 }
 //#endregion
+//#region src/devtools/analyzer.ts
+/** The output the revision tracks; the symbol table and edges are large and derived from it. */
+function fingerprint(result) {
+	return JSON.stringify([
+		result.findings,
+		result.baseline?.suppressed,
+		result.layers.map((layer) => layer.name),
+		result.files.length,
+		result.notes
+	]);
+}
+/** Analyzes lazily, shares one run between concurrent callers, and reuses per-file work. */
+var Analyzer = class {
+	constructor(options) {
+		this.id = randomUUID();
+		this.cache = new AnalysisCache();
+		this.lastFingerprint = "";
+		this.dirty = true;
+		this.options = options;
+	}
+	get current() {
+		return this.snapshot;
+	}
+	/** Marks the snapshot stale; the next `get` re-analyzes. Does no work itself. */
+	invalidate() {
+		this.dirty = true;
+	}
+	async get() {
+		if (this.snapshot !== void 0 && !this.dirty) return this.snapshot;
+		return await (this.inflight ?? this.start());
+	}
+	/** Always analyzes after the call: a run already in flight may predate the request. */
+	async refresh() {
+		if (this.inflight === void 0) return await this.start();
+		this.queued ??= this.afterInflight();
+		return await this.queued;
+	}
+	async afterInflight() {
+		await Promise.allSettled([this.inflight]);
+		this.queued = void 0;
+		return await this.refresh();
+	}
+	async start() {
+		this.inflight = this.analyze().finally(() => {
+			this.inflight = void 0;
+		});
+		return await this.inflight;
+	}
+	async analyze() {
+		this.dirty = false;
+		const started = Date.now();
+		try {
+			const result = await (this.options.run ?? (await import("./analyze-vZUz30sN.mjs")).analyze)({
+				rootDir: this.options.rootDir,
+				baseline: this.options.baseline,
+				cache: this.cache,
+				envKey: await this.options.envKey()
+			});
+			const next = fingerprint(result);
+			const changed = this.snapshot !== void 0 && next !== this.lastFingerprint;
+			this.lastFingerprint = next;
+			this.snapshot = {
+				id: this.id,
+				rev: (this.snapshot?.rev ?? 0) + (changed ? 1 : 0),
+				analyzedAt: Date.now(),
+				durationMs: Date.now() - started,
+				result
+			};
+			return this.snapshot;
+		} catch (error) {
+			this.dirty = true;
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region src/devtools/env-key.ts
+const WATCHED = [
+	"layerscope/registry.json",
+	"imports.d.ts",
+	"components.d.ts",
+	"tsconfig.json",
+	"tsconfig.app.json",
+	"tsconfig.server.json",
+	"tsconfig.shared.json",
+	"types/imports.d.ts",
+	"types/nitro-imports.d.ts",
+	"types/shared-imports.d.ts",
+	"types/components.d.ts"
+];
+const CONFIG_PATTERN = /^(nuxt|layerscope)\.config\./u;
+function stamp(file) {
+	try {
+		const { mtimeMs, size } = statSync(file);
+		return `${file}:${mtimeMs}:${size}`;
+	} catch {
+		return `${file}:missing`;
+	}
+}
+/** Changes when the registry, generated types or config change, which invalidates cached analyses. */
+function computeEnvKey(rootDir, buildDir) {
+	const configs = readdirSync(rootDir).filter((name) => CONFIG_PATTERN.test(name));
+	return [...WATCHED.map((name) => stamp(join(buildDir, name))), ...configs.map((name) => stamp(join(rootDir, name)))].join("|");
+}
+//#endregion
 //#region src/devtools/html.ts
 const ENTITIES = {
 	"&": "&",
@@ -89,7 +196,9 @@ function findingsList(input) {
 function summaryLine(result) {
 	const { errors, warnings } = summarize(result.findings);
 	const source = result.source === "registry" ? "module registry" : "generated .d.ts files";
-	return `${plural(result.files.length, "file")} in ${plural(result.layers.length, "layer")} · ${plural(errors, "error")}, ${plural(warnings, "warning")} · symbols from the ${source}`;
+	const suppressed = result.baseline?.suppressed.length ?? 0;
+	const baseline = suppressed === 0 ? "" : ` · ${suppressed} in baseline`;
+	return `${plural(result.files.length, "file")} in ${plural(result.layers.length, "layer")} · ${plural(errors, "error")}, ${plural(warnings, "warning")}${baseline} · symbols from the ${source}`;
 }
 function document(body) {
 	return `<!doctype html><html><head><meta charset="utf-8"><title>layerscope</title><style>${PAGE_STYLE}</style></head><body>${body}<script>${PAGE_SCRIPT}<\/script></body></html>`;
@@ -103,30 +212,101 @@ function renderError(message) {
 	return document(`<header><h1>layerscope</h1><button data-reload>Re-run</button></header><p class="error-message">${escapeHtml(message)}</p>`);
 }
 //#endregion
-//#region src/devtools/index.ts
-const DEVTOOLS_ROUTE = "/__layerscope";
-async function renderReport(nuxt, format) {
-	const [{ analyze }, { formatResult }] = await Promise.all([import("./analyze-DVzyPH7N.mjs"), import("./report-CKhXT50W.mjs")]);
-	const { rootDir, app } = nuxt.options;
-	const result = await analyze({ rootDir });
-	if (format === "json") return formatResult(result, "json", rootDir);
+//#region src/devtools/handler.ts
+const JSON_TYPE = "application/json";
+const HTML_TYPE = "text/html; charset=utf-8";
+function meta({ rev, analyzedAt, durationMs }) {
+	return {
+		rev,
+		analyzedAt,
+		durationMs
+	};
+}
+async function reportOf(snapshot) {
+	const { formatResult } = await import("./report-DG-XzEq4.mjs");
+	const { rootDir } = snapshot.result;
+	return JSON.parse(formatResult(snapshot.result, "json", rootDir));
+}
+function json(event, status, body) {
+	setResponseStatus(event, status);
+	setResponseHeader(event, "content-type", JSON_TYPE);
+	return JSON.stringify(body);
+}
+async function page(event, input) {
+	const snapshot = await input.analyzer.refresh();
+	if (getQuery(event).format === "json") {
+		setResponseHeader(event, "content-type", JSON_TYPE);
+		return JSON.stringify(await reportOf(snapshot));
+	}
+	setResponseHeader(event, "content-type", HTML_TYPE);
 	return renderPage({
-		result,
-		openInEditor: join("/", app.baseURL, app.buildAssetsDir, "__open-in-editor")
+		result: snapshot.result,
+		openInEditor: input.openInEditor
+	});
+}
+async function withReport(snapshot) {
+	return {
+		...meta(snapshot),
+		report: await reportOf(snapshot)
+	};
+}
+async function api(event, path, input) {
+	if (path === "/api/rerun") return event.method === "POST" ? json(event, 200, await withReport(await input.analyzer.refresh())) : json(event, 405, { error: "Use POST" });
+	if (path !== "/api/state" && path !== "/api/report") return json(event, 404, { error: `Not found: ${path}` });
+	if (event.method !== "GET") return json(event, 405, { error: "Use GET" });
+	const snapshot = await input.analyzer.get();
+	const etag = `"${snapshot.id}-${snapshot.rev}"`;
+	setResponseHeader(event, "etag", etag);
+	setResponseHeader(event, "cache-control", "no-cache");
+	if (getHeader(event, "if-none-match") === etag) {
+		setResponseStatus(event, 304);
+		return "";
+	}
+	return json(event, 200, path === "/api/state" ? {
+		...meta(snapshot),
+		status: "ready"
+	} : await withReport(snapshot));
+}
+/** The DevTools tab, mounted at `/__layerscope`: the page, its JSON report and `/api/*`. */
+function createDevtoolsHandler(input) {
+	return defineEventHandler(async (event) => {
+		const path = event.path.split("?")[0] ?? "/";
+		const isPage = path === "/" || path === "";
+		try {
+			return isPage ? await page(event, input) : await api(event, path, input);
+		} catch (error) {
+			const message = error.message;
+			if (isPage) {
+				setResponseHeader(event, "content-type", HTML_TYPE);
+				return renderError(message);
+			}
+			return json(event, 500, { error: message });
+		}
 	});
 }
+//#endregion
+//#region src/devtools/index.ts
+const DEVTOOLS_ROUTE = "/__layerscope";
 /** A Nuxt DevTools tab with the layer report, served while `nuxi dev` runs. */
 function setupDevtools(nuxt) {
+	const { rootDir, buildDir, app } = nuxt.options;
+	let analyzer;
+	const invalidate = () => analyzer?.invalidate();
+	nuxt.hook("app:templatesGenerated", invalidate);
+	nuxt.hook("builder:watch", invalidate);
+	const openInEditor = join("/", app.baseURL, app.buildAssetsDir, "__open-in-editor");
 	addDevServerHandler({
 		route: DEVTOOLS_ROUTE,
-		handler: defineEventHandler(async (event) => {
-			const { format } = getQuery(event);
-			setResponseHeader(event, "content-type", format === "json" ? "application/json" : "text/html; charset=utf-8");
-			try {
-				return await renderReport(nuxt, format);
-			} catch (error) {
-				return renderError(error.message);
-			}
+		handler: createDevtoolsHandler({
+			get analyzer() {
+				analyzer ??= new Analyzer({
+					rootDir,
+					baseline: BASELINE_FILE,
+					envKey: () => computeEnvKey(rootDir, buildDir)
+				});
+				return analyzer;
+			},
+			openInEditor
 		})
 	});
 	onDevtoolsCustomTabs(nuxt, (tabs) => {