eaa-kit 0.2.1 → 0.3.0

package/dist/component-7kEBjv_y.js

@@ -0,0 +1,111 @@
+import { i as toPosix } from "./fs-BmPtmFke.js";
+import { t as collapse } from "./text-BFmNtMsV.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { glob } from "tinyglobby";
+//#region src/audit/component.ts
+/**
+* Which source file a failing element was written in.
+*
+* Route mapping names the page, and on a site built from components the page is
+* not where the fix goes: a header with a missing `alt` appears on every page
+* that renders it and is written in none of them. The Issues view can already
+* tell that one element is shared across pages; this says which file to open.
+*
+* The method is deliberately dumb. Take a literal out of the failing markup —
+* an image path, a link target, an id — and look for it in the project's own
+* source. Frameworks do emit source positions, but only in development builds,
+* and an auditor runs against production output. A literal survives every
+* compiler.
+*
+* It never guesses. A literal found in two files names neither, because a wrong
+* file is worse than none: it sends somebody to edit code that was not the
+* cause, and costs more than the minute it saved.
+*/
+/** Where component source is expected to live. */
+const SOURCE_GLOBS = ["**/*.{tsx,jsx,ts,js,mjs,vue,svelte,astro,mdx,md,html,php,erb,twig,liquid,hbs}"];
+/** Never source: dependencies, build output, version control. */
+const NEVER = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/out/**",
+	"**/_site/**",
+	"**/.next/**",
+	"**/.nuxt/**",
+	"**/.svelte-kit/**",
+	"**/.output/**",
+	"**/coverage/**",
+	"**/*.min.js"
+];
+/** Files read into the index. A ceiling, not a target. */
+const MAX_FILES = 2e3;
+/** Bytes per file. A source file past this is generated or vendored. */
+const MAX_BYTES = 524288;
+/**
+* Read the project's source once, so every element can be looked up against it.
+*
+* Once rather than per element: a site with forty violations would otherwise
+* walk the tree forty times for an answer that does not change.
+*/
+async function buildComponentIndex(cwd) {
+	const found = await glob([...SOURCE_GLOBS], {
+		cwd,
+		ignore: [...NEVER],
+		onlyFiles: true,
+		dot: false
+	});
+	const files = /* @__PURE__ */ new Map();
+	for (const relative of found.slice(0, MAX_FILES).sort()) try {
+		const source = await readFile(path.resolve(cwd, relative), "utf8");
+		if (source.length <= MAX_BYTES) files.set(toPosix(relative), source);
+	} catch {}
+	return { files };
+}
+/**
+* Literals worth searching for, most distinctive first.
+*
+* An image path or a link target is written by hand and survives compilation.
+* A class name may be generated, and text content may be interpolated, so both
+* come after. Anything short is dropped: `/` appears in every file.
+*/
+function searchTermsFor(html) {
+	const terms = [];
+	const add = (value) => {
+		if (value === void 0) return;
+		const trimmed = value.trim();
+		if (trimmed.length < 4 || trimmed.includes("${")) return;
+		if (!terms.includes(trimmed)) terms.push(trimmed);
+	};
+	for (const attribute of [
+		"src",
+		"href",
+		"id",
+		"data-testid",
+		"name",
+		"action"
+	]) add(new RegExp(`\\s${attribute}\\s*=\\s*["']([^"']+)["']`, "i").exec(html)?.[1]);
+	const text = collapse(html.replace(/<[^>]*>/g, " "));
+	if (text.length >= 8) add(text.slice(0, 60));
+	return terms;
+}
+/**
+* The one source file this element was written in, if exactly one claims it.
+*
+* Returns undefined when nothing matches and when more than one does. The
+* second case is the important one: naming a file that merely happens to
+* contain the same path sends somebody to edit the wrong component.
+*/
+function componentFor(index, html) {
+	for (const term of searchTermsFor(html)) {
+		const matches = [];
+		for (const [file, source] of index.files) if (source.includes(term)) {
+			matches.push(file);
+			if (matches.length > 1) break;
+		}
+		if (matches.length === 1) return matches[0];
+	}
+}
+//#endregion
+export { buildComponentIndex, componentFor };

package/dist/{crawl-CtJbMNNb.js → crawl-Oxt2Gaqo.js}

@@ -1,3 +1,4 @@
+import { i as stripBom } from "./collect-BkAQ0viT.js";
 /** Requests in flight at once. Politeness, not throughput. */
 const REQUEST_CONCURRENCY = 4;
 var CrawlError = class extends Error {
@@ -142,31 +143,18 @@ function disallowedPaths(robots) {
 	return paths;
 }
 /**
-* Paths this crawler must not visit, from the site's own robots.txt.
+* One of the two files a site publishes about itself, or undefined.
 *
 * Read directly rather than through fetchPage, which correctly refuses anything
-* that is not a page. A site with no robots.txt disallows nothing.
+* that is not a page. A site that does not publish one is the ordinary case,
+* not a failure, so it comes back empty either way.
 */
-async function blockedPaths(entry, impl) {
+async function fetchSiteFile(entry, impl, name) {
 	try {
-		const response = await impl(new URL("/robots.txt", entry).href, { redirect: "follow" });
-		return response.ok ? disallowedPaths(await response.text()) : [];
+		const response = await impl(new URL(name, entry).href, { redirect: "follow" });
+		return response.ok ? await response.text() : void 0;
 	} catch {
-		return [];
-	}
-}
-/**
-* Page URLs the site lists for itself.
-*
-* Worth one request: a sitemap finds pages nothing links to, which link
-* following alone never reaches.
-*/
-async function sitemapUrls(entry, impl) {
-	try {
-		const response = await impl(new URL("/sitemap.xml", entry).href, { redirect: "follow" });
-		return response.ok ? urlsFromSitemap(await response.text(), entry) : [];
-	} catch {
-		return [];
+		return;
 	}
 }
 /**
@@ -182,7 +170,8 @@ async function crawlSite(entry, options = {}) {
 	const maxDepth = options.maxDepth ?? 3;
 	const timeoutMs = options.timeoutMs ?? 15e3;
 	const failures = [];
-	const blocked = options.ignoreRobots ? [] : await blockedPaths(entry, impl);
+	const robots = options.ignoreRobots ? void 0 : await fetchSiteFile(entry, impl, "/robots.txt");
+	const blocked = robots === void 0 ? [] : disallowedPaths(robots);
 	const allowed = (url) => !blocked.some((path) => url.pathname.startsWith(path));
 	let discovery = "links";
 	const queue = [];
@@ -195,7 +184,8 @@ async function crawlSite(entry, options = {}) {
 			depth
 		});
 	};
-	const listed = await sitemapUrls(entry, impl);
+	const sitemap = await fetchSiteFile(entry, impl, "/sitemap.xml");
+	const listed = sitemap === void 0 ? [] : urlsFromSitemap(sitemap, entry);
 	if (listed.length > 0) {
 		discovery = "sitemap";
 		for (const url of listed) enqueue(url, 0);
@@ -220,7 +210,7 @@ async function crawlSite(entry, options = {}) {
 			pages.push({
 				absolutePath: url.href,
 				relativePath: pageIdentity(url),
-				html: html.charCodeAt(0) === 65279 ? html.slice(1) : html
+				html: stripBom(html)
 			});
 			options.onProgress?.(pages.length, queue.length);
 			if (item.depth < maxDepth) for (const link of linksFrom(html, url)) enqueue(link, item.depth + 1);

package/dist/frameworks-BYa3tULg.js

@@ -0,0 +1,243 @@
+import { t as exists } from "./fs-BmPtmFke.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/audit/frameworks.ts
+/**
+* Most specific first. Several of these depend on Vite, so Vite is last: a
+* SvelteKit project is a SvelteKit project, not a Vite one.
+*
+* Several carry `files` as well as `packages` even though they are npm
+* packages. A config file named after the framework is as good an identifier as
+* the dependency, and it still works where package.json is missing, unreadable,
+* or belongs to a workspace root rather than the project in front of us.
+*/
+const FRAMEWORKS = [
+	{
+		id: "next",
+		name: "Next.js",
+		packages: ["next"],
+		files: [
+			"next.config.js",
+			"next.config.mjs",
+			"next.config.ts"
+		],
+		outputs: ["out"],
+		configs: [
+			"next.config.js",
+			"next.config.mjs",
+			"next.config.ts"
+		],
+		outputPattern: /distDir\s*:\s*['"`]([^'"`]+)['"`]/,
+		staticOutput: {
+			needs: "output: 'export'",
+			how: "add output: 'export' to your Next config, then build"
+		},
+		serves: true
+	},
+	{
+		id: "nuxt",
+		name: "Nuxt",
+		packages: ["nuxt"],
+		files: ["nuxt.config.ts", "nuxt.config.js"],
+		outputs: [".output/public", "dist"],
+		staticOutput: {
+			needs: "nuxt generate",
+			how: "run nuxt generate rather than nuxt build"
+		},
+		serves: true
+	},
+	{
+		id: "sveltekit",
+		name: "SvelteKit",
+		packages: ["@sveltejs/kit"],
+		files: ["svelte.config.js"],
+		outputs: ["build", ".svelte-kit/output/prerendered/pages"],
+		staticOutput: {
+			needs: "@sveltejs/adapter-static",
+			how: "use @sveltejs/adapter-static, then build"
+		},
+		serves: true
+	},
+	{
+		id: "remix",
+		name: "React Router / Remix",
+		packages: [
+			"@remix-run/react",
+			"react-router",
+			"@react-router/dev"
+		],
+		outputs: ["build/client"],
+		serves: true
+	},
+	{
+		id: "astro",
+		name: "Astro",
+		packages: ["astro"],
+		files: [
+			"astro.config.mjs",
+			"astro.config.js",
+			"astro.config.ts"
+		],
+		outputs: ["dist"],
+		configs: [
+			"astro.config.mjs",
+			"astro.config.js",
+			"astro.config.ts"
+		],
+		outputPattern: /outDir\s*:\s*['"`]([^'"`]+)['"`]/,
+		serves: true
+	},
+	{
+		id: "gatsby",
+		name: "Gatsby",
+		packages: ["gatsby"],
+		outputs: ["public"],
+		serves: false
+	},
+	{
+		id: "docusaurus",
+		name: "Docusaurus",
+		packages: ["@docusaurus/core"],
+		outputs: ["build"],
+		serves: false
+	},
+	{
+		id: "vitepress",
+		name: "VitePress",
+		packages: ["vitepress"],
+		files: [".vitepress/config.ts", "docs/.vitepress/config.ts"],
+		outputs: [".vitepress/dist", "docs/.vitepress/dist"],
+		serves: false
+	},
+	{
+		id: "eleventy",
+		name: "Eleventy",
+		packages: ["@11ty/eleventy"],
+		outputs: ["_site"],
+		configs: [
+			".eleventy.js",
+			"eleventy.config.js",
+			"eleventy.config.mjs"
+		],
+		outputPattern: /output\s*:\s*['"`]([^'"`]+)['"`]/,
+		serves: false
+	},
+	{
+		id: "angular",
+		name: "Angular",
+		packages: ["@angular/core"],
+		outputs: ["dist"],
+		serves: false
+	},
+	{
+		id: "cra",
+		name: "Create React App",
+		packages: ["react-scripts"],
+		outputs: ["build"],
+		serves: false
+	},
+	{
+		id: "hugo",
+		name: "Hugo",
+		packages: [],
+		files: [
+			"hugo.toml",
+			"hugo.yaml",
+			"config.toml"
+		],
+		outputs: ["public"],
+		serves: false
+	},
+	{
+		id: "jekyll",
+		name: "Jekyll",
+		packages: [],
+		files: ["_config.yml"],
+		outputs: ["_site"],
+		serves: false
+	},
+	{
+		id: "vite",
+		name: "Vite",
+		packages: ["vite"],
+		outputs: ["dist"],
+		configs: [
+			"vite.config.ts",
+			"vite.config.js",
+			"vite.config.mjs"
+		],
+		outputPattern: /outDir\s*:\s*['"`]([^'"`]+)['"`]/,
+		serves: true
+	}
+];
+/** Output directories to try when nothing was recognised. */
+const FALLBACK_OUTPUTS = [
+	"dist",
+	"out",
+	"build",
+	"_site",
+	"public",
+	".output/public"
+];
+/**
+* The framework this project uses, if it is one this knows.
+*
+* Dependencies decide it where there are any, because a package.json states
+* what a project is far more reliably than a file lying in the root. The
+* file-based entries exist for Hugo and Jekyll, which have no package.json to
+* read.
+*/
+async function detectFramework(cwd, pkg) {
+	const deps = {
+		...pkg?.dependencies,
+		...pkg?.devDependencies
+	};
+	for (const framework of FRAMEWORKS) {
+		const byPackage = framework.packages.some((name) => deps[name] !== void 0);
+		let byFile = false;
+		if (!byPackage && framework.files !== void 0) {
+			for (const file of framework.files) if (await exists(file, cwd)) {
+				byFile = true;
+				break;
+			}
+		}
+		if (!byPackage && !byFile) continue;
+		const configured = await outputFromConfig(cwd, framework);
+		const outputs = configured === void 0 ? [...framework.outputs] : [configured, ...framework.outputs];
+		return {
+			framework,
+			outputs: [...new Set(outputs)]
+		};
+	}
+}
+/**
+* A custom output directory, read out of the framework's config file.
+*
+* Read with a pattern rather than executed. A config file is code, and this runs
+* before anything has decided the project is worth trusting; a regex that
+* misses a computed value is a directory not found, which the caller already
+* handles, while running the file to find out is a different class of risk
+* entirely.
+*/
+async function outputFromConfig(cwd, framework) {
+	if (framework.configs === void 0 || framework.outputPattern === void 0) return void 0;
+	for (const name of framework.configs) {
+		let source;
+		try {
+			source = await readFile(path.resolve(cwd, name), "utf8");
+		} catch {
+			continue;
+		}
+		const value = framework.outputPattern.exec(source)?.[1];
+		if (value === void 0 || value === "") continue;
+		if (path.isAbsolute(value)) continue;
+		return value.replace(/^\.\//, "");
+	}
+}
+/** Every output directory worth trying, framework-aware, most likely first. */
+async function candidateOutputs(cwd, pkg) {
+	const detected = await detectFramework(cwd, pkg);
+	return [.../* @__PURE__ */ new Set([...detected?.outputs ?? [], ...FALLBACK_OUTPUTS])];
+}
+//#endregion
+export { outputFromConfig as a, detectFramework as i, FRAMEWORKS as n, candidateOutputs as r, FALLBACK_OUTPUTS as t };

package/dist/frameworks-DaDqrJOw.js

@@ -0,0 +1,2 @@
+import { i as detectFramework, t as FALLBACK_OUTPUTS } from "./frameworks-BYa3tULg.js";
+export { FALLBACK_OUTPUTS, detectFramework };

package/dist/fs-BmPtmFke.js

@@ -0,0 +1,40 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+//#region src/fs.ts
+/**
+* Asking the filesystem a yes-or-no question.
+*
+* Six modules had their own copy of the same try/stat/catch, each answering a
+* slightly different question and each getting it right by hand. A path that
+* cannot be stat'd is not a path of the kind asked about, which is the only
+* behaviour any caller here wants from an unreadable directory.
+*/
+/** Whether anything is there, resolved against `root` when one is given. */
+async function exists(target, root) {
+	try {
+		await stat(root === void 0 ? target : path.resolve(root, target));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isFile(target) {
+	try {
+		return (await stat(target)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function isDirectory(target) {
+	try {
+		return (await stat(target)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** Platform-native separators to POSIX, so paths in reports match everywhere. */
+function toPosix(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+//#endregion
+export { toPosix as i, isDirectory as n, isFile as r, exists as t };