@svelte-vitals/vite 0.6.0 → 0.7.0

package/dist/{chunk-GISWUGBL.js → chunk-MICKONGB.js}

@@ -1,5 +1,5 @@
 // src/providers/rendered/parse-html.ts
-import { parse } from "node-html-parser";
+import { parse, HTMLElement } from "node-html-parser";
 function attrValue(v) {
   return v !== void 0 && v.trim().length > 0 ? "static" : "absent";
 }
@@ -8,20 +8,35 @@ function parseHtmlHead(html) {
   const head = root.querySelector("head") ?? root;
   const tags = [];
   const title = head.querySelector("title");
-  if (title) tags.push({ kind: "title", presence: "own", value: attrValue(title.text) });
+  if (title) {
+    const text = title.text;
+    tags.push({
+      kind: "title",
+      presence: "own",
+      value: attrValue(text),
+      ...text && text.trim().length > 0 ? { text } : {}
+    });
+  }
   for (const meta of head.querySelectorAll("meta")) {
     const name = meta.getAttribute("name");
     const property = meta.getAttribute("property");
+    const charset = meta.getAttribute("charset");
+    if (charset != null) {
+      tags.push({ kind: "meta", name: "charset", presence: "own", value: attrValue(charset) });
+      continue;
+    }
     if (!name && !property) continue;
     const content = name === "robots" ? meta.getAttribute("content") : null;
     const noindex = content != null && /(^|[\s,])(noindex|none)([\s,]|$)/i.test(content);
+    const descText = name === "description" ? meta.getAttribute("content") : null;
     tags.push({
       kind: "meta",
       ...name ? { name } : {},
       ...property ? { property } : {},
       presence: "own",
       value: attrValue(meta.getAttribute("content")),
-      ...noindex ? { noindex: true } : {}
+      ...noindex ? { noindex: true } : {},
+      ...descText && descText.trim().length > 0 ? { text: descText } : {}
     });
   }
   for (const link of head.querySelectorAll("link")) {
@@ -29,24 +44,44 @@ function parseHtmlHead(html) {
     if (!rel) continue;
     const asAttr = link.getAttribute("as");
     const hasCrossorigin = link.hasAttribute("crossorigin");
+    const hreflang = link.getAttribute("hreflang");
     tags.push({
       kind: "link",
       rel,
       presence: "own",
       value: attrValue(link.getAttribute("href")),
       ...asAttr != null ? { hasAs: true, as: asAttr } : {},
-      ...hasCrossorigin ? { hasCrossorigin: true } : {}
+      ...hasCrossorigin ? { hasCrossorigin: true } : {},
+      // Keep a literal empty hreflang="" (present-but-invalid) so SEO026 can flag it.
+      ...hreflang != null ? { hreflang } : {}
     });
   }
   for (const script of head.querySelectorAll("script")) {
     if (script.getAttribute("type") === "application/ld+json") {
-      tags.push({ kind: "jsonld", presence: "own", value: attrValue(script.text) });
+      const raw = script.rawText;
+      tags.push({
+        kind: "jsonld",
+        presence: "own",
+        value: attrValue(raw),
+        ...raw && raw.trim().length > 0 ? { jsonld: raw } : {}
+      });
     }
   }
   const htmlEl = root.querySelector("html");
   const lang = htmlEl?.getAttribute("lang");
   const htmlLang = lang === void 0 || lang === null ? { presence: "none", value: "absent" } : { presence: "own", value: attrValue(lang) };
-  return { tags, htmlLang };
+  const headings = [];
+  const collectHeadings = (el) => {
+    for (const child of el.childNodes) {
+      if (child instanceof HTMLElement) {
+        const m = /^h([1-6])$/i.exec(child.rawTagName ?? "");
+        if (m) headings.push(Number(m[1]));
+        collectHeadings(child);
+      }
+    }
+  };
+  collectHeadings(root.querySelector("body") ?? root);
+  return { tags, htmlLang, headings };
 }
 
 export {

package/dist/hooks/index.js

@@ -1,6 +1,6 @@
 import {
   parseHtmlHead
-} from "../chunk-GISWUGBL.js";
+} from "../chunk-MICKONGB.js";
 
 // src/hooks/handle.ts
 import { DEV } from "esm-env";
@@ -63,10 +63,13 @@ async function postIngest(origin, route, results) {
 }
 async function analyzeAndWarn(html, route, origin, rules, config, lastSignature) {
   try {
-    const { tags, htmlLang } = parseHtmlHead(html);
+    const { tags, htmlLang, headings: levels } = parseHtmlHead(html);
     const head = { route, source: "rendered", tags, file: route };
+    const headings = [
+      { route, headings: levels.map((level) => ({ level, line: 0, file: route })) }
+    ];
     const project = { hasRobotsTxt: true, hasSitemap: true, htmlLang };
-    const results = applyRuleSeverities(await runRules(rules, { heads: [head], project, config }), config);
+    const results = applyRuleSeverities(await runRules(rules, { heads: [head], headings, project, config }), config);
     const signature = findingSignature(results, config);
     if (lastSignature.get(route) === signature) return;
     lastSignature.set(route, signature);

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   parseHtmlHead
-} from "./chunk-GISWUGBL.js";
+} from "./chunk-MICKONGB.js";
 
 // src/plugin.ts
 import { existsSync } from "fs";
@@ -38,17 +38,24 @@ async function collectRenderedHeads(prerenderPagesDir) {
     files.map(async (rel) => ({ rel, parsed: parseHtmlHead(await readFile(join(prerenderPagesDir, rel), "utf8")) }))
   );
   const heads = [];
+  const headings = [];
   let htmlLang = { presence: "none", value: "absent" };
   for (const { rel, parsed } of parsedFiles) {
     if (htmlLang.presence === "none" && parsed.htmlLang.presence === "own") htmlLang = parsed.htmlLang;
+    const route = deriveRouteFromHtmlPath(rel);
     heads.push({
-      route: deriveRouteFromHtmlPath(rel),
+      route,
       source: "rendered",
       tags: parsed.tags,
       file: rel
     });
+    headings.push({
+      route,
+      // Rendered mode does not track source lines (line 0 = unknown); file is the HTML path.
+      headings: parsed.headings.map((level) => ({ level, line: 0, file: rel }))
+    });
   }
-  return { heads, htmlLang };
+  return { heads, headings, htmlLang };
 }
 
 // src/providers/rendered/project.ts
@@ -107,10 +114,10 @@ async function analyze(prerenderPagesDir, cwd, options) {
     rules: options.rules ?? {},
     failOn: options.failOn ?? "critical"
   });
-  const { heads, htmlLang } = await collectRenderedHeads(prerenderPagesDir);
+  const { heads, headings, htmlLang } = await collectRenderedHeads(prerenderPagesDir);
   const project = await collectRenderedProject(cwd, htmlLang);
   const results = applyRuleSeverities(
-    await runRules(selectRules(allRules, config), { heads, project, config }),
+    await runRules(selectRules(allRules, config), { heads, headings, project, config }),
     config
   );
   const { score } = computeScore(results, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svelte-vitals/vite",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Vite/SvelteKit plugin for svelte-vitals — analyzes prerendered HTML during vite build.",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "esm-env": "^1.2.2",
     "node-html-parser": "^6.1.13",
     "tinyglobby": "^0.2.17",
-    "@svelte-vitals/core": "0.13.0"
+    "@svelte-vitals/core": "0.14.0"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^2.0.0",