nuxt-layerscope 0.1.0

package/dist/report-DtAi0vPb.mjs

@@ -0,0 +1,2 @@
+import { n as formatResult, r as isOutputFormat, t as OUTPUT_FORMATS } from "./report-BNW0GCl9.mjs";
+export { OUTPUT_FORMATS, formatResult, isOutputFormat };

package/dist/strings-CrOjNZmB.mjs

@@ -0,0 +1,17 @@
+//#region src/utils/strings.ts
+function pascalCase(name) {
+	const camel = name.replaceAll(/-(\w)/gu, (_, c) => c.toUpperCase());
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function escapeRegExp(text) {
+	return text.replaceAll(/[$()*+.?[\\\]^{|}]/gu, "\\$&");
+}
+function plural(count, word, many = `${word}s`) {
+	return `${count} ${count === 1 ? word : many}`;
+}
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+}
+//#endregion
+export { plural as i, escapeRegExp as n, pascalCase as r, compareStrings as t };

package/dist/summary-DiUYKMPe.mjs

@@ -0,0 +1,10 @@
+//#region src/report/summary.ts
+function summarize(findings) {
+	const errors = findings.filter((finding) => finding.severity === "error").length;
+	return {
+		errors,
+		warnings: findings.length - errors
+	};
+}
+//#endregion
+export { summarize as t };

package/dist/unused-Dxep1p6u.mjs

@@ -0,0 +1,164 @@
+import { t as compareStrings } from "./strings-CrOjNZmB.mjs";
+import { c as createOwnerLookup, g as isAllowed } from "./file-analysis-Bkq_69x4.mjs";
+import { relative } from "pathe";
+//#region src/rules/edge-status.ts
+/** How the layer rules see one edge. */
+function edgeStatus(edge, config) {
+	if (edge.toLayer === null) return "external";
+	if (edge.toLayer === edge.fromLayer) return "same-layer";
+	const allow = config.layers?.[edge.fromLayer]?.allow;
+	if (allow === void 0) return "unrestricted";
+	return isAllowed(edge, allow) ? "allowed" : "not-allowed";
+}
+//#endregion
+//#region src/graph/index.ts
+const GRAPH_LEVELS = ["layer", "file"];
+const STATUS_ORDER = [
+	"not-allowed",
+	"allowed",
+	"unrestricted",
+	"same-layer"
+];
+function worse(a, b) {
+	return STATUS_ORDER.indexOf(a) <= STATUS_ORDER.indexOf(b) ? a : b;
+}
+function endpoints(edge, level, rootDir) {
+	if (edge.toLayer === null || edge.to === null) return null;
+	if (level === "layer") return edge.toLayer === edge.fromLayer ? null : [edge.fromLayer, edge.toLayer];
+	const from = relative(rootDir, edge.file);
+	const to = relative(rootDir, edge.to);
+	return from === to ? null : [from, to];
+}
+function collectNodes(result, edges, level) {
+	if (level === "layer") return result.layers.map((layer) => ({
+		id: layer.name,
+		layer: layer.name
+	}));
+	const layerByFile = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		layerByFile.set(relative(result.rootDir, edge.file), edge.fromLayer);
+		if (edge.to !== null && edge.toLayer !== null) layerByFile.set(relative(result.rootDir, edge.to), edge.toLayer);
+	}
+	return [...layerByFile].map(([id, layer]) => ({
+		id,
+		layer
+	})).toSorted((a, b) => compareStrings(a.id, b.id));
+}
+/** Dependencies between layers or files inside layers; packages are left out. */
+function buildGraph(result, config, level) {
+	const edges = /* @__PURE__ */ new Map();
+	const internal = [];
+	for (const edge of result.edges) {
+		const ends = endpoints(edge, level, result.rootDir);
+		if (ends === null) continue;
+		internal.push(edge);
+		const [from, to] = ends;
+		const key = `${from}\0${to}`;
+		const status = edgeStatus(edge, config);
+		const existing = edges.get(key);
+		edges.set(key, existing === void 0 ? {
+			from,
+			to,
+			count: 1,
+			status
+		} : {
+			...existing,
+			count: existing.count + 1,
+			status: worse(existing.status, status)
+		});
+	}
+	return {
+		level,
+		nodes: collectNodes(result, internal, level),
+		edges: [...edges.values()].toSorted((a, b) => compareStrings(a.from, b.from) || compareStrings(a.to, b.to))
+	};
+}
+//#endregion
+//#region src/unused/index.ts
+const CONTEXTS = [
+	"app",
+	"server",
+	"shared"
+];
+const VIRTUAL_IMPORT = /^#(?:imports|components):(.+)$/u;
+function symbolKey(file, name) {
+	return `${file}\0${name}`;
+}
+function collectUses(edges) {
+	const uses = {
+		files: /* @__PURE__ */ new Set(),
+		symbols: /* @__PURE__ */ new Set()
+	};
+	for (const edge of edges) {
+		if (edge.to === null) continue;
+		const virtual = VIRTUAL_IMPORT.exec(edge.symbol);
+		if (edge.kind === "import" && virtual === null) uses.files.add(edge.to);
+		else uses.symbols.add(symbolKey(edge.to, virtual?.[1] ?? edge.symbol));
+	}
+	return uses;
+}
+function isUsed(uses, file, names) {
+	return uses.files.has(file) || names.some((name) => uses.symbols.has(symbolKey(file, name)));
+}
+/** Component names by file; `BaseButton` and `LazyBaseButton` are one component. */
+function componentsByFile(components) {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const [name, target] of components) if (target.file !== null) byFile.set(target.file, [...byFile.get(target.file) ?? [], name]);
+	return byFile;
+}
+function shortestName(names) {
+	return names.toSorted((a, b) => a.length - b.length || compareStrings(a, b))[0];
+}
+/**
+* Components and auto-imports registered by the project's own layers that nothing references.
+* Layers installed as packages are not checked, so their symbols are never reported.
+*/
+function findUnused(result) {
+	const ownerOf = createOwnerLookup(result.layers);
+	const checked = (target) => {
+		const layer = target.file === null ? null : ownerOf(target.file);
+		return layer === null || layer.root.includes("/node_modules/") ? null : layer.name;
+	};
+	const uses = collectUses(result.edges);
+	const possiblyUsed = result.dynamicComponentFiles.length > 0;
+	const unused = [];
+	for (const [file, names] of componentsByFile(result.symbols.components)) {
+		const layer = checked({
+			file,
+			module: null
+		});
+		if (layer !== null && !isUsed(uses, file, names)) {
+			const name = shortestName(names);
+			unused.push({
+				name,
+				kind: "component",
+				context: null,
+				file,
+				layer,
+				possiblyUsed
+			});
+		}
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const context of CONTEXTS) for (const [name, target] of result.symbols.imports[context]) {
+		const layer = checked(target);
+		const key = target.file === null ? "" : symbolKey(target.file, name);
+		if (layer === null || target.file === null || seen.has(key)) continue;
+		seen.add(key);
+		if (!isUsed(uses, target.file, [name])) {
+			const { file } = target;
+			unused.push({
+				name,
+				kind: "auto-import",
+				context,
+				file,
+				layer,
+				possiblyUsed: false
+			});
+		}
+	}
+	const order = new Map(result.layers.map((layer, index) => [layer.name, index]));
+	return unused.toSorted((a, b) => (order.get(a.layer) ?? 0) - (order.get(b.layer) ?? 0) || compareStrings(a.file, b.file) || compareStrings(a.name, b.name));
+}
+//#endregion
+export { edgeStatus as i, GRAPH_LEVELS as n, buildGraph as r, findUnused as t };

package/dist/version-D6whhsHH.mjs

@@ -0,0 +1,9 @@
+import { s as readJson } from "./layer-factory-xZmIAPrA.mjs";
+import { fileURLToPath } from "node:url";
+//#region src/version.ts
+/** Both `src/` and the bundled `dist/` sit next to package.json. */
+function packageVersion() {
+	return readJson(fileURLToPath(new URL("../package.json", import.meta.url))).version ?? "0.0.0";
+}
+//#endregion
+export { packageVersion as t };

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "nuxt-layerscope",
+  "version": "0.1.0",
+  "description": "Layer boundary checks for Nuxt apps that see auto-imports",
+  "keywords": [
+    "architecture",
+    "auto-imports",
+    "boundaries",
+    "cli",
+    "lint",
+    "nuxt",
+    "nuxt-layers",
+    "nuxt-module"
+  ],
+  "homepage": "https://github.com/hamedniroomand/nuxt-layerscope/tree/main/packages/layerscope#readme",
+  "bugs": "https://github.com/hamedniroomand/nuxt-layerscope/issues",
+  "license": "MIT",
+  "author": "Hamed Niroomand",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hamedniroomand/nuxt-layerscope.git",
+    "directory": "packages/layerscope"
+  },
+  "bin": {
+    "layerscope": "./dist/bin.mjs"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "imports": {
+    "#src/*": "./src/*",
+    "#test/*": "./test/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./api": {
+      "types": "./dist/api.d.mts",
+      "default": "./dist/api.mjs"
+    },
+    "./eslint": {
+      "types": "./dist/eslint.d.mts",
+      "default": "./dist/eslint.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.5.2",
+    "@nuxt/schema": "^4.5.2",
+    "@vue/compiler-sfc": "^3.5.43",
+    "cac": "^7.0.0",
+    "globals": "^17.12.0",
+    "h3": "^1.15.11",
+    "jiti": "^2.7.0",
+    "oxc-parser": "^0.151.0",
+    "oxc-walker": "^1.1.1",
+    "pathe": "^2.0.3",
+    "tinyglobby": "^0.2.17"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "eslint": "^10.11.0",
+    "typescript-eslint": "^8.70.1",
+    "vite-plus": "1.0.0",
+    "vue-eslint-parser": "^10.4.1"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "nuxt": "^3.12.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "nuxt": {
+      "optional": true
+    },
+    "eslint": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test",
+    "tarball": "vp run build && vp pm pack --pack-destination ../../.release"
+  }
+}