svelte-vitals 0.14.0 → 0.15.0

package/dist/bin.js

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

package/dist/{chunk-YMRN4VPN.js → chunk-2NZBWTKF.js}

@@ -77,8 +77,11 @@ async function detectProject(rt, cwd) {
   );
 }
 async function enumerateRoutePages(rt, cwd) {
-  const pages = await rt.glob(`${ROUTES_DIR}/**/+page.svelte`, cwd);
-  return pages.sort();
+  const [plain, breakout] = await Promise.all([
+    rt.glob(`${ROUTES_DIR}/**/+page.svelte`, cwd),
+    rt.glob(`${ROUTES_DIR}/**/+page@*.svelte`, cwd)
+  ]);
+  return [.../* @__PURE__ */ new Set([...plain, ...breakout])].sort();
 }
 async function existsAny(rt, cwd, paths) {
   const found = await Promise.all(paths.map((p) => rt.exists(rt.join(cwd, p))));
@@ -363,6 +366,109 @@ function parseFile(source, filename) {
     headings
   };
 }
+function isConstantListEach(node) {
+  const expr = node?.expression;
+  return expr?.type === "ArrayExpression" && Array.isArray(expr.elements) && !expr.elements.some((el) => el?.type === "SpreadElement");
+}
+function collectEachBlocks(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectEachBlocks(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "EachBlock" && !isConstantListEach(node)) {
+    acc.push({ hasKey: node.key != null, line: lineOf(source, node.start) });
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectEachBlocks(node[key], source, acc);
+  }
+}
+function walkEstree(node, visit) {
+  if (Array.isArray(node)) {
+    for (const child of node) walkEstree(child, visit);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    walkEstree(node[key], visit);
+  }
+}
+function isEffectCall(node) {
+  const c = node?.callee;
+  if (c?.type === "Identifier") return c.name === "$effect";
+  if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$effect") {
+    return c.property?.type === "Identifier" && c.property.name === "pre";
+  }
+  return false;
+}
+function isStateDeclaration(node) {
+  const c = node?.callee;
+  if (c?.type === "Identifier") return c.name === "$state";
+  if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$state") {
+    return c.property?.type === "Identifier" && (c.property.name === "raw" || c.property.name === "frozen");
+  }
+  return false;
+}
+function bodyOnlyAssignsState(fn, stateNames) {
+  const isStateAssign = (expr) => expr?.type === "AssignmentExpression" && expr.operator === "=" && expr.left?.type === "Identifier" && stateNames.has(expr.left.name);
+  const body = fn?.body;
+  if (!body) return false;
+  if (body.type !== "BlockStatement") return isStateAssign(body);
+  if (body.body.length === 0) return false;
+  return body.body.every((s) => s?.type === "ExpressionStatement" && isStateAssign(s.expression));
+}
+var URL_ATTRS = ["href", "src", "action", "formaction"];
+function collectSecurityFacts(node, source, htmlTags, jsUrls) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectSecurityFacts(child, source, htmlTags, jsUrls);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "HtmlTag") htmlTags.push({ line: lineOf(source, node.start) });
+  if ((node.type === "RegularElement" || node.type === "SvelteElement") && Array.isArray(node.attributes)) {
+    for (const name of URL_ATTRS) {
+      const attr = findAttr(node.attributes, name);
+      if (!attr) continue;
+      const value = attrTextOf(attr);
+      if (value !== void 0 && /^\s*javascript:/i.test(value)) {
+        jsUrls.push({ line: lineOf(source, attr.start ?? node.start) });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectSecurityFacts(node[key], source, htmlTags, jsUrls);
+  }
+}
+function parseComponentFacts(source, filename) {
+  const ast = parse(source, { modern: true, filename });
+  const eachBlocks = [];
+  collectEachBlocks(ast.fragment ?? ast, source, eachBlocks);
+  const htmlTags = [];
+  const javascriptUrls = [];
+  collectSecurityFacts(ast.fragment ?? ast, source, htmlTags, javascriptUrls);
+  const effects = [];
+  const program = ast.instance?.content;
+  if (program) {
+    const stateNames = /* @__PURE__ */ new Set();
+    walkEstree(program, (n) => {
+      if (n.type === "VariableDeclarator" && n.init && isStateDeclaration(n.init) && n.id?.type === "Identifier") {
+        stateNames.add(n.id.name);
+      }
+    });
+    walkEstree(program, (n) => {
+      if (n.type !== "CallExpression" || !isEffectCall(n)) return;
+      const fn = n.arguments?.[0];
+      const isFn = fn?.type === "ArrowFunctionExpression" || fn?.type === "FunctionExpression";
+      effects.push({
+        line: lineOf(source, n.start),
+        assignsOnlyState: isFn ? bodyOnlyAssignsState(fn, stateNames) : false
+      });
+    });
+  }
+  return { eachBlocks, effects, htmlTags, javascriptUrls };
+}
 
 // src/providers/source/adapters/svelte-meta-tags.ts
 function findAttr2(attributes, name) {
@@ -519,27 +625,68 @@ var MAX_DEPTH = 5;
 function isGroupSegment(segment) {
   return /^\(.+\)$/.test(segment);
 }
+function dirOf(rel) {
+  const i = rel.lastIndexOf("/");
+  return i >= 0 ? rel.slice(0, i) : "";
+}
+function dirSegments(dir) {
+  const extra = dir.slice(ROUTES_DIR2.length);
+  return extra.length === 0 ? [] : extra.split("/").filter(Boolean);
+}
+function dirKey(segs) {
+  return segs.length === 0 ? ROUTES_DIR2 : `${ROUTES_DIR2}/${segs.join("/")}`;
+}
+function parseAt(rel) {
+  const file = rel.slice(rel.lastIndexOf("/") + 1);
+  const m = /^\+(?:page|layout)@(.*)\.svelte$/.exec(file);
+  return m ? m[1] : null;
+}
+function atTarget(rel, dirSegs, strictAncestor = false) {
+  const at = parseAt(rel);
+  if (at === null) return null;
+  if (at === "") return [];
+  const haystack = strictAncestor ? dirSegs.slice(0, -1) : dirSegs;
+  const i = haystack.lastIndexOf(at);
+  return i >= 0 ? dirSegs.slice(0, i + 1) : null;
+}
 function deriveRoute(pageRel) {
-  const inner = pageRel.slice(`${ROUTES_DIR2}/`.length, -"/+page.svelte".length);
-  const segments = inner.length === 0 ? [] : inner.split("/").filter((s) => !isGroupSegment(s));
+  const segments = dirSegments(dirOf(pageRel)).filter((s) => !isGroupSegment(s));
   return "/" + segments.join("/");
 }
-async function chainFiles(rt, cwd, pageRel) {
-  const dir = pageRel.slice(0, -"/+page.svelte".length);
-  const extra = dir.slice(ROUTES_DIR2.length);
-  const segments = extra.length === 0 ? [] : extra.split("/").filter(Boolean);
-  const files = [];
-  let prefix = ROUTES_DIR2;
-  for (let i = 0; i <= segments.length; i++) {
-    if (i > 0) prefix = `${prefix}/${segments[i - 1]}`;
-    const layout = `${prefix}/+layout.svelte`;
-    if (await rt.exists(rt.join(cwd, layout))) files.push({ rel: layout, isPage: false });
-  }
-  files.push({ rel: pageRel, isPage: true });
-  return files;
-}
-async function resolveRoute(rt, cwd, pageRel, config) {
-  const files = await chainFiles(rt, cwd, pageRel);
+async function collectLayouts(rt, cwd) {
+  const [plain, breakout] = await Promise.all([
+    rt.glob(`${ROUTES_DIR2}/**/+layout.svelte`, cwd),
+    rt.glob(`${ROUTES_DIR2}/**/+layout@*.svelte`, cwd)
+  ]);
+  const map = /* @__PURE__ */ new Map();
+  for (const rel of [...plain, ...breakout]) map.set(dirOf(rel), rel);
+  return map;
+}
+function layoutAtOrAbove(segs, layouts) {
+  for (let j = segs.length; j >= 0; j--) {
+    const rel = layouts.get(dirKey(segs.slice(0, j)));
+    if (rel) return { segs: segs.slice(0, j), rel };
+  }
+  return null;
+}
+function chainFiles(pageRel, layouts) {
+  const pageSegs = dirSegments(dirOf(pageRel));
+  let dir = atTarget(pageRel, pageSegs) ?? pageSegs;
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (dir !== null) {
+    const found = layoutAtOrAbove(dir, layouts);
+    if (!found || seen.has(found.rel)) break;
+    seen.add(found.rel);
+    chain.unshift(found.rel);
+    const reset = atTarget(found.rel, found.segs, true);
+    dir = reset !== null && reset.length < found.segs.length ? reset : found.segs.slice(0, -1);
+    if (dir.length === 0 && found.segs.length === 0) dir = null;
+  }
+  return [...chain.map((rel) => ({ rel, isPage: false })), { rel: pageRel, isPage: true }];
+}
+async function resolveRoute(rt, cwd, pageRel, config, layouts) {
+  const files = chainFiles(pageRel, layouts);
   const composed = /* @__PURE__ */ new Map();
   let broadOwn = false;
   let broadInherited = false;
@@ -578,8 +725,8 @@ async function resolveRoute(rt, cwd, pageRel, 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)));
+  const [pages, layouts] = await Promise.all([enumerateRoutePages(rt, cwd), collectLayouts(rt, cwd)]);
+  const facts = await Promise.all(pages.map((page) => resolveRoute(rt, cwd, page, config, layouts)));
   return {
     heads: facts.map((f) => f.head),
     images: facts.map((f) => f.images),
@@ -587,6 +734,21 @@ async function collectRoutes(rt, cwd, config = defaultConfig) {
   };
 }
 
+// src/providers/source/components.ts
+async function collectComponentFacts(rt, cwd) {
+  const files = await rt.glob("src/**/*.svelte", cwd);
+  return Promise.all(
+    files.sort().map(async (rel) => {
+      try {
+        const source = await rt.readFile(rt.join(cwd, rel));
+        return { file: rel, ...parseComponentFacts(source, rel) };
+      } catch {
+        return { file: rel, eachBlocks: [], effects: [], htmlTags: [], javascriptUrls: [] };
+      }
+    })
+  );
+}
+
 // src/version.ts
 import { readFileSync } from "fs";
 function readPackageVersion() {
@@ -668,8 +830,12 @@ async function analyzeProject(opts = {}) {
   const images = collected.images.filter((i) => matches(i.route));
   const headings = collected.headings.filter((h) => matches(h.route));
   const project = await collectProjectFacts(rt, cwd);
+  const components = opts.route ? [] : await collectComponentFacts(rt, cwd);
   const rules = selectRules(allRules2, config);
-  const results = applyRuleSeverities(await runRules(rules, { heads, images, headings, project, config }), config);
+  const results = applyRuleSeverities(
+    await runRules(rules, { heads, images, headings, components, project, config }),
+    config
+  );
   return { results, config, version: readPackageVersion() };
 }
 async function run(opts = {}) {

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-vitals",
-  "version": "0.14.0",
+  "version": "0.15.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.15.0"
+    "@svelte-vitals/core": "0.16.0"
   },
   "devDependencies": {
     "@types/node": "^24.7.0"