svelte-vitals 0.5.2 → 0.7.0

package/dist/bin.js

@@ -6,7 +6,7 @@ import {
   knownRuleIds,
   readPackageVersion,
   run
-} from "./chunk-LQPB2WAL.js";
+} from "./chunk-DVIKLRTP.js";
 
 // src/bin.ts
 import mri from "mri";

package/dist/{chunk-LQPB2WAL.js → chunk-DVIKLRTP.js}

@@ -164,6 +164,13 @@ function attrValue(attributes, name) {
   if (v && v.type === "ExpressionTag") return "dynamic";
   return "absent";
 }
+function lineOf(source, offset) {
+  if (typeof offset !== "number" || offset < 0) return 0;
+  let line = 1;
+  const end = Math.min(offset, source.length);
+  for (let i = 0; i < end; i++) if (source[i] === "\n") line++;
+  return line;
+}
 function findAttr(attributes, name) {
   if (!Array.isArray(attributes)) return void 0;
   return attributes.find((a) => a?.type === "Attribute" && a.name === name);
@@ -231,16 +238,39 @@ function collectComponents(node, acc) {
     if (key in node) collectComponents(node[key], acc);
   }
 }
+function collectImages(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectImages(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "img") {
+    const attrs = node.attributes ?? [];
+    const hasSpread = attrs.some((a) => a?.type === "SpreadAttribute");
+    acc.push({
+      hasWidth: hasSpread || Boolean(findAttr(attrs, "width")),
+      hasHeight: hasSpread || Boolean(findAttr(attrs, "height")),
+      hasLoading: hasSpread || Boolean(findAttr(attrs, "loading")),
+      line: lineOf(source, node.start)
+    });
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectImages(node[key], source, acc);
+  }
+}
 function parseFile(source, filename) {
   const ast = parse(source, { modern: true, filename });
   const heads = [];
   collectSvelteHeads(ast.fragment ?? ast, heads);
   const components = [];
   collectComponents(ast.fragment ?? ast, components);
+  const images = [];
+  collectImages(ast.fragment ?? ast, source, images);
   return {
     headTags: heads.flatMap(tagsFromHead),
     components,
-    imports: collectImports(ast)
+    imports: collectImports(ast),
+    images
   };
 }
 
@@ -403,9 +433,13 @@ async function resolveRoute(rt, cwd, pageRel, config) {
   const composed = /* @__PURE__ */ new Map();
   let broadOwn = false;
   let broadInherited = false;
+  const images = [];
   for (const { rel, isPage } of files) {
     const source = await rt.readFile(rt.join(cwd, rel));
     const parsed = parseFile(source, rel);
+    for (const img of parsed.images) {
+      images.push({ ...img, file: rel });
+    }
     const resolved = await resolveFileTags(rt, cwd, rel, parsed, config, MAX_DEPTH, /* @__PURE__ */ new Set([rel]));
     for (const tag of resolved.tags) {
       composed.set(tagKey(tag), { ...tag, presence: isPage ? "own" : "inherited", file: rel });
@@ -422,20 +456,119 @@ async function resolveRoute(rt, cwd, pageRel, config) {
       if (!composed.has(key)) composed.set(key, { ...tag, presence });
     }
   }
+  const route = deriveRoute(pageRel);
   return {
-    route: deriveRoute(pageRel),
-    source: "static",
-    tags: [...composed.values()],
-    file: pageRel
+    head: { route, source: "static", tags: [...composed.values()], file: pageRel },
+    images: { route, images }
   };
 }
-var sourceHeadProvider = {
-  mode: "static",
-  async collect(rt, cwd, config = defaultConfig) {
-    const pages = await enumerateRoutePages(rt, cwd);
-    return Promise.all(pages.map((page) => resolveRoute(rt, cwd, page, config)));
+async function collectRoutes(rt, cwd, config = defaultConfig) {
+  const pages = await enumerateRoutePages(rt, cwd);
+  const facts = await Promise.all(pages.map((page) => resolveRoute(rt, cwd, page, config)));
+  return {
+    heads: facts.map((f) => f.head),
+    images: facts.map((f) => f.images)
+  };
+}
+
+// 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";
@@ -477,24 +610,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;
@@ -513,10 +628,14 @@ async function analyzeProject(opts = {}) {
   });
   await detectProject(rt, cwd);
   const matches = routeMatcher(opts.route);
-  const heads = (await sourceHeadProvider.collect(rt, cwd, config)).filter((h) => matches(h.route));
+  const collected = await collectRoutes(rt, cwd, config);
+  const heads = collected.heads.filter((h) => matches(h.route));
+  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, 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 = {}) {
@@ -576,11 +695,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>;
 

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-vitals",
-  "version": "0.5.2",
+  "version": "0.7.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.7.0"
+    "@svelte-vitals/core": "0.8.0"
   },
   "devDependencies": {
     "@types/node": "^24.7.0"