svelte-vitals 0.6.0 → 0.8.0

package/dist/bin.js

@@ -6,7 +6,7 @@ import {
   knownRuleIds,
   readPackageVersion,
   run
-} from "./chunk-LWN65ZOR.js";
+} from "./chunk-L6IHVJKF.js";
 
 // src/bin.ts
 import mri from "mri";
@@ -85,6 +85,7 @@ Options:
   --json                      Alias for --reporter=json
   --fail-on <severity>        Fail (exit 1) when any finding reaches this severity: critical | warning | info
   --fail-on-warning           Alias for --fail-on=warning
+  --min-health <0-100>        Fail (exit 1) when the combined Health score is below this value
   --rules <ids>               Comma-separated rule ids to enable (all others disabled)
   --ignore <ids>              Comma-separated rule ids to disable
   -h, --help                  Show this help
@@ -99,7 +100,7 @@ async function main() {
   const argv = mri(process.argv.slice(2), {
     alias: { h: "help", v: "version" },
     boolean: ["by-route", "json", "fail-on-warning"],
-    string: ["meta-components", "treat-dynamic-as", "route", "fail-on", "reporter", "rules", "ignore"]
+    string: ["meta-components", "treat-dynamic-as", "route", "fail-on", "reporter", "rules", "ignore", "min-health"]
   });
   if (argv.help) {
     console.log(HELP);
@@ -113,7 +114,17 @@ async function main() {
   for (const w of warnings) console.error(w);
   for (const e of errors) console.error(e);
   if (!options) process.exit(2);
-  const code = await run(options);
+  const minHealthRaw = argv["min-health"];
+  let minHealth;
+  if (minHealthRaw !== void 0) {
+    const n = Number(minHealthRaw);
+    if (!Number.isFinite(n) || n < 0 || n > 100) {
+      console.error(`svelte-vitals: invalid --min-health '${minHealthRaw}'; expected a number 0-100.`);
+      process.exit(2);
+    }
+    minHealth = n;
+  }
+  const code = await run({ ...options, minHealth });
   process.exit(code);
 }
 void main();

package/dist/{chunk-LWN65ZOR.js → chunk-L6IHVJKF.js}

@@ -9,6 +9,7 @@ import {
   formatGithubReport,
   summarize,
   hasFailureAtOrAbove,
+  computeHealth,
   defineConfig,
   selectRules,
   applyRuleSeverities
@@ -471,6 +472,105 @@ async function collectRoutes(rt, cwd, config = defaultConfig) {
   };
 }
 
+// src/providers/source/a11y.ts
+import { compile } from "svelte/compiler";
+import { defaultConfig as defaultConfig2 } from "@svelte-vitals/core";
+
+// src/rules-config.ts
+import { allRules } from "@svelte-vitals/core";
+var KNOWN_IDS = new Set(allRules.map((r) => r.id));
+var A11Y_CODE_PREFIX = "a11y_";
+var A11Y_CATEGORY_KEY = "a11y_category";
+function findUnknownRuleIds(ids) {
+  return [
+    ...new Set(ids.filter((id) => !KNOWN_IDS.has(id) && !(id.startsWith(A11Y_CODE_PREFIX) && id !== A11Y_CATEGORY_KEY)))
+  ];
+}
+function knownRuleIds() {
+  return [...KNOWN_IDS].sort();
+}
+function buildRulesConfig(allow, ignore) {
+  const rules = {};
+  if (allow.length > 0) {
+    for (const r of allRules) if (!allow.includes(r.id)) rules[r.id] = "off";
+    if (!allow.some((id) => id.startsWith(A11Y_CODE_PREFIX))) rules[A11Y_CATEGORY_KEY] = "off";
+  }
+  for (const id of ignore) rules[id] = "off";
+  return rules;
+}
+
+// src/providers/source/a11y.ts
+function firstLine(message) {
+  return message.split("\n")[0] ?? message;
+}
+function fileA11y(source, rel) {
+  let warnings;
+  try {
+    ({ warnings } = compile(source, { generate: false, filename: rel }));
+  } catch {
+    return { ok: false, warnings: [] };
+  }
+  const out = [];
+  for (const w of warnings) {
+    if (w.code.startsWith(A11Y_CODE_PREFIX)) {
+      out.push({
+        code: w.code,
+        message: firstLine(w.message),
+        line: w.start?.line ?? 0
+      });
+    }
+  }
+  return { ok: true, warnings: out };
+}
+async function collectA11y(rt, cwd, config = defaultConfig2) {
+  if (config.rules[A11Y_CATEGORY_KEY] === "off") return [];
+  const pages = await enumerateRoutePages(rt, cwd);
+  const cache = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const page of pages) {
+    const files = await chainFiles(rt, cwd, page);
+    const route = deriveRoute(page);
+    const fails = [];
+    let compiledAll = true;
+    for (const { rel } of files) {
+      let entry = cache.get(rel);
+      if (!entry) {
+        const source = await rt.readFile(rt.join(cwd, rel));
+        entry = fileA11y(source, rel);
+        cache.set(rel, entry);
+      }
+      if (!entry.ok) compiledAll = false;
+      for (const w of entry.warnings) {
+        if (config.rules[w.code] === "off") continue;
+        fails.push({
+          id: w.code,
+          category: "a11y",
+          severity: "warning",
+          detection: { presence: "none", value: "absent" },
+          route,
+          location: rel,
+          ...w.line > 0 ? { line: w.line } : {},
+          message: w.message,
+          docsUrl: `https://svelte.dev/e/${w.code}`
+        });
+      }
+    }
+    if (fails.length > 0) {
+      results.push(...fails);
+    } else if (compiledAll) {
+      results.push({
+        id: "a11y",
+        category: "a11y",
+        severity: "warning",
+        detection: { presence: "own", value: "static" },
+        route,
+        message: "Accessibility"
+      });
+    }
+  }
+  return results;
+}
+
 // src/version.ts
 import { readFileSync } from "fs";
 function readPackageVersion() {
@@ -511,24 +611,6 @@ function isAutoDetectedGithub(explicit, env = process.env) {
   return !explicit && !isReporterName(env.SVELTE_VITALS_REPORTER) && !isAgentEnv(env) && isGithubActionsEnv(env);
 }
 
-// src/rules-config.ts
-import { allRules } from "@svelte-vitals/core";
-var KNOWN_IDS = new Set(allRules.map((r) => r.id));
-function findUnknownRuleIds(ids) {
-  return [...new Set(ids.filter((id) => !KNOWN_IDS.has(id)))];
-}
-function knownRuleIds() {
-  return [...KNOWN_IDS].sort();
-}
-function buildRulesConfig(allow, ignore) {
-  const rules = {};
-  if (allow.length > 0) {
-    for (const r of allRules) if (!allow.includes(r.id)) rules[r.id] = "off";
-  }
-  for (const id of ignore) rules[id] = "off";
-  return rules;
-}
-
 // src/index.ts
 function routeMatcher(glob) {
   if (!glob) return () => true;
@@ -552,12 +634,18 @@ async function analyzeProject(opts = {}) {
   const images = collected.images.filter((i) => matches(i.route));
   const project = await collectProjectFacts(rt, cwd);
   const rules = selectRules(allRules2, config);
-  const results = applyRuleSeverities(await runRules(rules, { heads, images, project, config }), config);
+  const a11y = (await collectA11y(rt, cwd, config)).filter((r) => r.route === void 0 || matches(r.route));
+  const ruleResults = await runRules(rules, { heads, images, project, config });
+  const results = applyRuleSeverities([...ruleResults, ...a11y], config);
   return { results, config, version: readPackageVersion() };
 }
 async function run(opts = {}) {
   const log = opts.log ?? ((line) => console.log(line));
   const errorLog = opts.errorLog ?? ((line) => console.error(line));
+  if (opts.minHealth != null && (!Number.isFinite(opts.minHealth) || opts.minHealth < 0 || opts.minHealth > 100)) {
+    errorLog(`svelte-vitals: invalid minHealth '${opts.minHealth}'; expected a number 0-100.`);
+    return 2;
+  }
   let analysis;
   try {
     analysis = await analyzeProject({
@@ -603,7 +691,9 @@ async function run(opts = {}) {
       log(formatConsoleReport(results, config, { byRoute: opts.byRoute ?? false }));
     }
     const summary = summarize(results, config);
-    return hasFailureAtOrAbove(summary, config.failOn) ? 1 : 0;
+    const failBySeverity = hasFailureAtOrAbove(summary, config.failOn);
+    const failByHealth = opts.minHealth != null && computeHealth(results, config).health < opts.minHealth;
+    return failBySeverity || failByHealth ? 1 : 0;
   } catch (err) {
     errorLog(`svelte-vitals: ${err instanceof Error ? err.message : String(err)}`);
     return 2;
@@ -612,11 +702,11 @@ async function run(opts = {}) {
 
 export {
   ProjectError,
-  readPackageVersion,
-  isReporterName,
   findUnknownRuleIds,
   knownRuleIds,
   buildRulesConfig,
+  readPackageVersion,
+  isReporterName,
   routeMatcher,
   analyzeProject,
   run

package/dist/index.d.ts

@@ -16,6 +16,10 @@ declare function knownRuleIds(): string[];
  * (--ignore). An allow-list disables every rule not listed; deny always wins.
  * Callers should reject unknown ids first (see findUnknownRuleIds) so a typo in
  * --rules can't silently disable every rule.
+ *
+ * When the allow-list is non-empty and contains no `a11y_*` entries, the
+ * `A11Y_CATEGORY_KEY` sentinel is set to `'off'`; `collectA11y` checks this key
+ * to suppress the entire Accessibility category.
  */
 declare function buildRulesConfig(allow: string[], ignore: string[]): Record<string, RuleSetting>;
 
@@ -33,6 +37,8 @@ interface RunOptions {
     rules?: Record<string, RuleSetting>;
     /** Override process.env for reporter auto-detection (mainly useful in tests). */
     env?: NodeJS.ProcessEnv;
+    /** Fail (exit 1) when the combined Health score is below this value (0–100). */
+    minHealth?: number;
 }
 declare function routeMatcher(glob: string | undefined): (route: string) => boolean;
 interface AnalyzeOptions {

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   knownRuleIds,
   routeMatcher,
   run
-} from "./chunk-LWN65ZOR.js";
+} from "./chunk-L6IHVJKF.js";
 export {
   ProjectError,
   analyzeProject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-vitals",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "A SvelteKit SEO checker — not a runtime Web Vitals reporter. Static analysis of your routes' head metadata.",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "mri": "^1.2.0",
     "svelte": "^5.56.3",
     "tinyglobby": "^0.2.17",
-    "@svelte-vitals/core": "0.8.0"
+    "@svelte-vitals/core": "0.9.0"
   },
   "devDependencies": {
     "@types/node": "^24.7.0"