nuxt-layerscope 0.1.0

package/dist/effective-Dqg4EwH_.d.mts

@@ -0,0 +1,7 @@
+import { u as LayerscopeConfig } from "./define-DNRGLVG_.mjs";
+//#region src/config/effective.d.ts
+/** The keys that describe the project; `buildDir` only says where to look. */
+declare const PROJECT_CONFIG_KEYS: readonly ['layers', 'rules', 'ignore', 'globals'];
+type ProjectConfig = Pick<LayerscopeConfig, (typeof PROJECT_CONFIG_KEYS)[number]>;
+//#endregion
+export { ProjectConfig as t };

package/dist/eslint.d.mts

@@ -0,0 +1,7 @@
+import { ESLint, Linter } from "eslint";
+//#region src/eslint/index.d.ts
+declare const plugin: ESLint.Plugin & {
+  configs: Record<string, Linter.Config>;
+};
+//#endregion
+export { plugin as default };

package/dist/eslint.mjs

@@ -0,0 +1,213 @@
+import { d as effectiveConfig, l as REGISTRY_FILE } from "./layer-factory-xZmIAPrA.mjs";
+import { t as packageVersion } from "./version-D6whhsHH.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-Bkq_69x4.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
+//#region src/eslint/load-project.ts
+/** Config, layers and symbols of a project, from its registry; Nuxt itself is never loaded. */
+function loadProject(rootDir) {
+	const fileConfig = loadConfigSync(rootDir);
+	const buildDir = resolve(rootDir, fileConfig.buildDir ?? ".nuxt");
+	const read = readRegistry(buildDir);
+	if (read.kind !== "ok") return {
+		ok: false,
+		message: `${read.file} is missing or from another nuxt-layerscope release. Add "nuxt-layerscope" to "modules" in nuxt.config and run "nuxi prepare".`
+	};
+	const config = effectiveConfig(fileConfig, read.registry.config);
+	const layers = nameLayers(read.registry.layers, rootDir, config);
+	const table = tableFromRegistry(read.registry, buildDir);
+	const lintConfig = {
+		...config,
+		rules: {
+			...config.rules,
+			"layer-boundary": "error",
+			"unresolved-reference": "warn"
+		}
+	};
+	return {
+		ok: true,
+		project: {
+			rootDir,
+			config: lintConfig,
+			env: createAnalysisEnv(table, createOwnerLookup(layers), buildDir, lintConfig)
+		}
+	};
+}
+//#endregion
+//#region src/eslint/project.ts
+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)) {
+		if (existsSync(join(dir, DEFAULT_REGISTRY))) return dir;
+		if (dirname(dir) === dir) return null;
+	}
+}
+function mtime(file) {
+	return file !== null && existsSync(file) ? statSync(file).mtimeMs : 0;
+}
+function tryLoadProject(rootDir) {
+	try {
+		return loadProject(rootDir);
+	} catch (error) {
+		return {
+			ok: false,
+			message: error.message
+		};
+	}
+}
+/** 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);
+	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.`
+	};
+	const configFile = findConfigFile(rootDir);
+	const registry = join(rootDir, DEFAULT_REGISTRY);
+	const stamp = `${mtime(configFile)}:${mtime(registry)}`;
+	const cached = cache.get(rootDir);
+	if (cached?.stamp === stamp) return cached.load;
+	const load = tryLoadProject(rootDir);
+	cache.set(rootDir, {
+		stamp,
+		load
+	});
+	return load;
+}
+//#endregion
+//#region src/eslint/rules.ts
+const OPTIONS_SCHEMA = [{
+	type: "object",
+	properties: { root: { type: "string" } },
+	additionalProperties: false
+}];
+function describeFinding(finding, rootDir) {
+	if (finding.rule !== "layer-boundary" || finding.target === null) return finding.message;
+	const allowed = finding.allowed === void 0 || finding.allowed.length === 0 ? "no other layers" : finding.allowed.join(", ");
+	return `${finding.message}: ${finding.symbol} → ${relative(rootDir, finding.target)} (allowed for "${finding.fromLayer}": ${allowed})`;
+}
+function createRule(description, pick, reportsSetup) {
+	return {
+		meta: {
+			type: "problem",
+			docs: { description },
+			schema: OPTIONS_SCHEMA
+		},
+		create(context) {
+			const [options] = context.options;
+			return { "Program:exit"() {
+				const load = projectFor(context.filename, options?.root);
+				if (!load.ok) {
+					if (reportsSetup) context.report({
+						loc: {
+							line: 1,
+							column: 0
+						},
+						message: `layerscope: ${load.message}`
+					});
+					return;
+				}
+				const { project } = load;
+				const { text } = context.sourceCode;
+				const lint = lintFile(context.filename, text, project);
+				for (const finding of pick(lint)) {
+					const { line, column, outside } = reportLocation(finding, lint.source, text);
+					const message = describeFinding(finding, project.rootDir);
+					context.report({
+						loc: {
+							line,
+							column: column - 1
+						},
+						message: outside ? `${message} (template line ${finding.line})` : message
+					});
+				}
+			} };
+		}
+	};
+}
+const rules = {
+	"layer-boundary": createRule("Disallow dependencies, including auto-imports, into layers this layer may not use", (lint) => lint.boundary, true),
+	"unresolved-reference": createRule("Report identifiers, components and imports that cannot be resolved", (lint) => lint.unresolved, false)
+};
+//#endregion
+//#region src/eslint/index.ts
+const plugin = {
+	meta: {
+		name: "nuxt-layerscope",
+		version: packageVersion()
+	},
+	rules,
+	configs: {}
+};
+plugin.configs.recommended = {
+	name: "nuxt-layerscope/recommended",
+	plugins: { layerscope: plugin },
+	rules: {
+		"layerscope/layer-boundary": "error",
+		"layerscope/unresolved-reference": "warn"
+	}
+};
+//#endregion
+export { plugin as default };