nuxt-layerscope 0.1.2 → 0.1.4

package/dist/eslint.mjs

@@ -1,68 +1,9 @@
-import { d as effectiveConfig, l as REGISTRY_FILE } from "./layer-factory-DFh7nkFH.mjs";
-import { t as packageVersion } from "./version-DFWOUgi5.mjs";
-import { _ as findConfigFile, a as lineColumn, c as createOwnerLookup, d as createAnalysisEnv, f as readRegistry, h as boundaryFindings, i as isCheckedFile, l as nameLayers, o as offsetAt, p as tableFromRegistry, s as scanFile, t as FileAnalysis, y as loadConfigSync } from "./file-analysis-Bh7qcWUK.mjs";
+import { c as FileAnalysis, g as scanFile, h as offsetAt, m as lineColumn, o as REGISTRY_FILE, p as isCheckedFile, y as effectiveConfig } from "./layer-factory-DVSf2Wj4.mjs";
+import { t as packageVersion } from "./version-D5JrgoO_.mjs";
+import { a as readRegistry, c as boundaryFindings, f as loadConfigSync, i as createAnalysisEnv, n as nameLayers, o as tableFromRegistry, t as createOwnerLookup, u as findConfigFile } from "./owner-BA00V9VD.mjs";
 import { dirname, join, relative, resolve } from "pathe";
 import { existsSync, readFileSync, statSync } from "node:fs";
-//#region src/eslint/lint-file.ts
-/** Both rules lint the same text, so the last result per file is reused. */
-const lastLint = /* @__PURE__ */ new Map();
-/**
-* oxlint passes only the `<script>` of a `.vue` file to JS plugins, while the template matters
-* too; the saved file is read instead.
-*/
-function fullSource(file, text) {
-	return file.endsWith(".vue") && !/<(?:script|template)[\s>]/u.test(text) ? readFileSync(file, "utf8") : text;
-}
-/** Lints the text the editor holds, which may differ from the file on disk. */
-function lintFile(file, text, project) {
-	const source = fullSource(file, text);
-	const cached = lastLint.get(file);
-	if (cached?.source === source) return cached.lint;
-	const layer = project.env.ownerOf(file);
-	let lint = {
-		source,
-		boundary: [],
-		unresolved: []
-	};
-	if (layer !== null && isCheckedFile(file, layer, project.config.ignore ?? [])) {
-		const analysis = new FileAnalysis(file, source, layer, project.env).run(scanFile(source, file));
-		lint = {
-			source,
-			boundary: boundaryFindings(analysis.edges, project.config),
-			unresolved: analysis.unresolved
-		};
-	}
-	lastLint.set(file, {
-		source,
-		lint
-	});
-	return lint;
-}
-//#endregion
-//#region src/eslint/location.ts
-/**
-* Maps a finding from the full file into the text the linter passed. ESLint passes the full
-* file; oxlint passes only a `.vue` file's `<script>`, where template findings have no position.
-*/
-function reportLocation(finding, source, text) {
-	if (source === text) return {
-		line: finding.line,
-		column: finding.column,
-		outside: false
-	};
-	const base = source.indexOf(text);
-	const offset = offsetAt(source, finding) - base;
-	if (base === -1 || offset < 0 || offset > text.length) return {
-		line: 1,
-		column: 1,
-		outside: true
-	};
-	return {
-		...lineColumn(text, offset),
-		outside: false
-	};
-}
-//#endregion
+import { createHash } from "node:crypto";
 //#region src/eslint/load-project.ts
 /** Config, layers and symbols of a project, from its registry; Nuxt itself is never loaded. */
 function loadProject(rootDir) {
@@ -98,8 +39,9 @@ function loadProject(rootDir) {
 const DEFAULT_REGISTRY = join(".nuxt", REGISTRY_FILE);
 /** Editors keep the linter running, so a project is reloaded when its inputs change. */
 const cache = /* @__PURE__ */ new Map();
-function findRoot(file) {
-	for (let dir = dirname(file);; dir = dirname(dir)) {
+/** The nearest directory from `startDir` up that holds a registry. */
+function findProjectRoot(startDir) {
+	for (let dir = startDir;; dir = dirname(dir)) {
 		if (existsSync(join(dir, DEFAULT_REGISTRY))) return dir;
 		if (dirname(dir) === dir) return null;
 	}
@@ -119,7 +61,7 @@ function tryLoadProject(rootDir) {
 }
 /** The Nuxt project a linted file belongs to, from its registry; Nuxt itself is never loaded. */
 function projectFor(file, root) {
-	const rootDir = root === void 0 ? findRoot(file) : resolve(root);
+	const rootDir = root === void 0 ? findProjectRoot(dirname(file)) : resolve(root);
 	if (rootDir === null) return {
 		ok: false,
 		message: `No ${DEFAULT_REGISTRY} above this file. Run "nuxi prepare", or set the rule's "root" option to the Nuxt project.`
@@ -137,6 +79,101 @@ function projectFor(file, root) {
 	return load;
 }
 //#endregion
+//#region src/eslint/stamp.ts
+function digest(file) {
+	return file !== null && existsSync(file) ? createHash("sha1").update(readFileSync(file)).digest("hex") : "";
+}
+/**
+* What layerscope's results depend on besides the linted file: the registry and the layer config.
+* ESLint's cache keys a result on the file and the ESLint config only, so this goes into the
+* config, which drops cached results when it changes. Content, not mtime: `nuxi prepare` rewrites
+* an unchanged registry.
+*/
+function projectStamp(cwd = process.cwd()) {
+	const root = findProjectRoot(cwd);
+	if (root === null) return "";
+	const parts = [join(root, DEFAULT_REGISTRY), findConfigFile(root)].map((file) => digest(file));
+	return createHash("sha1").update(parts.join(":")).digest("hex");
+}
+//#endregion
+//#region src/eslint/recommended.ts
+/** Built when `eslint.config.*` loads, so `--cache` sees the stamp of this run. */
+function createRecommended(plugin, cwd) {
+	return {
+		name: "nuxt-layerscope/recommended",
+		plugins: { layerscope: plugin },
+		settings: { layerscope: { stamp: projectStamp(cwd) } },
+		rules: {
+			"layerscope/layer-boundary": "error",
+			"layerscope/unresolved-reference": "warn"
+		}
+	};
+}
+//#endregion
+//#region src/eslint/lint-file.ts
+/**
+* Both rules lint the same text, so the last result per file is reused. A reloaded project
+* (registry or config changed) is another object, so results from before it are not reused.
+*/
+const lastLint = /* @__PURE__ */ new Map();
+/**
+* oxlint passes only the `<script>` of a `.vue` file to JS plugins, while the template matters
+* too; the saved file is read instead.
+*/
+function fullSource(file, text) {
+	return file.endsWith(".vue") && !/<(?:script|template)[\s>]/u.test(text) ? readFileSync(file, "utf8") : text;
+}
+/** Lints the text the editor holds, which may differ from the file on disk. */
+function lintFile(file, text, project) {
+	const source = fullSource(file, text);
+	const cached = lastLint.get(file);
+	if (cached?.project === project && cached.source === source) return cached.lint;
+	const layer = project.env.ownerOf(file);
+	let lint = {
+		source,
+		boundary: [],
+		unresolved: []
+	};
+	if (layer !== null && isCheckedFile(file, layer, project.config.ignore ?? [])) {
+		const analysis = new FileAnalysis(file, source, layer, project.env).run(scanFile(source, file));
+		lint = {
+			source,
+			boundary: boundaryFindings(analysis.edges, project.config),
+			unresolved: analysis.unresolved
+		};
+	}
+	lastLint.set(file, {
+		project,
+		source,
+		lint
+	});
+	return lint;
+}
+//#endregion
+//#region src/eslint/location.ts
+/**
+* Maps a finding from the full file into the text the linter passed. ESLint passes the full
+* file; oxlint passes only a `.vue` file's `<script>`, where template findings have no position.
+*/
+function reportLocation(finding, source, text) {
+	if (source === text) return {
+		line: finding.line,
+		column: finding.column,
+		outside: false
+	};
+	const base = source.indexOf(text);
+	const offset = offsetAt(source, finding) - base;
+	if (base === -1 || offset < 0 || offset > text.length) return {
+		line: 1,
+		column: 1,
+		outside: true
+	};
+	return {
+		...lineColumn(text, offset),
+		outside: false
+	};
+}
+//#endregion
 //#region src/eslint/rules.ts
 const OPTIONS_SCHEMA = [{
 	type: "object",
@@ -201,13 +238,6 @@ const plugin = {
 	rules,
 	configs: {}
 };
-plugin.configs.recommended = {
-	name: "nuxt-layerscope/recommended",
-	plugins: { layerscope: plugin },
-	rules: {
-		"layerscope/layer-boundary": "error",
-		"layerscope/unresolved-reference": "warn"
-	}
-};
+plugin.configs.recommended = createRecommended(plugin);
 //#endregion
 export { plugin as default };

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-DtAi0vPb.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) => {