dogsbay 0.2.0-beta.45 → 0.2.0-beta.47

package/dist/audit/rules/seo/sitemap.js

@@ -22,7 +22,7 @@
  * `_resetSitemapCache()`.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 const STATE_CACHE = new Map();
 export function _resetSitemapCache() {
     STATE_CACHE.clear();
@@ -50,11 +50,26 @@ function getState(distRoot) {
             // sitemap integration which produces well-formed XML, so
             // the only failure mode is "missing entirely" or
             // "doesn't parse at all."
-            if (/<(urlset|sitemapindex)[\s>]/.test(content)) {
+            const isIndex = /<sitemapindex[\s>]/.test(content);
+            const isUrlset = /<urlset[\s>]/.test(content);
+            if (isIndex || isUrlset) {
                 sitemapValid = true;
-                const matches = content.matchAll(/<loc>([^<]+)<\/loc>/g);
-                for (const m of matches) {
-                    sitemapLocs.add(m[1].trim());
+                if (isIndex) {
+                    // sitemap-index.xml — each <loc> points at a child
+                    // sitemap file (not a page). Read each child and union
+                    // its <loc> entries (those ARE the page URLs). Without
+                    // this recursion, sitemapLocs would carry sitemap file
+                    // URLs only and every page would be flagged "missing
+                    // from sitemap" — the entire audit class is unusable.
+                    collectChildSitemapLocs(content, sitemapPath, sitemapLocs);
+                }
+                else {
+                    // Plain <urlset> — extract <loc>s directly. Same as
+                    // before.
+                    const matches = content.matchAll(/<loc>([^<]+)<\/loc>/g);
+                    for (const m of matches) {
+                        sitemapLocs.add(m[1].trim());
+                    }
                 }
             }
         }
@@ -214,6 +229,51 @@ export const sitemapRobotsCoherence = {
         return issues;
     },
 };
+/**
+ * Recurse into a `<sitemapindex>` document: for each child
+ * sitemap referenced by `<loc>`, read the file from disk and
+ * union its page-level `<loc>` entries into the supplied set.
+ *
+ * Resolution strategy: take the basename of the child URL and
+ * resolve it against the directory that contains the index file.
+ * That covers both layouts in use today — host-root
+ * (`dist/sitemap-index.xml` + `dist/sitemap-0.xml`) and
+ * per-mount (`dist/<basePath>/sitemap-index.xml` +
+ * `dist/<basePath>/sitemap-0.xml`). Children that don't resolve
+ * to a local file are silently skipped — better to miss a few
+ * URLs than to crash the audit when a deploy ships a partial
+ * sitemap. The page-level rule still surfaces orphan pages, so
+ * an incomplete recursion just downgrades to the previous
+ * misbehaviour (all pages flagged as missing) — never worse.
+ */
+function collectChildSitemapLocs(indexContent, indexPath, out) {
+    const indexDir = dirname(indexPath);
+    for (const m of indexContent.matchAll(/<loc>([^<]+)<\/loc>/g)) {
+        const childUrl = m[1].trim();
+        let childName;
+        try {
+            const u = new URL(childUrl);
+            childName = basename(u.pathname);
+        }
+        catch {
+            childName = basename(childUrl);
+        }
+        if (!childName || childName === "/")
+            continue;
+        const childPath = join(indexDir, childName);
+        if (!existsSync(childPath))
+            continue;
+        try {
+            const childContent = readFileSync(childPath, "utf-8");
+            for (const cm of childContent.matchAll(/<loc>([^<]+)<\/loc>/g)) {
+                out.add(cm[1].trim());
+            }
+        }
+        catch {
+            // Skip unreadable child — see function-level comment.
+        }
+    }
+}
 /**
  * Convert an HTML file path within `dist/` into the public URL
  * path the sitemap is likely to list. Drops `/index.html` and

package/dist/audit/rules/structure/index.js

@@ -16,6 +16,7 @@ import { internalLinks } from "./internal-links.js";
 import { localeCoherence } from "./locale-coherence.js";
 import { namespaceCoherence } from "./namespace-coherence.js";
 import { navTargetExists } from "./nav-target-exists.js";
+import { unresolvedDirectives } from "./unresolved-directives.js";
 import { versionCoherence } from "./version-coherence.js";
 let registered = false;
 /**
@@ -32,6 +33,7 @@ export function registerStructureRules() {
     registerRule(navTargetExists);
     registerRule(internalLinks);
     registerRule(assetRefs);
+    registerRule(unresolvedDirectives);
 }
 /**
  * Test-only: reset the "registered" flag so unit tests can

package/dist/audit/rules/structure/unresolved-directives.js

@@ -0,0 +1,108 @@
+/**
+ * Strict variable form: `{{ name }}`, `{{ obj.field }}`,
+ * `{{ name|filter }}`, `{{ name | filter }}`. Identifier-then-optional-filter
+ * shape so a stray `{{` in legitimate prose (e.g. discussing
+ * mathematical notation) doesn't false-positive.
+ */
+const VAR_RE = /\{\{\s*([a-zA-Z_][\w.-]*)\s*(?:\|[^}]+)?\s*\}\}/g;
+/**
+ * Strict block form: `{% if name %}` / `{% endif %}` / `{% set ... %}` /
+ * `{% include "..." %}` / `{%- ... -%}` (whitespace control variants).
+ * Anchored to a known keyword so a generic `{% ... %}` we don't
+ * recognise isn't flagged (Minja's grammar is a subset of Jinja —
+ * surfacing only the patterns the engine actually emits keeps the
+ * rule focused on what the preprocessor would have resolved).
+ */
+const BLOCK_RE = /\{%-?\s*(if|elif|else|endif|for|endfor|set|include|raw|endraw|leveloffset|switch|case|endswitch|default)\b[^%]*%\}/g;
+/**
+ * Walk a TreeNode tree, accumulating directive hits from text
+ * content. Skips code-flavoured nodes so documentation of Jinja
+ * syntax doesn't false-positive.
+ */
+function findHits(nodes, out) {
+    for (const node of nodes) {
+        if (node.type === "code")
+            continue;
+        if (node.inline)
+            findInlineHits(node.inline, out);
+        if (typeof node.html === "string")
+            scanText(node.html, out);
+        if (typeof node.props?.title === "string")
+            scanText(node.props.title, out);
+        if (node.children)
+            findHits(node.children, out);
+    }
+}
+function findInlineHits(nodes, out) {
+    for (const node of nodes) {
+        if (node.type === "code")
+            continue;
+        if (node.type === "text") {
+            scanText(node.text, out);
+        }
+        else if (node.type === "link" && node.children) {
+            findInlineHits(node.children, out);
+        }
+        else if (node.type === "highlight" && node.children) {
+            findInlineHits(node.children, out);
+        }
+        else if (node.type === "html-inline" && typeof node.html === "string") {
+            scanText(node.html, out);
+        }
+    }
+}
+function scanText(text, out) {
+    let m;
+    VAR_RE.lastIndex = 0;
+    while ((m = VAR_RE.exec(text)) !== null) {
+        out.push({ match: m[0], kind: "variable" });
+    }
+    BLOCK_RE.lastIndex = 0;
+    while ((m = BLOCK_RE.exec(text)) !== null) {
+        out.push({ match: m[0], kind: "block" });
+    }
+}
+/**
+ * Build the three-fix message for one hit. Keep it dense but
+ * actionable — the audit text formatter renders one line per
+ * finding plus the message.
+ */
+function formatMessage(hit) {
+    const kindLabel = hit.kind === "variable"
+        ? "variable reference"
+        : "conditional / block directive";
+    return (`Unresolved Minja ${kindLabel} \`${hit.match}\` survived to the rendered ` +
+        `page. Fix one of: ` +
+        `(1) add the missing value to the \`attributes:\` block in ` +
+        `\`dogsbay.config.yml\`; ` +
+        `(2) pass \`dogsbay site build --attribute name=value\` for per-build ` +
+        `overrides (CI secrets, deploy targets); ` +
+        `(3) if the literal is intentional (e.g. the page documents Jinja ` +
+        `syntax), add \`preprocess: false\` to the page's frontmatter.`);
+}
+export const unresolvedDirectives = {
+    id: "structure/unresolved-directives",
+    category: "structure",
+    stage: "source",
+    severity: "warning",
+    description: "Flags surviving Minja `{{ var }}` / `{% if %}` directives in page content " +
+        "(the preprocessor couldn't resolve them and they're heading to the rendered HTML).",
+    run(rawCtx) {
+        const ctx = rawCtx;
+        if (!ctx.page)
+            return [];
+        if (ctx.page.frontmatter?.preprocess === false)
+            return [];
+        const hits = [];
+        findHits(ctx.page.tree, hits);
+        if (hits.length === 0)
+            return [];
+        return hits.map((hit) => ({
+            ruleId: "structure/unresolved-directives",
+            severity: "warning",
+            file: `${ctx.page.slug}.md`,
+            message: formatMessage(hit),
+            context: hit.match,
+        }));
+    },
+};