crawlemon 0.3.1 → 0.3.2

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.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.
@@ -223,11 +229,11 @@ jobs:
       - name: Audit SEO
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.1 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.1` 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
@@ -242,7 +248,7 @@ working directory:
         working-directory: apps/web
         env:
           CI: true
-        run: npx --yes crawlemon@0.3.1 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);
+  }
+  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 files;
+  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`);
@@ -1556,53 +1608,103 @@ 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 };
+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 null;
+  return regions;
 }
-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));
+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 };
   }
-  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;
+  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);
     }
-    counts.set(owner, (counts.get(owner) || 0) + 1);
   }
+  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 (const count of counts.values()) max = Math.max(max, count);
+  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;
 }
 
@@ -1753,8 +1855,9 @@ var NextJsAdapter = class {
                 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;
+                maxConcurrentH1 = headings.some((h) => h.level === 1) ? 1 : 0;
               }
+              const hasLittleContent = parsed.hasLittleContent && (!resolver || !pageHasMeaningfulContent(fullPath, resolver));
               routes.push({
                 route: routePath,
                 filePath: fullPath,
@@ -1763,7 +1866,7 @@ 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,
@@ -3871,7 +3974,7 @@ function runSEOAudit(options) {
     recommendations,
     opportunities,
     timestamp,
-    engineVersion: "0.3.1"
+    engineVersion: "0.3.2"
   };
 }
 
@@ -5789,7 +5892,7 @@ async function runCli(args) {
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.3.1");
+    console.log("0.3.2");
     return;
   }
   checkSecretRisk(projectRoot);

package/package.json

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