eaa-kit 0.2.1 → 0.4.0

package/dist/routes-CmdRUuOs.js

@@ -0,0 +1,265 @@
+import { i as toPosix, n as isDirectory } from "./fs-BmPtmFke.js";
+import { i as detectFramework } from "./frameworks-B4ClIJgE.js";
+import { i as readPackageJson } from "./project-CzOnkLH6.js";
+import path from "node:path";
+import { glob } from "tinyglobby";
+//#region src/audit/routes.ts
+/**
+* A path segment that serves more than one page, or none.
+*
+* Dynamic segments are refused rather than resolved: `[slug]` stands for every
+* post there is, and picking one would name a file that did not produce the
+* page in front of the reader. Private and slot folders contribute no route at
+* all.
+*/
+function classifyBracketSegment(segment) {
+	if (/^\(.*\)$/.test(segment)) return "skip";
+	if (/^[[(]|^_|^@/.test(segment)) return "refuse";
+	return "route";
+}
+/** Drop the extension, and fold an index file into the directory it sits in. */
+function withoutExtension(file) {
+	const route = file.replace(/\.[^./]+$/, "").replace(/\/index$/, "");
+	return route === "index" ? "" : route;
+}
+/** The directory a route file sits in, for routers that put the route there. */
+function containingDirectory(file) {
+	return file.includes("/") ? file.replace(/\/[^/]+$/, "") : "";
+}
+/** Keep the segments that are routes, refusing the file if any is dynamic. */
+function joinSegments(route) {
+	const kept = [];
+	for (const segment of route.split("/").filter((part) => part !== "")) {
+		const kind = classifyBracketSegment(segment);
+		if (kind === "refuse") return void 0;
+		if (kind === "skip") continue;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/** `pages/kontakt.tsx` serves `/kontakt`; the filename is the route. */
+function fileNamedRoute(file) {
+	return joinSegments(withoutExtension(file));
+}
+/** `app/kontakt/page.tsx` serves `/kontakt`; the directory is the route. */
+function directoryNamedRoute(file) {
+	return joinSegments(containingDirectory(file));
+}
+/**
+* A documentation tree whose directory layout is the URL layout.
+*
+* No dynamic segments to worry about — these are files an author wrote, one per
+* page — so the only work is folding the index file into its directory.
+*/
+function mirroredRoute(file) {
+	return withoutExtension(file);
+}
+/**
+* Remix and React Router flat routes: `blog.post.tsx` serves `/blog/post`.
+*
+* The dot is the separator, `_index` is a directory's own page, and a trailing
+* underscore on a segment escapes a parent layout without changing the URL. A
+* `$` segment is dynamic and refused, as `[slug]` is elsewhere.
+*/
+function remixRoute(file) {
+	const withoutRouteFile = file.replace(/\/route\.[^./]+$/, "");
+	const flat = withoutRouteFile === file ? withoutExtension(file) : toPosix(withoutRouteFile);
+	const leaf = flat.includes("/") ? flat.split("/").pop() : flat;
+	if (leaf === "") return void 0;
+	const kept = [];
+	for (const raw of leaf.split(".")) {
+		const segment = raw.replace(/_$/, "");
+		if (segment === "") continue;
+		if (segment === "_index") continue;
+		if (segment.startsWith("$")) return void 0;
+		if (segment.includes("[")) return void 0;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/**
+* Hugo content: `content/posts/hello.md` serves `/posts/hello/`.
+*
+* `_index.md` is a section's own page rather than a page called `_index`, which
+* is the one place Hugo's leading underscore does not mean "private".
+*/
+function hugoRoute(file) {
+	const withoutIndex = file.replace(/(^|\/)_index\.[^./]+$/, "");
+	if (withoutIndex !== file) return toPosix(withoutIndex);
+	return withoutExtension(file);
+}
+/**
+* Conventions, most specific first.
+*
+* Order still matters where the registry knows nothing about a project, which
+* is the case for a plain directory of HTML and for anything the registry has
+* not heard of.
+*/
+const CONVENTIONS = [
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "src/app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "remix",
+		ids: ["remix"],
+		dir: "app/routes",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: remixRoute
+	},
+	{
+		framework: "starlight",
+		ids: ["astro"],
+		dir: "src/content/docs",
+		pattern: "**/*.{md,mdx,mdoc}",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "astro",
+		ids: ["astro"],
+		dir: "src/pages",
+		pattern: "**/*.{astro,md,mdx,html}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "gatsby",
+		ids: ["gatsby"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,md,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "nuxt",
+		ids: ["nuxt"],
+		dir: "pages",
+		pattern: "**/*.vue",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "sveltekit",
+		ids: ["sveltekit"],
+		dir: "src/routes",
+		pattern: "**/+page.{svelte,ts,js}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "docusaurus",
+		ids: ["docusaurus"],
+		dir: "docs",
+		pattern: "**/*.{md,mdx}",
+		toRoute: (file) => {
+			const route = mirroredRoute(file);
+			return route === void 0 ? void 0 : route === "" ? "docs" : `docs/${route}`;
+		}
+	},
+	{
+		framework: "vitepress",
+		ids: ["vitepress"],
+		dir: "docs",
+		pattern: "**/*.md",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "hugo",
+		ids: ["hugo"],
+		dir: "content",
+		pattern: "**/*.{md,html}",
+		toRoute: hugoRoute
+	}
+];
+/** Every page path a build could have emitted for one route. */
+function emittedPathsFor(route) {
+	if (route === "") return [
+		"/",
+		"index.html",
+		"index.htm"
+	];
+	return [
+		route,
+		`${route}/`,
+		`${route}.html`,
+		`${route}/index.html`
+	];
+}
+/**
+* Build a page-to-source map by reading the project's route files.
+*
+* Returns undefined when the project uses no convention this understands, which
+* is not a failure — most builds are not framework projects.
+*/
+async function buildRouteMap(cwd, pkg) {
+	for (const convention of await orderedConventions(cwd, pkg)) {
+		const map = await mapConvention(cwd, convention);
+		if (map !== void 0) return map;
+	}
+}
+/**
+* Conventions to try, the detected framework's first.
+*
+* Without this, `src/pages` is claimed by whichever convention is declared
+* earliest, so a Gatsby project was reported as `next-pages`. The mapping
+* happened to be right and the name was wrong, which is the kind of detail a
+* reader notices and stops trusting the rest of the report over.
+*/
+async function orderedConventions(cwd, pkg) {
+	const detected = await detectFramework(cwd, pkg ?? await readPackageJson(cwd));
+	if (detected === void 0) return [...CONVENTIONS];
+	const id = detected.framework.id;
+	const mine = CONVENTIONS.filter((convention) => convention.ids.includes(id));
+	const rest = CONVENTIONS.filter((convention) => !convention.ids.includes(id));
+	return [...mine, ...rest];
+}
+/** Read one convention's directory, or undefined when it has nothing to say. */
+async function mapConvention(cwd, convention) {
+	const directory = path.join(cwd, convention.dir);
+	if (!await isDirectory(directory)) return void 0;
+	const files = await glob([convention.pattern], {
+		cwd: directory,
+		ignore: ["**/node_modules/**"],
+		onlyFiles: true
+	});
+	if (files.length === 0) return void 0;
+	const sources = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const route = convention.toRoute(toPosix(file));
+		if (route === void 0) continue;
+		const source = `${convention.dir}/${toPosix(file)}`;
+		for (const emitted of emittedPathsFor(route)) if (!sources.has(emitted)) sources.set(emitted, source);
+	}
+	if (sources.size === 0) return void 0;
+	return {
+		framework: convention.framework,
+		sources
+	};
+}
+/** The source file for an audited page, if the map knows one. */
+function sourceFor(map, pagePath) {
+	if (map === void 0) return void 0;
+	return map.sources.get(pagePath) ?? map.sources.get(pagePath.replace(/^\//, ""));
+}
+//#endregion
+export { buildRouteMap, sourceFor };

package/dist/run-BMASMmwO.d.ts

@@ -0,0 +1,45 @@
+import { t as ImpactLevel } from "./impact-EEB9ZXmC.js";
+//#region src/cli/audit.d.ts
+declare const OUTPUT_FORMATS: readonly ['console', 'json', 'sarif', 'html'];
+type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+//#endregion
+//#region src/integration/run.d.ts
+/**
+ * What a build-time integration does once the build has written its files.
+ *
+ * Astro, Vite and Next all reach the same point by different routes: a
+ * directory exists, and the build should stop if what is in it fails the
+ * threshold. Only the hook name and the logger differ, so only those live in
+ * the integrations.
+ */
+interface IntegrationOptions {
+  /** Lowest impact that fails the build. Defaults to 'serious'. */
+  failOn?: ImpactLevel;
+  include?: string[];
+  exclude?: string[];
+  baseUrl?: string;
+  /** Audit in real Chromium. Needs the playwright peer. */
+  browser?: boolean;
+  concurrency?: number;
+  baseline?: string;
+  format?: OutputFormat;
+  /** Write the report here instead of the build log. */
+  output?: string;
+  /**
+   * Report without failing the build. For the week it takes to adopt this on a
+   * site that already exists — a baseline is the honest way to go green after
+   * that.
+   */
+  failBuild?: boolean;
+  /** Skip entirely. For turning it off per environment without unwiring it. */
+  enabled?: boolean;
+}
+/**
+ * Thrown to fail the build. Its own class so a consumer can tell an audit
+ * failure from the build tool falling over.
+ */
+declare class BuildAuditError extends Error {
+  readonly name = "BuildAuditError";
+}
+//#endregion
+export { IntegrationOptions as n, BuildAuditError as t };

package/dist/run-DB34BSOZ.js

@@ -0,0 +1,53 @@
+//#region src/integration/run.ts
+/**
+* Where an integration writes when its host offers no logger of its own.
+*
+* stderr rather than stdout, so a line about accessibility never lands in the
+* middle of a report being piped to a file, and prefixed either way: a message
+* in somebody's build log has to say what produced it.
+*/
+function stderrLogger() {
+	const write = (message) => {
+		process.stderr.write(`eaa-kit: ${message}\n`);
+	};
+	return {
+		info: write,
+		warn: write,
+		error: write
+	};
+}
+/**
+* Thrown to fail the build. Its own class so a consumer can tell an audit
+* failure from the build tool falling over.
+*/
+var BuildAuditError = class extends Error {
+	name = "BuildAuditError";
+};
+/**
+* Audit a finished build and decide whether it may proceed.
+*
+* Returns normally when the build should continue, and throws BuildAuditError
+* when it should not.
+*/
+async function auditBuild(directory, options, logger) {
+	const { enabled, failBuild, ...auditOptions } = options;
+	if (enabled === false) {
+		logger.info("skipped (enabled: false)");
+		return;
+	}
+	const { runAuditCommand } = await import("./audit-CpXH2Mk8.js");
+	const { exitCode } = await runAuditCommand(directory, auditOptions);
+	if (exitCode === 0) {
+		logger.info("no violations at or above the threshold");
+		return;
+	}
+	const message = exitCode === 2 ? "the audit could not be completed, so this build was not checked" : "accessibility violations at or above the threshold";
+	if (failBuild === false) {
+		logger.warn(`${message} (failBuild: false, so the build continues)`);
+		return;
+	}
+	logger.error(message);
+	throw new BuildAuditError(`eaa-kit: ${message}`);
+}
+//#endregion
+export { auditBuild as n, stderrLogger as r, BuildAuditError as t };

package/dist/{sarif-eSCuI0eX.js → sarif-SR3_lLYd.js}

@@ -1,6 +1,8 @@
-import { i as isImpactLevel } from "./impact-DvgBjupx.js";
+import { o as isImpactLevel } from "./impact-DZt2oBCP.js";
+import { o as standardsReference } from "./text-CKKpzkYM.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
 import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
+import { a as findingElements, s as ruleOutcomes } from "./result-DoamKFsp.js";
 import path from "node:path";
 //#region src/audit/report/sarif.ts
 const SARIF_VERSION = "2.1.0";
@@ -73,7 +75,7 @@ function buildSarifReport(audits, options) {
 				toolExecutionNotifications: notifications
 			}],
 			results,
-			properties: summaryProperties(audits)
+			properties: summaryProperties(audits, options.completeness)
 		}]
 	};
 }
@@ -92,29 +94,16 @@ const SUPPRESSED = [{
 function toResults(finding, ruleIndex, uri, suppressions) {
 	const level = toSarifLevel(finding.impact);
 	const location = { physicalLocation: { artifactLocation: { uri } } };
-	if (finding.nodes.length === 0) return [{
+	return findingElements(finding).map(({ selector, html }) => ({
 		ruleId: finding.ruleId,
 		ruleIndex,
 		level,
 		kind: "fail",
-		message: { text: finding.help },
+		message: { text: selector === "" ? finding.help : `${finding.help}. Element: ${selector}` },
 		locations: [location],
-		partialFingerprints: fingerprint(finding.ruleId, "", ""),
+		partialFingerprints: fingerprint(finding.ruleId, selector, html),
 		...suppressions ? { suppressions } : {}
-	}];
-	return finding.nodes.map((node) => {
-		const selector = node.target.join(" ");
-		return {
-			ruleId: finding.ruleId,
-			ruleIndex,
-			level,
-			kind: "fail",
-			message: { text: `${finding.help}. Element: ${selector}` },
-			locations: [location],
-			partialFingerprints: fingerprint(finding.ruleId, selector, node.html),
-			...suppressions ? { suppressions } : {}
-		};
-	});
+	}));
 }
 /**
 * Identifies an alert across runs. Deliberately excludes the file path, so that
@@ -127,25 +116,14 @@ function fingerprint(ruleId, selector, html) {
 /** Every rule the run knows about, so the catalogue is complete in GitHub. */
 function buildRules(audits) {
 	const rules = /* @__PURE__ */ new Map();
-	for (const audit of audits) {
-		const outcomes = [
-			...audit.violations,
-			...audit.accepted ?? [],
-			...audit.incomplete,
-			...audit.passes,
-			...audit.inapplicable
-		];
-		for (const outcome of outcomes) {
-			if (rules.has(outcome.ruleId)) continue;
-			rules.set(outcome.ruleId, toSarifRule(outcome));
-		}
+	for (const audit of audits) for (const outcome of ruleOutcomes(audit)) {
+		if (rules.has(outcome.ruleId)) continue;
+		rules.set(outcome.ruleId, toSarifRule(outcome));
 	}
 	return [...rules.values()].sort((a, b) => a.id.localeCompare(b.id));
 }
 function toSarifRule(outcome) {
-	const criteria = outcome.successCriteria.map((criterion) => `WCAG ${criterion}`);
-	const clauses = outcome.enClauses.map((clause) => `EN 301 549 ${clause}`);
-	const references = [...criteria, ...clauses].join(", ");
+	const references = standardsReference(outcome.successCriteria, outcome.enClauses);
 	return {
 		id: outcome.ruleId,
 		shortDescription: { text: outcome.help },
@@ -162,7 +140,7 @@ function toSarifRule(outcome) {
 * Coverage that has no place in `results` but should not vanish: a SARIF log
 * with no results must not be mistaken for "everything was checked".
 */
-function summaryProperties(audits) {
+function summaryProperties(audits, completeness) {
 	let needsReview = 0;
 	let notEvaluated = 0;
 	const notEvaluatedRules = /* @__PURE__ */ new Set();
@@ -175,7 +153,15 @@ function summaryProperties(audits) {
 		pages: audits.length,
 		needsReview,
 		notEvaluated,
-		notEvaluatedRules: [...notEvaluatedRules].sort()
+		notEvaluatedRules: [...notEvaluatedRules].sort(),
+		...completeness ? {
+			complete: completeness.complete,
+			discovery: completeness.discovery,
+			pagesAudited: completeness.audited,
+			pagesErrored: completeness.errored,
+			pagesUnreachable: completeness.unreachable.length,
+			truncated: completeness.truncated
+		} : {}
 	};
 }
 /**

package/dist/{schema-CMZ8ItGk.js → schema-is6CGX2D.js}

@@ -64,6 +64,9 @@ function string(options = {}) {
 		return value;
 	} };
 }
+function boolean() {
+	return { read: (value, path, issues) => typeof value === "boolean" ? value : fail(issues, path, "expected true or false") };
+}
 function number() {
 	return { read: (value, path, issues) => typeof value === "number" && Number.isFinite(value) ? value : fail(issues, path, "expected a number") };
 }
@@ -189,4 +192,4 @@ function email() {
 	} };
 }
 //#endregion
-export { withDefault as _, isoDateTime as a, object as c, record as d, safeParse as f, url as g, union as h, isoDate as i, optional as l, transform as m, email as n, nullable as o, string as p, enumeration as r, number as s, array as t, pipe as u };
+export { url as _, isoDate as a, number as c, pipe as d, record as f, union as g, transform as h, enumeration as i, object as l, string as m, boolean as n, isoDateTime as o, safeParse as p, email as r, nullable as s, array as t, optional as u, withDefault as v };

package/dist/text-CKKpzkYM.js

@@ -0,0 +1,43 @@
+//#region src/text.ts
+/**
+* Text this package writes: escaping, counting and the standards references
+* that appear in every report and in the statement.
+*
+* Both documents eaa-kit produces embed text it did not write: an issue
+* description from a config file, axe-core's help text, and — in the audit
+* report — the markup of the element that failed, which is by definition
+* arbitrary HTML from somebody's build. Getting the escaping wrong in the
+* report would mean a page that fails an accessibility audit for having a stray
+* `<script>` hands that script to whoever opens the report.
+*/
+/** For text nodes. Leaves quotes alone, which are fine between tags. */
+function escapeText(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** For attribute values, where a quote would end the attribute. */
+function escapeAttribute(value) {
+	return escapeText(value).replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+/** `plural(1, 'page')` is `page`, `plural(2, 'page')` is `pages`. */
+function plural(value, noun) {
+	return value === 1 ? noun : `${noun}s`;
+}
+/** `count(2, 'page')` is `2 pages`. */
+function count(value, noun) {
+	return `${value} ${plural(value, noun)}`;
+}
+/**
+* Element markup on one line, optionally bounded: one minified page must not be
+* able to fill a report or run past a terminal.
+*/
+function collapse(html, max) {
+	const flat = html.replace(/\s+/g, " ").trim();
+	if (max === void 0 || flat.length <= max) return flat;
+	return `${flat.slice(0, max - 1)}…`;
+}
+/** `WCAG 1.1.1, EN 301 549 9.1.1.1`, in that order, or an empty string. */
+function standardsReference(successCriteria, enClauses) {
+	return [...successCriteria.map((criterion) => `WCAG ${criterion}`), ...enClauses.map((clause) => `EN 301 549 ${clause}`)].join(", ");
+}
+//#endregion
+export { plural as a, escapeText as i, count as n, standardsReference as o, escapeAttribute as r, collapse as t };

package/dist/vite/index.d.ts

@@ -0,0 +1,39 @@
+import { n as IntegrationOptions, t as BuildAuditError } from "../run-BMASMmwO.js";
+//#region src/vite/index.d.ts
+interface EaaKitPluginOptions extends IntegrationOptions {
+  /**
+   * Directory to audit, relative to the Vite root. Defaults to the build's own
+   * `outDir`, which is the only place the plugin can know the files went.
+   */
+  directory?: string;
+}
+/**
+ * The parts of Vite this plugin touches, described structurally.
+ *
+ * So the published .d.ts does not reference vite, and installing eaa-kit in a
+ * project that has none costs nothing and still typechecks. The same reasoning
+ * as the Astro integration and the Playwright runner.
+ */
+interface ResolvedConfigLike {
+  root: string;
+  build: {
+    outDir: string;
+  };
+  logger?: {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+  };
+}
+interface VitePluginLike {
+  name: string;
+  /** Build only: a dev server writes nothing to audit. */
+  apply: 'build';
+  /** Runs after the bundle is written, which is the earliest the files exist. */
+  enforce?: 'post';
+  configResolved(config: ResolvedConfigLike): void;
+  closeBundle(): Promise<void>;
+}
+declare function eaaKit(options?: EaaKitPluginOptions): VitePluginLike;
+//#endregion
+export { BuildAuditError, EaaKitPluginOptions, ResolvedConfigLike, VitePluginLike, eaaKit as default };

package/dist/vite/index.js

@@ -0,0 +1,40 @@
+import { n as auditBuild, t as BuildAuditError } from "../run-DB34BSOZ.js";
+import path from "node:path";
+//#region src/vite/index.ts
+function eaaKit(options = {}) {
+	let directory;
+	let logger;
+	return {
+		name: "eaa-kit",
+		apply: "build",
+		enforce: "post",
+		configResolved(config) {
+			directory = path.resolve(config.root, options.directory ?? config.build.outDir);
+			logger = prefixed(config.logger);
+		},
+		async closeBundle() {
+			if (directory === void 0 || logger === void 0) throw new BuildAuditError("eaa-kit: the plugin was not given a resolved Vite config");
+			await auditBuild(directory, options, logger);
+		}
+	};
+}
+/**
+* Vite's own logger where there is one, the console otherwise.
+*
+* Prefixed either way: a line about accessibility in the middle of a build log
+* needs to say what produced it.
+*/
+function prefixed(logger) {
+	const write = (level, message) => {
+		const line = `eaa-kit: ${message}`;
+		if (logger === void 0) process.stderr.write(`${line}\n`);
+		else logger[level](line);
+	};
+	return {
+		info: (message) => write("info", message),
+		warn: (message) => write("warn", message),
+		error: (message) => write("error", message)
+	};
+}
+//#endregion
+export { BuildAuditError, eaaKit as default };

package/dist/webpack/index.d.ts

@@ -0,0 +1,33 @@
+import { n as IntegrationOptions, t as BuildAuditError } from "../run-BMASMmwO.js";
+//#region src/webpack/index.d.ts
+/** The part of a webpack compilation this reads. */
+interface CompilationLike {
+  /** Non-empty when the build itself failed; there is nothing to audit then. */
+  errors: readonly unknown[];
+}
+/** The part of the webpack compiler this plugin touches. */
+interface CompilerLike {
+  options: {
+    output?: {
+      path?: string;
+    };
+    mode?: string;
+  };
+  watchMode?: boolean;
+  hooks: {
+    afterEmit: {
+      tapPromise(name: string, handler: (compilation: CompilationLike) => Promise<void>): void;
+    };
+  };
+}
+interface EaaKitWebpackOptions extends IntegrationOptions {
+  /** Directory to audit. Defaults to webpack's own `output.path`. */
+  directory?: string;
+}
+declare class EaaKitWebpackPlugin {
+  private readonly options;
+  constructor(options?: EaaKitWebpackOptions);
+  apply(compiler: CompilerLike): void;
+}
+//#endregion
+export { BuildAuditError, CompilationLike, CompilerLike, EaaKitWebpackOptions, EaaKitWebpackPlugin as default };

package/dist/webpack/index.js

@@ -0,0 +1,20 @@
+import { n as auditBuild, r as stderrLogger, t as BuildAuditError } from "../run-DB34BSOZ.js";
+import path from "node:path";
+//#region src/webpack/index.ts
+var EaaKitWebpackPlugin = class {
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	apply(compiler) {
+		compiler.hooks.afterEmit.tapPromise("eaa-kit", async (compilation) => {
+			if (compiler.watchMode === true) return;
+			if (compilation.errors.length > 0) return;
+			const output = this.options.directory ?? compiler.options.output?.path;
+			if (output === void 0) throw new BuildAuditError("eaa-kit: webpack has no output.path, so there is no directory to audit. Set one, or pass `directory` to the plugin.");
+			await auditBuild(path.resolve(output), this.options, stderrLogger());
+		});
+	}
+};
+//#endregion
+export { BuildAuditError, EaaKitWebpackPlugin as default };