crawlemon 0.3.0 → 0.3.1

package/README.md

@@ -6,6 +6,12 @@ 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.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 +223,11 @@ jobs:
       - name: Audit SEO
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.0 audit
+        run: npx --yes crawlemon@0.3.1 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.1` 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 +242,7 @@ working directory:
         working-directory: apps/web
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.0 audit
+        run: npx --yes crawlemon@0.3.1 audit
 ```
 
 ## Zero-configuration detection

package/dist/index.js

@@ -1547,7 +1547,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 +1556,55 @@ function discoverImportedH1(filePath, resolver, maxDepth = 3) {
   }
   return result;
 }
+function findDefaultExportBody(content) {
+  const idx = content.search(/export\s+default\b/);
+  if (idx === -1) return null;
+  const head = content.slice(idx);
+  if (/export\s+default\s+(?:async\s+)?function\b/.test(head)) {
+    const openParen = head.indexOf("(", head.indexOf("function"));
+    if (openParen === -1) return null;
+    let cursor = readBalanced(head, openParen) + 1;
+    while (cursor < head.length && head[cursor] !== "{") cursor += 1;
+    if (head[cursor] !== "{") return null;
+    const end = readBalanced(head, cursor);
+    return { start: idx + cursor, end: idx + end };
+  }
+  const arrow = head.indexOf("=>");
+  if (arrow !== -1) {
+    let cursor = arrow + 2;
+    while (cursor < head.length && /\s/.test(head[cursor])) cursor += 1;
+    if (head[cursor] === "{") {
+      const end = readBalanced(head, cursor);
+      return { start: idx + cursor, end: idx + end };
+    }
+  }
+  return null;
+}
+function computeH1Concurrency(content, h1Lines) {
+  const body = findDefaultExportBody(content);
+  if (!body) return null;
+  const { start, end } = body;
+  const blockStarts = [];
+  const returnRe = /(?:^|[^A-Za-z0-9_$])return\s*(?:\(\s*)?</g;
+  for (const match of content.slice(start, end).matchAll(returnRe)) {
+    const absolute = start + (match.index || 0);
+    blockStarts.push(lineAt2(content, absolute));
+  }
+  if (blockStarts.length === 0) return null;
+  blockStarts.sort((a, b) => a - b);
+  const counts = /* @__PURE__ */ new Map();
+  for (const h1Line of h1Lines) {
+    let owner = blockStarts[0];
+    for (const block of blockStarts) {
+      if (block <= h1Line) owner = block;
+      else break;
+    }
+    counts.set(owner, (counts.get(owner) || 0) + 1);
+  }
+  let max = 0;
+  for (const count of counts.values()) max = Math.max(max, count);
+  return max;
+}
 
 // ../next-adapter/src/scanner.ts
 function normalizeRouteGroup(segment) {
@@ -1698,6 +1747,14 @@ 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.filter((h) => h.level === 1).length;
+              }
               routes.push({
                 route: routePath,
                 filePath: fullPath,
@@ -1710,7 +1767,8 @@ var NextJsAdapter = class {
                 hasDynamicSegments: routePath.includes("["),
                 dynamicParams: dynamic?.dynamicParams,
                 generatedParams: dynamic?.generatedParams,
-                isRedirect: isRedirectOnly(content)
+                isRedirect: isRedirectOnly(content),
+                maxConcurrentH1
               });
             }
           }
@@ -1738,6 +1796,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 +1808,8 @@ var NextJsAdapter = class {
                 links: parsed.links,
                 textContent: parsed.textContent,
                 hasLittleContent: parsed.hasLittleContent,
-                hasDynamicSegments: routePath.includes("[")
+                hasDynamicSegments: routePath.includes("["),
+                maxConcurrentH1
               });
             }
           }
@@ -2220,6 +2282,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 +2427,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 +2504,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 +3871,7 @@ function runSEOAudit(options) {
     recommendations,
     opportunities,
     timestamp,
-    engineVersion: "0.3.0"
+    engineVersion: "0.3.1"
   };
 }
 
@@ -5721,7 +5789,7 @@ async function runCli(args) {
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.3.0");
+    console.log("0.3.1");
     return;
   }
   checkSecretRisk(projectRoot);

package/package.json

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