nuxt-layerscope 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,24 @@
+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";
+//#region src/module/index.d.ts
+interface ModuleOptions extends ProjectConfig {
+  /** Write `.nuxt/layerscope/registry.json`. Defaults to `true`. */
+  enabled: boolean;
+  /** Add a Layerscope tab to Nuxt DevTools while `nuxi dev` runs. Defaults to `true`. */
+  devtools: boolean;
+}
+/**
+ * Records the registry Nuxt resolves (layers, components including overridden ones, app and
+ * server auto-imports) into `.nuxt/layerscope/registry.json` for the `layerscope` CLI.
+ */
+declare const layerscopeModule: import("@nuxt/schema").NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    layerscope?: Partial<ModuleOptions>;
+  }
+  interface NuxtOptions {
+    layerscope: ModuleOptions;
+  }
+}
+//#endregion
+export { type AnalyzeResult, type BaselineEntry, type BaselineResult, type Context, type Edge, type Finding, type Layer, type LayerRule, type LayerscopeConfig, type ModuleOptions, type Reference, type ReferenceKind, type ResolutionSource, type RuleName, type Severity, type SourceOption, layerscopeModule as default, defineConfig };

package/dist/index.mjs

@@ -0,0 +1,364 @@
+import { f as pickProjectConfig, l as REGISTRY_FILE, r as layerFromNuxt } from "./layer-factory-xZmIAPrA.mjs";
+import { t as summarize } from "./summary-DiUYKMPe.mjs";
+import { i as plural, t as compareStrings } from "./strings-CrOjNZmB.mjs";
+import { t as packageVersion } from "./version-D6whhsHH.mjs";
+import { t as globComponents } from "./component-files-DgOXNE6l.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";
+//#region src/module/nuxt.ts
+/** `nitro:init` is typed by Nuxt's Nitro integration, not by `@nuxt/schema`. */
+function onNitroInit(nuxt, handler) {
+	nuxt.hook("nitro:init", handler);
+}
+/** Typed by `@nuxt/devtools`, which the module does not depend on. */
+function onDevtoolsCustomTabs(nuxt, handler) {
+	nuxt.hook("devtools:customTabs", handler);
+}
+//#endregion
+//#region src/devtools/html.ts
+const ENTITIES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml(text) {
+	return text.replaceAll(/[&<>"']/gu, (char) => ENTITIES[char] ?? char);
+}
+//#endregion
+//#region src/devtools/page-assets.ts
+const PAGE_STYLE = `
+:root { color-scheme: light dark; font: 14px/1.5 system-ui, sans-serif; }
+body { margin: 0; padding: 16px 24px; }
+header { display: flex; align-items: center; justify-content: space-between; }
+h1 { font-size: 18px; margin: 0; }
+h2 { font-size: 15px; margin: 24px 0 8px; }
+table { border-collapse: collapse; width: 100%; }
+th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #8884; }
+ul.findings { list-style: none; padding: 0; margin: 0; }
+ul.findings li { padding: 8px 0; border-bottom: 1px solid #8884; }
+.badge { font-size: 12px; padding: 1px 6px; border-radius: 4px; color: #fff; }
+.error .badge { background: #d73a49; }
+.warn .badge { background: #b08800; }
+.rule, .summary, .target { opacity: 0.7; }
+.note, .error-message { padding: 8px; border-radius: 4px; background: #b0880022; }
+.ok { color: #22863a; }
+a { color: inherit; }
+button { cursor: pointer; }
+`;
+const PAGE_SCRIPT = `
+const endpoint = document.getElementById('open-endpoint')?.textContent;
+document.addEventListener('click', event => {
+  const link = event.target.closest('[data-open]');
+  if (link && endpoint) {
+    event.preventDefault();
+    fetch(endpoint + '?file=' + encodeURIComponent(link.dataset.open));
+  }
+  if (event.target.closest('[data-reload]')) {
+    location.reload();
+  }
+});
+`;
+//#endregion
+//#region src/devtools/page.ts
+function fileLink(file, line, column, input) {
+	const label = `${relative(input.result.rootDir, file)}:${line}:${column}`;
+	return `<a href="#" data-open="${escapeHtml(`${file}:${line}:${column}`)}">${escapeHtml(label)}</a>`;
+}
+function layersTable(input) {
+	return `<table><thead><tr><th>Layer</th><th>Root</th><th>May depend on</th></tr></thead><tbody>${input.result.layers.map((layer) => {
+		const allow = input.result.config.layers?.[layer.name]?.allow;
+		const allowed = allow === void 0 ? "<em>unrestricted</em>" : escapeHtml(allow.join(", ") || "—");
+		const root = relative(input.result.rootDir, layer.root) || ".";
+		return `<tr><td>${escapeHtml(layer.name)}</td><td><code>${escapeHtml(root)}</code></td><td>${allowed}</td></tr>`;
+	}).join("")}</tbody></table>`;
+}
+function findingItem(finding, input) {
+	const target = finding.target === null ? "" : `<div class="target">→ ${fileLink(finding.target, 1, 1, input)}</div>`;
+	return `<li class="${finding.severity}"><span class="badge">${finding.severity}</span> ${escapeHtml(finding.message)} <span class="rule">${finding.rule}</span><div>${fileLink(finding.file, finding.line, finding.column, input)}</div>${target}</li>`;
+}
+function findingsList(input) {
+	const { findings } = input.result;
+	if (findings.length === 0) return "<p class=\"ok\">✔ No problems</p>";
+	return `<ul class="findings">${findings.map((finding) => findingItem(finding, input)).join("")}</ul>`;
+}
+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}`;
+}
+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>`;
+}
+/** The DevTools tab: layers, their allowed dependencies and current findings. */
+function renderPage(input) {
+	const notes = input.result.notes.map((note) => `<p class="note">${escapeHtml(note)}</p>`).join("");
+	return document(`<header><h1>layerscope</h1><button data-reload>Re-run</button></header><p class="summary">${summaryLine(input.result)}</p>${notes}<h2>Layers</h2>${layersTable(input)}<h2>Findings</h2>${findingsList(input)}<template id="open-endpoint">${escapeHtml(input.openInEditor)}</template>`);
+}
+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-YePAJEVS.mjs"), import("./report-DtAi0vPb.mjs")]);
+	const { rootDir, app } = nuxt.options;
+	const result = await analyze({ rootDir });
+	if (format === "json") return formatResult(result, "json", rootDir);
+	return renderPage({
+		result,
+		openInEditor: join("/", app.baseURL, app.buildAssetsDir, "__open-in-editor")
+	});
+}
+/** A Nuxt DevTools tab with the layer report, served while `nuxi dev` runs. */
+function setupDevtools(nuxt) {
+	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);
+			}
+		})
+	});
+	onDevtoolsCustomTabs(nuxt, (tabs) => {
+		tabs.push({
+			name: "layerscope",
+			title: "Layerscope",
+			icon: "carbon:flow-connection",
+			view: {
+				type: "iframe",
+				src: DEVTOOLS_ROUTE
+			}
+		});
+	});
+}
+//#endregion
+//#region src/module/collect.ts
+const COMPONENT_IGNORE = ["**/*{M,.m,-m}ixin.{js,ts,jsx,tsx}", "**/*.{d.ts,d.mts,d.cts,d.vue.ts,d.vue.mts,d.vue.cts}"];
+const SHARED_BUILTINS = [
+	{
+		name: "useRuntimeConfig",
+		from: "nuxt"
+	},
+	{
+		name: "useAppConfig",
+		from: "nuxt"
+	},
+	{
+		name: "defineAppConfig",
+		from: "nuxt"
+	},
+	{
+		name: "createError",
+		from: "h3"
+	},
+	{
+		name: "setResponseStatus",
+		from: "h3"
+	}
+];
+const SHARED_BUILTIN_NAMES = new Set(SHARED_BUILTINS.map((entry) => entry.name));
+const SERVER_PLACEHOLDER = "/components/server-placeholder";
+function resolveAlias(path, aliases) {
+	const key = Object.keys(aliases).toSorted((a, b) => b.length - a.length).find((alias) => path === alias || path.startsWith(`${alias}/`));
+	return key === void 0 ? path : aliases[key] + path.slice(key.length);
+}
+function toMode(mode) {
+	return mode === "client" || mode === "server" ? mode : "all";
+}
+function byName(entries) {
+	return entries.toSorted((a, b) => compareStrings(a.name, b.name));
+}
+function importName(entry) {
+	return entry.as ?? entry.name;
+}
+async function activeImports(context) {
+	return (context === null || context === void 0 ? [] : await context.getImports()).filter((entry) => entry.type !== true && entry.disabled !== true);
+}
+function toRegistryImports(imports, aliases) {
+	return byName(imports.map((entry) => {
+		const from = resolveAlias(entry.from, aliases);
+		return {
+			name: importName(entry),
+			from: isAbsolute(from) ? resolve(from) : from
+		};
+	}));
+}
+function withoutDot(extension) {
+	return extension.replace(/^\./u, "");
+}
+/**
+* Records what Nuxt resolves while it prepares or builds the app. Nuxt drops overridden
+* components before `components:extend`, so each component dir's `extendComponent` is wrapped to
+* see every scanned component, including the ones a higher-priority layer replaces.
+*/
+var RegistryCollector = class {
+	constructor(nuxt, config) {
+		this.dirs = [];
+		this.scanned = /* @__PURE__ */ new Map();
+		this.registered = [];
+		this.appImports = null;
+		this.nitro = null;
+		this.config = config;
+		this.nuxt = nuxt;
+	}
+	install() {
+		const { nuxt } = this;
+		nuxt.hook("modules:done", () => {
+			nuxt.hook("components:dirs", (dirs) => {
+				this.wrapDirs(dirs);
+			});
+		});
+		nuxt.hook("components:extend", (components) => {
+			this.registered = components;
+		});
+		nuxt.hook("imports:context", (context) => {
+			this.appImports = context;
+		});
+		onNitroInit(nuxt, (nitro) => {
+			this.nitro = nitro;
+		});
+	}
+	wrapDirs(dirs) {
+		this.dirs = [];
+		for (const [index, entry] of dirs.entries()) {
+			const dir = typeof entry === "string" ? { path: entry } : entry;
+			const extend = dir.extendComponent;
+			dir.extendComponent = async (component) => {
+				const result = (extend === void 0 ? void 0 : await extend(component)) ?? component;
+				this.scanned.set(result.filePath, result);
+				return result;
+			};
+			dirs[index] = dir;
+			this.dirs.push(dir);
+		}
+	}
+	async collect() {
+		const [componentDirs, imports] = await Promise.all([this.componentDirs(), this.imports()]);
+		const layers = this.layers();
+		const components = this.components();
+		return {
+			version: 1,
+			generator: {
+				name: "nuxt-layerscope",
+				version: packageVersion(),
+				nuxt: this.nuxt._version
+			},
+			layers,
+			components,
+			shadowedComponents: this.shadowed(components),
+			componentDirs,
+			imports,
+			...Object.keys(this.config).length > 0 ? { config: this.config } : {}
+		};
+	}
+	layers() {
+		const dirs = getLayerDirectories(this.nuxt);
+		return this.nuxt.options._layers.map((layer, index) => layerFromNuxt(layer, index, dirs[index]));
+	}
+	toFile(path) {
+		const file = resolveAlias(path, this.nuxt.options.alias);
+		return isAbsolute(file) ? resolve(file) : file;
+	}
+	toComponent(component) {
+		return {
+			name: component.pascalName,
+			file: this.toFile(component.filePath),
+			mode: toMode(component.mode),
+			island: component.island === true,
+			priority: component.priority ?? 0
+		};
+	}
+	components() {
+		return this.registered.filter((component) => !component.filePath.includes(SERVER_PLACEHOLDER)).map((component) => this.toComponent(component));
+	}
+	shadowed(registered) {
+		const files = new Set(registered.map((component) => component.file));
+		return [...this.scanned.values()].map((component) => this.toComponent(component)).filter((component) => !files.has(component.file)).flatMap((component) => {
+			const winner = registered.find((other) => other.name === component.name && (other.mode === "all" || component.mode === "all" || other.mode === component.mode));
+			return winner === void 0 ? [] : [{
+				...component,
+				shadowedBy: winner.file
+			}];
+		}).toSorted((a, b) => compareStrings(a.file, b.file));
+	}
+	async componentDirs() {
+		const { alias, extensions } = this.nuxt.options;
+		const jobs = this.dirs.map(async (dir) => {
+			const path = resolve(resolveAlias(dir.path, alias));
+			const exts = (dir.extensions ?? extensions).map((ext) => withoutDot(ext));
+			const pattern = dir.pattern ?? (exts.length > 1 ? `**/*.{${exts.join(",")}}` : `**/*.${exts[0] ?? "*"}`);
+			const ignore = [...COMPONENT_IGNORE, ...dir.ignore ?? []];
+			return {
+				path,
+				pattern,
+				ignore,
+				files: path.includes("/node_modules/") ? [] : await globComponents(path, pattern, ignore)
+			};
+		});
+		return await Promise.all(jobs);
+	}
+	async imports() {
+		const serverContext = this.nitro?.unimport;
+		await serverContext?.init?.();
+		const app = await activeImports(this.appImports);
+		const server = await activeImports(serverContext);
+		const serverFrom = new Map(server.map((entry) => [importName(entry), entry.from]));
+		const shared = app.filter((entry) => !SHARED_BUILTIN_NAMES.has(importName(entry)) && serverFrom.get(importName(entry)) === entry.from);
+		const nuxtAliases = this.nuxt.options.alias;
+		const serverAliases = {
+			...nuxtAliases,
+			...this.nitro?.options.alias
+		};
+		return {
+			app: toRegistryImports(app, nuxtAliases),
+			server: toRegistryImports(server, serverAliases),
+			shared: byName([...SHARED_BUILTINS, ...toRegistryImports(shared, nuxtAliases)])
+		};
+	}
+};
+//#endregion
+//#region src/module/index.ts
+async function writeRegistry(collector, buildDir) {
+	const file = join(buildDir, REGISTRY_FILE);
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, `${JSON.stringify(await collector.collect(), null, 2)}\n`);
+}
+//#endregion
+//#region src/index.ts
+var src_default = defineNuxtModule({
+	meta: {
+		name: "nuxt-layerscope",
+		configKey: "layerscope",
+		version: packageVersion(),
+		compatibility: { nuxt: ">=3.12.0" }
+	},
+	defaults: {
+		enabled: true,
+		devtools: true
+	},
+	setup(options, nuxt) {
+		if (!options.enabled) return;
+		const collector = new RegistryCollector(nuxt, pickProjectConfig(options));
+		collector.install();
+		const write = async () => {
+			await writeRegistry(collector, nuxt.options.buildDir);
+		};
+		nuxt.hook("prepare:types", write);
+		if (nuxt.options.dev) {
+			nuxt.hook("app:templatesGenerated", write);
+			if (options.devtools) setupDevtools(nuxt);
+		}
+	}
+});
+//#endregion
+export { src_default as default, defineConfig };

package/dist/layer-factory-xZmIAPrA.mjs

@@ -0,0 +1,168 @@
+import { basename, dirname, join, resolve } from "pathe";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+//#region src/errors.ts
+/** A config or input problem; the CLI exits with code 2. */
+var LayerscopeError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "LayerscopeError";
+	}
+};
+//#endregion
+//#region src/config/rules.ts
+const DEFAULT_SEVERITY = {
+	"layer-boundary": "error",
+	"unresolved-reference": "warn",
+	"shadowed-component": "warn"
+};
+/** Accepted in config for forward compatibility; not implemented yet. */
+const RESERVED_RULES = /* @__PURE__ */ new Set(["unused-symbol"]);
+const SEVERITIES = /* @__PURE__ */ new Set([
+	"off",
+	"warn",
+	"error"
+]);
+function isRuleName(name) {
+	return Object.hasOwn(DEFAULT_SEVERITY, name);
+}
+function ruleSeverity(config, rule) {
+	return config.rules?.[rule] ?? DEFAULT_SEVERITY[rule];
+}
+//#endregion
+//#region src/config/validate.ts
+function validateConfig(config, file) {
+	for (const [rule, severity] of Object.entries(config.rules ?? {})) {
+		if (!isRuleName(rule) && !RESERVED_RULES.has(rule)) throw new LayerscopeError(`${file}: unknown rule "${rule}"`);
+		if (!SEVERITIES.has(String(severity))) throw new LayerscopeError(`${file}: rule "${rule}" must be "off", "warn" or "error", got ${JSON.stringify(severity)}`);
+	}
+	for (const [name, layer] of Object.entries(config.layers ?? {})) {
+		if (layer.allow !== void 0 && !Array.isArray(layer.allow)) throw new LayerscopeError(`${file}: layers.${name}.allow must be an array of layer names`);
+		if (layer.path !== void 0 && layer.source !== void 0) throw new LayerscopeError(`${file}: layers.${name} sets both "path" and "source"; use one`);
+	}
+}
+//#endregion
+//#region src/config/effective.ts
+/** Where the module's options live when they come from `nuxt.config`. */
+const NUXT_CONFIG_LABEL = "nuxt.config (layerscope)";
+/** The keys that describe the project; `buildDir` only says where to look. */
+const PROJECT_CONFIG_KEYS = [
+	"layers",
+	"rules",
+	"ignore",
+	"globals"
+];
+function hasProjectConfig(config) {
+	return PROJECT_CONFIG_KEYS.some((key) => config[key] !== void 0);
+}
+function pickProjectConfig(config) {
+	return Object.fromEntries(PROJECT_CONFIG_KEYS.flatMap((key) => config[key] === void 0 ? [] : [[key, config[key]]]));
+}
+/**
+* `layerscope.config.*` or the `layerscope` key of `nuxt.config`, which the module records in the
+* registry. Both at once is an error rather than a merge, so it is always clear which one applies.
+*/
+function effectiveConfig(fileConfig, recorded) {
+	if (recorded === void 0 || !hasProjectConfig(recorded)) return fileConfig;
+	if (hasProjectConfig(fileConfig)) throw new LayerscopeError("Layers or rules are set both in layerscope.config and in the \"layerscope\" key of nuxt.config. Keep one.");
+	validateConfig(recorded, NUXT_CONFIG_LABEL);
+	return {
+		...fileConfig,
+		...recorded
+	};
+}
+//#endregion
+//#region src/registry/schema.ts
+/** Bumped on breaking changes to `registry.json`; readers fall back to the `.d.ts` files. */
+const REGISTRY_VERSION = 1;
+/** Relative to the Nuxt build dir. */
+const REGISTRY_FILE = "layerscope/registry.json";
+//#endregion
+//#region src/utils/fs.ts
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function readJson(path) {
+	return JSON.parse(readFileSync(path, "utf8").replaceAll(/^\s*\/\/.*$/gmu, ""));
+}
+/** Symlinks resolved (pnpm links packages), or the path itself when it does not exist. */
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+//#endregion
+//#region src/nuxt/remote-layer.ts
+/** c12 clones remote layers into `node_modules/.c12`, or into `~/.cache/c12` without one. */
+const CLONE_DIRS = /* @__PURE__ */ new Set([".c12", "c12"]);
+/**
+* c12 names a clone after the first three word segments of its `extends` source plus a hash of
+* the whole source (`github:org/repo#v1` → `github_org_repo_<hash>`). The hash changes with the
+* ref, so names and config matching use the prefix only.
+*/
+function clonePrefix(source) {
+	return source.replaceAll(/\W+/gu, "_").split("_").slice(0, 3).join("_");
+}
+/** The clone name without its hash, so it survives ref changes; `null` for other layers. */
+function remoteLayerName(root) {
+	if (!CLONE_DIRS.has(basename(dirname(root)))) return null;
+	const name = basename(root);
+	const hashStart = name.lastIndexOf("_");
+	return hashStart === -1 ? name : name.slice(0, hashStart);
+}
+/** Whether the layer at `root` was cloned from this `extends` source. */
+function isClonedFrom(root, source) {
+	return remoteLayerName(root) === clonePrefix(source);
+}
+//#endregion
+//#region src/nuxt/layer-factory.ts
+const ROOT_LAYER_NAME = "root";
+/** Fallback for `@nuxt/kit` releases without `getLayerDirectories`. */
+function deriveDirectories(layer, index, options) {
+	const root = resolve(layer.config.rootDir ?? layer.cwd);
+	return {
+		root,
+		app: resolve(root, layer.config.srcDir ?? "."),
+		server: index === 0 && options.serverDir !== void 0 ? resolve(options.serverDir) : resolve(root, layer.config.serverDir ?? "server"),
+		shared: resolve(root, layer.config.dir?.shared ?? options.dir?.shared ?? "shared")
+	};
+}
+/** Real paths, so they match symlinked paths in generated types and imports. */
+function toDirs(dirs) {
+	const dir = (path) => realPath(resolve(path));
+	return {
+		root: dir(dirs.root),
+		srcDir: dir(dirs.app),
+		serverDir: dir(dirs.server),
+		sharedDir: dir(dirs.shared)
+	};
+}
+function layerFromNuxt(layer, index, dirs) {
+	const resolved = toDirs(dirs);
+	return {
+		name: layer.meta?.name ?? layer.config.$meta?.name ?? (index === 0 ? "root" : remoteLayerName(resolved.root) ?? basename(resolved.root)),
+		...resolved,
+		defaultComponents: layer.config.components === void 0
+	};
+}
+/** Without @nuxt/kit, assume Nuxt defaults: `app/` as srcDir when it exists (Nuxt 4). */
+function layerFromPath(name, root) {
+	const appDir = join(root, "app");
+	return {
+		name,
+		...toDirs({
+			root,
+			app: existsSync(appDir) ? appDir : root,
+			server: join(root, "server"),
+			shared: join(root, "shared")
+		}),
+		defaultComponents: true
+	};
+}
+//#endregion
+export { isClonedFrom as a, realPath as c, effectiveConfig as d, pickProjectConfig as f, LayerscopeError as g, ruleSeverity as h, layerFromPath as i, REGISTRY_FILE as l, isRuleName as m, deriveDirectories as n, isFile as o, validateConfig as p, layerFromNuxt as r, readJson as s, ROOT_LAYER_NAME as t, REGISTRY_VERSION as u };

package/dist/report-BNW0GCl9.mjs

@@ -0,0 +1,131 @@
+import { t as summarize } from "./summary-DiUYKMPe.mjs";
+import { i as plural } from "./strings-CrOjNZmB.mjs";
+import { relative } from "pathe";
+//#region src/report/baseline.ts
+/** `layer-boundary useCart → web (×2)` */
+function describeEntry(entry) {
+	const target = entry.toLayer === null ? "" : ` → ${entry.toLayer}`;
+	const count = (entry.count ?? 1) > 1 ? ` (×${entry.count})` : "";
+	return `${entry.rule} ${entry.symbol}${target}${count}`;
+}
+const UPDATE_HINT = "Run \"layerscope check --update-baseline\" to remove";
+//#endregion
+//#region src/report/details.ts
+/** Where the symbol resolves to and what the layer may use, so the fix is obvious. */
+function findingDetails(finding, cwd) {
+	const details = [];
+	if (finding.target !== null) details.push(`${finding.symbol} → ${relative(cwd, finding.target)}`);
+	if (finding.allowed !== void 0) {
+		const allowed = finding.allowed.length > 0 ? finding.allowed.join(", ") : "no other layers";
+		details.push(`allowed for "${finding.fromLayer}": ${allowed}`);
+	}
+	return details;
+}
+//#endregion
+//#region src/report/github.ts
+function escapeData(value) {
+	return value.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function escapeProperty(value) {
+	return escapeData(value).replaceAll(":", "%3A").replaceAll(",", "%2C");
+}
+function formatAnnotation(finding, cwd) {
+	return `::${finding.severity === "error" ? "error" : "warning"} ${[
+		`file=${escapeProperty(relative(cwd, finding.file))}`,
+		`line=${finding.line}`,
+		`col=${finding.column}`,
+		`title=${escapeProperty(`layerscope ${finding.rule}`)}`
+	].join(",")}::${escapeData([finding.message, ...findingDetails(finding, cwd)].join("\n"))}\n`;
+}
+function formatRemovable$1(entry, file) {
+	const message = `Fixed baseline entry in ${entry.file}: ${describeEntry(entry)}. ${UPDATE_HINT} it.`;
+	return `::notice file=${escapeProperty(file)},title=layerscope baseline::${escapeData(message)}\n`;
+}
+/** Workflow commands that GitHub shows inline on the pull request diff. */
+function formatGithub(result, cwd) {
+	const annotations = result.findings.map((finding) => formatAnnotation(finding, cwd));
+	const { baseline } = result;
+	const removable = baseline === void 0 ? [] : baseline.removable.map((entry) => formatRemovable$1(entry, relative(cwd, baseline.file)));
+	return [...annotations, ...removable].join("");
+}
+//#endregion
+//#region src/report/json.ts
+/** Bumped on breaking changes to the JSON report shape. */
+const JSON_REPORT_VERSION = 1;
+function relativeFinding(finding, cwd) {
+	return {
+		...finding,
+		file: relative(cwd, finding.file),
+		target: finding.target === null ? null : relative(cwd, finding.target)
+	};
+}
+function formatBaseline(baseline, cwd) {
+	return {
+		file: relative(cwd, baseline.file),
+		suppressed: baseline.suppressed.map((finding) => relativeFinding(finding, cwd)),
+		removable: baseline.removable
+	};
+}
+function formatJson(result, cwd) {
+	const report = {
+		version: 1,
+		source: result.source,
+		notes: result.notes,
+		layers: result.layers.map((layer) => ({
+			name: layer.name,
+			root: relative(cwd, layer.root) || "."
+		})),
+		summary: {
+			files: result.files.length,
+			...summarize(result.findings)
+		},
+		findings: result.findings.map((finding) => relativeFinding(finding, cwd)),
+		...result.baseline === void 0 ? {} : { baseline: formatBaseline(result.baseline, cwd) }
+	};
+	return `${JSON.stringify(report, null, 2)}\n`;
+}
+//#endregion
+//#region src/report/text.ts
+const DETAIL_INDENT = " ".repeat(17);
+function formatFinding(finding, cwd) {
+	return [`  ${`${finding.line}:${finding.column}`.padEnd(8)}${finding.severity.padEnd(7)}${finding.message}  ${finding.rule}`, ...findingDetails(finding, cwd).map((detail) => `${DETAIL_INDENT}${detail}`)].join("\n");
+}
+function formatRemovable(baseline, cwd) {
+	if (baseline.removable.length === 0) return null;
+	const entries = baseline.removable.map((entry) => `  ${entry.file}  ${describeEntry(entry)}`);
+	const count = baseline.removable.length;
+	return [`${relative(cwd, baseline.file)}: ${plural(count, "fixed entry", "fixed entries")}. ${UPDATE_HINT} ${count === 1 ? "it" : "them"}.`, ...entries].join("\n");
+}
+function formatFooter(result) {
+	const suppressed = result.baseline?.suppressed.length ?? 0;
+	const baselined = suppressed > 0 ? `, ${suppressed} more in the baseline` : "";
+	if (result.findings.length === 0) return `✔ No problems in ${plural(result.files.length, "file")} across ${plural(result.layers.length, "layer")}${baselined}`;
+	const { errors, warnings } = summarize(result.findings);
+	return `✖ ${plural(result.findings.length, "problem")} (${plural(errors, "error")}, ${plural(warnings, "warning")})${baselined}`;
+}
+function formatText(result, cwd) {
+	const sections = [...Map.groupBy(result.findings, (finding) => relative(cwd, finding.file))].map(([file, findings]) => [file, ...findings.map((finding) => formatFinding(finding, cwd))].join("\n"));
+	const removable = result.baseline === void 0 ? null : formatRemovable(result.baseline, cwd);
+	return `${[...removable === null ? sections : [...sections, removable], formatFooter(result)].join("\n\n")}\n`;
+}
+//#endregion
+//#region src/report/index.ts
+const OUTPUT_FORMATS = [
+	"text",
+	"github",
+	"json"
+];
+const formatters = {
+	text: formatText,
+	github: formatGithub,
+	json: formatJson
+};
+function isOutputFormat(value) {
+	return Object.hasOwn(formatters, value);
+}
+/** Paths in the output are relative to `cwd`. */
+function formatResult(result, format, cwd = process.cwd()) {
+	return formatters[format](result, cwd);
+}
+//#endregion
+export { JSON_REPORT_VERSION as i, formatResult as n, isOutputFormat as r, OUTPUT_FORMATS as t };