crawlemon 0.3.0 → 0.3.2

package/README.md

@@ -6,6 +6,18 @@ Crawlemon is the SEO safety layer between code and production. It works like an
 
 No account, cloud connection, browser, AI provider, or API key is required.
 
+## What is new in 0.3.2
+
+- Accurate heading analysis across early `return` and ternary/`&&` branches, plus lazy `next/dynamic` imports — far fewer false "missing/duplicate `<h1>`" findings.
+- Thin-content detection counts component text and stops stripping JSX text inside `return` bodies.
+- Fixes metadata inheritance for multi-line site config (`export const x =` followed by the value), so pages no longer show phantom "missing meta description".
+
+## What is new in 0.3.1
+
+- Canonical URLs are no longer required on `robots: noindex` pages.
+- `<h1>` duplicates in mutually exclusive early-return branches (auth gates, loading/success/error states) are no longer reported.
+- Empty `alt` on dynamic-src decorative images (e.g. favicons) is no longer flagged.
+
 ## What is new in 0.3.0
 
 - Production-grade static resolution for Next.js: site config, `metadataBase`, title objects (`default`/`template`/`absolute`), and layout inheritance.
@@ -217,11 +229,11 @@ jobs:
       - name: Audit SEO
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.0 audit
+        run: npx --yes crawlemon@0.3.2 audit
 ```
 
 The exact package version is pinned so an upstream release cannot unexpectedly
-change your CI result. Update `crawlemon@0.3.0` deliberately when you are ready
+change your CI result. Update `crawlemon@0.3.2` deliberately when you are ready
 to adopt a newer version.
 
 With `CI=true`, the workflow fails when Crawlemon finds at least one error-level
@@ -236,7 +248,7 @@ working directory:
         working-directory: apps/web
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.0 audit
+        run: npx --yes crawlemon@0.3.2 audit
 ```
 
 ## Zero-configuration detection

package/dist/index.js

@@ -183,7 +183,7 @@ function parsePageSource(content, framework = "nextjs") {
       isInternal
     });
   }
-  const cleanBodyText = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\{[^{}]*\}/g, " ").replace(/\s+/g, " ").trim();
+  const cleanBodyText = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\{[^{}]*\}/g, (block) => /\b(return|function)\b|=>/.test(block) ? block : " ").replace(/\s+/g, " ").trim();
   const words = cleanBodyText.split(/\s+/).filter((word) => word.length > 2);
   const hasLittleContent = words.length < 20;
   return {
@@ -814,7 +814,13 @@ function absolutize(value, base) {
 function resolvePageMetadata(content, file, inherited, ctx) {
   const extract = extractNextMetadata(content, file, ctx.resolver);
   if (!extract) {
-    return inherited;
+    const clean = { ...inherited };
+    delete clean.titleDeclared;
+    delete clean.descriptionDeclared;
+    delete clean.canonicalDeclared;
+    delete clean.dynamicMetadata;
+    delete clean.metadataSource;
+    return clean;
   }
   return buildEffectiveMetadata(extract, inherited, { ...ctx, isLayout: false });
 }
@@ -1016,6 +1022,14 @@ function readStringEnd(text, index) {
   }
   return text.length;
 }
+function statementContinues(code) {
+  const trimmed = code.trimEnd();
+  if (!trimmed) return false;
+  if (trimmed.endsWith(";")) return false;
+  if (/=>$/.test(trimmed)) return true;
+  const last = trimmed[trimmed.length - 1];
+  return /[=+\-*/%&|?:,.<>]/.test(last);
+}
 function splitTopLevelStatements(code) {
   const out = [];
   let depth = 0;
@@ -1037,7 +1051,7 @@ function splitTopLevelStatements(code) {
       continue;
     }
     if (ch === "\n") {
-      if (depth === 0) flush(i);
+      if (depth === 0 && !(statementStart !== -1 && statementContinues(code.slice(statementStart, i)))) flush(i);
       i += 1;
       continue;
     }
@@ -1461,14 +1475,52 @@ function collectInlineHeadings(content) {
   }
   return headings.sort((a, b) => (a.line || 0) - (b.line || 0));
 }
-function localComponentImports(content, fromFile, resolver) {
-  const files = [];
+function textWordCount(content) {
+  const cleaned = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\{[^{}]*\}/g, (block) => /\b(return|function)\b|=>/.test(block) ? block : " ").replace(/\s+/g, " ").trim();
+  return cleaned.split(/\s+/).filter((word) => word.length > 2).length;
+}
+var CONTENT_WORD_THRESHOLD = 20;
+function pageHasMeaningfulContent(filePath, resolver) {
+  const visited = /* @__PURE__ */ new Set([filePath]);
+  let total = 0;
+  const enqueue = (file, queue2, depth) => {
+    if (!visited.has(file) && depth <= 3) queue2.push({ file, depth });
+  };
+  const queue = [];
+  let content = resolver.readModuleFile(filePath);
+  if (content === void 0) return false;
+  total += textWordCount(content);
+  if (total >= CONTENT_WORD_THRESHOLD) return true;
   for (const m of content.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) {
-    const spec = m[1];
-    const resolved = resolver.resolveModule(spec, fromFile);
-    if (resolved) files.push(resolved);
+    const resolved = resolver.resolveModule(m[1], filePath);
+    if (resolved) enqueue(resolved, queue, 1);
   }
-  return files;
+  while (queue.length > 0) {
+    const { file, depth } = queue.shift();
+    if (visited.has(file)) continue;
+    visited.add(file);
+    const nextContent = resolver.readModuleFile(file);
+    if (nextContent === void 0) continue;
+    total += textWordCount(nextContent);
+    if (total >= CONTENT_WORD_THRESHOLD) return true;
+    if (depth < 3) {
+      for (const m of nextContent.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) {
+        const resolved = resolver.resolveModule(m[1], file);
+        if (resolved) enqueue(resolved, queue, depth + 1);
+      }
+    }
+  }
+  return total >= CONTENT_WORD_THRESHOLD;
+}
+function localComponentImports(content, fromFile, resolver) {
+  const files = /* @__PURE__ */ new Set();
+  const add = (spec) => {
+    const resolved = resolver.resolveModule(spec, fromFile);
+    if (resolved) files.add(resolved);
+  };
+  for (const m of content.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) add(m[1]);
+  for (const m of content.matchAll(/(?:\bimport|require)\s*\(\s*["']([^"']+)["']/g)) add(m[1]);
+  return Array.from(files);
 }
 function fileHasFlag(content, flag) {
   const re = new RegExp(`\\b${flag}\\s*=\\s*false\\b`);
@@ -1547,7 +1599,7 @@ function discoverImportedH1(filePath, resolver, maxDepth = 3) {
     if (nextContent === void 0) continue;
     const h1s = collectInlineHeadings(nextContent).filter((h) => h.level === 1);
     if (h1s.length > 0) {
-      result.push(...h1s);
+      result.push(h1s[0]);
       continue;
     }
     for (const next of localComponentImports(nextContent, file, resolver)) {
@@ -1556,6 +1608,105 @@ function discoverImportedH1(filePath, resolver, maxDepth = 3) {
   }
   return result;
 }
+function countH1(text) {
+  const re = /<h1\b/g;
+  let count = 0;
+  while (re.exec(text)) count += 1;
+  return count;
+}
+function interpolationRegions(text) {
+  const regions = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "'" || ch === '"') {
+      const q = text[i];
+      i += 1;
+      while (i < text.length && text[i] !== q) i += 1;
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      let t = i + 1;
+      while (t < text.length && text[t] !== "`") {
+        if (text[t] === "\\") t += 1;
+        t += 1;
+      }
+      i = t + 1;
+      continue;
+    }
+    if (ch === "{") {
+      const end = readBalanced(text, i);
+      regions.push({ start: i, end });
+      i = end + 1;
+      continue;
+    }
+    i += 1;
+  }
+  return regions;
+}
+function findTopLevelTernary(text) {
+  let depth = 0;
+  let question = -1;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "'" || ch === '"') {
+      const q = ch;
+      i += 1;
+      while (i < text.length && text[i] !== q) i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      while (i < text.length && text[i] !== "`") i += 1;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth = Math.max(0, depth - 1);
+    else if (ch === "?" && depth === 0) {
+      question = i;
+      break;
+    }
+  }
+  if (question === -1) return null;
+  let depth2 = 0;
+  for (let i = question + 1; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth2 += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth2 = Math.max(0, depth2 - 1);
+    else if (ch === ":" && depth2 === 0) return { question, colon: i };
+  }
+  return null;
+}
+function computeBlockMaxH1(text) {
+  const regions = interpolationRegions(text);
+  let jsxLevelH1 = countH1(text);
+  let add = 0;
+  for (const region of regions) {
+    const inner = text.slice(region.start + 1, region.end);
+    jsxLevelH1 -= countH1(inner);
+    const ternary = findTopLevelTernary(inner);
+    if (ternary) {
+      const truePart = inner.slice(0, ternary.colon);
+      const falsePart = inner.slice(ternary.colon + 1);
+      add += Math.max(countH1(truePart), countH1(falsePart));
+    } else {
+      add += countH1(inner);
+    }
+  }
+  return jsxLevelH1 + add;
+}
+function computeH1Concurrency(content, h1Lines) {
+  const returnRe = /(?:^|[^A-Za-z0-9_$])return\s*(?:\(\s*)?</g;
+  const starts = [];
+  for (const match of content.matchAll(returnRe)) starts.push(match.index || 0);
+  if (starts.length === 0) return null;
+  let max = 0;
+  for (let index = 0; index < starts.length; index += 1) {
+    const blockText = content.slice(starts[index], index + 1 < starts.length ? starts[index + 1] : content.length);
+    max = Math.max(max, computeBlockMaxH1(blockText));
+  }
+  return max;
+}
 
 // ../next-adapter/src/scanner.ts
 function normalizeRouteGroup(segment) {
@@ -1698,6 +1849,15 @@ var NextJsAdapter = class {
                 headings.push(...discoverImportedH1(fullPath, resolver));
               }
               const dynamic = resolver ? dynamicParamsForFile(fullPath, resolver) : void 0;
+              const inlineH1 = parsed.headings.filter((h) => h.level === 1);
+              let maxConcurrentH1;
+              if (inlineH1.length > 0) {
+                const concurrency = computeH1Concurrency(content, inlineH1.map((h) => h.line || 0));
+                maxConcurrentH1 = concurrency === null ? inlineH1.length : concurrency;
+              } else {
+                maxConcurrentH1 = headings.some((h) => h.level === 1) ? 1 : 0;
+              }
+              const hasLittleContent = parsed.hasLittleContent && (!resolver || !pageHasMeaningfulContent(fullPath, resolver));
               routes.push({
                 route: routePath,
                 filePath: fullPath,
@@ -1706,11 +1866,12 @@ var NextJsAdapter = class {
                 images: parsed.images,
                 links: parsed.links,
                 textContent: parsed.textContent,
-                hasLittleContent: parsed.hasLittleContent,
+                hasLittleContent,
                 hasDynamicSegments: routePath.includes("["),
                 dynamicParams: dynamic?.dynamicParams,
                 generatedParams: dynamic?.generatedParams,
-                isRedirect: isRedirectOnly(content)
+                isRedirect: isRedirectOnly(content),
+                maxConcurrentH1
               });
             }
           }
@@ -1738,6 +1899,9 @@ var NextJsAdapter = class {
               if (routePath === "//" || routePath === "") routePath = "/";
               const content = fs3.readFileSync(fullPath, "utf8");
               const parsed = parsePageSource(content);
+              const inlineH1 = parsed.headings.filter((h) => h.level === 1);
+              const concurrency = computeH1Concurrency(content, inlineH1.map((h) => h.line || 0));
+              const maxConcurrentH1 = concurrency === null ? inlineH1.length : concurrency;
               routes.push({
                 route: routePath,
                 filePath: fullPath,
@@ -1747,7 +1911,8 @@ var NextJsAdapter = class {
                 links: parsed.links,
                 textContent: parsed.textContent,
                 hasLittleContent: parsed.hasLittleContent,
-                hasDynamicSegments: routePath.includes("[")
+                hasDynamicSegments: routePath.includes("["),
+                maxConcurrentH1
               });
             }
           }
@@ -2220,6 +2385,7 @@ var canonicalRule = {
     }
     for (const route of context.routes) {
       if (route.isRedirect) continue;
+      if ((route.metadata.robots || "").toLowerCase().includes("noindex")) continue;
       if (route.metadata.dynamicMetadata) continue;
       const canonical = route.metadata.canonical;
       if (!canonical || canonical.trim() === "") {
@@ -2364,19 +2530,22 @@ var headingsRule = {
           fixable: false,
           explanation: "Every page should have exactly one <h1> element defining its primary topic for search engines and accessibility."
         });
-      } else if (h1s.length > 1) {
-        findings.push({
-          id: `heading-multiple-h1-${route.route}`,
-          rule: "headings",
-          severity: "warning",
-          category: "content",
-          message: `Found ${h1s.length} <h1> tags on route "${route.route}". Best practice is a single prominent <h1>.`,
-          file: route.filePath,
-          line: h1s[1].line,
-          route: route.route,
-          fixable: false,
-          explanation: "Multiple <h1> tags can dilute topical hierarchy and confuse screen readers."
-        });
+      } else {
+        const effectiveCount = route.maxConcurrentH1 !== void 0 ? Math.max(route.maxConcurrentH1, h1s.length > 0 ? 1 : 0) : h1s.length;
+        if (effectiveCount > 1) {
+          findings.push({
+            id: `heading-multiple-h1-${route.route}`,
+            rule: "headings",
+            severity: "warning",
+            category: "content",
+            message: `Found ${effectiveCount} <h1> tags on route "${route.route}". Best practice is a single prominent <h1>.`,
+            file: route.filePath,
+            line: h1s[1].line,
+            route: route.route,
+            fixable: false,
+            explanation: "Multiple <h1> tags can dilute topical hierarchy and confuse screen readers."
+          });
+        }
       }
       let prevLevel = 1;
       for (const h of headings) {
@@ -2438,7 +2607,9 @@ var imagesRule = {
             // Never invent alt descriptions without AI
             explanation: "Missing alt attributes harm accessibility and prevent images from ranking in Google Image Search."
           });
-        } else if (img.alt.trim() === "" && !img.src.includes("icon") && !img.src.includes("decorative")) {
+        } else if (img.alt.trim() === "" && !img.src.includes("icon") && !img.src.includes("decorative") && // A runtime/dynamic src (e.g. favicon from data) cannot be judged;
+        // empty alt for it is commonly the intended decorative usage.
+        !img.src.includes("unknown-image")) {
           findings.push({
             id: `img-empty-alt-${route.route}-${img.src}`,
             rule: "images",
@@ -3803,7 +3974,7 @@ function runSEOAudit(options) {
     recommendations,
     opportunities,
     timestamp,
-    engineVersion: "0.3.0"
+    engineVersion: "0.3.2"
   };
 }
 
@@ -5721,7 +5892,7 @@ async function runCli(args) {
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.3.0");
+    console.log("0.3.2");
     return;
   }
   checkSecretRisk(projectRoot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crawlemon",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "ESLint / Dependabot for SEO \u2014 Developer-First SEO Automation Tool",
   "license": "MIT",