@imwz/wp-pattern-sentinel 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imwz/wp-pattern-sentinel",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Browser-based WordPress block pattern validator using Playwright",
   "type": "module",
   "engines": {

package/src/main.js

@@ -12,7 +12,7 @@ import {
   savePage,
   deletePage,
 } from './editor.js';
-import { checkBlockValidation, compareContent } from './validation.js';
+import { checkBlockValidation, compareContent, splitPatternRefs, checkPatternRefs } from './validation.js';
 import { log, formatResult, printSummary } from './format.js';
 
 const CACHE_FILE = '.sentinel-cache.json';
@@ -191,6 +191,10 @@ async function validatePatternFile(patternPath, options, context) {
     return fail(patternName, patternPath, startTime, 'extraction_error', 'Could not extract block content from file');
   }
 
+  // Nested `wp:pattern` references are validated by their own pattern's run;
+  // here they only need to resolve. The editor round-trip covers the rest.
+  const { slugs, ownContent } = splitPatternRefs(blockContent);
+
   const page = await context.newPage();
   page.setDefaultTimeout(60000);
 
@@ -200,12 +204,30 @@ async function validatePatternFile(patternPath, options, context) {
       return fail(patternName, patternPath, startTime, 'page_creation_error', 'Failed to create test page');
     }
 
-    if (!(await insertPatternIntoEditor(page, blockContent, verbose))) {
+    const refErrors = await checkPatternRefs(page, slugs, verbose);
+
+    // A pattern that only composes other patterns has nothing of its own to
+    // round-trip through the editor.
+    if (!ownContent) {
+      await deletePage(page, options.adminUrl, pageId, verbose);
+      return {
+        pattern:  patternName,
+        patternPath,
+        hash:     hashContent(fileContent),
+        passed:   refErrors.length === 0,
+        errors:   refErrors,
+        warnings: [],
+        duration: Date.now() - startTime,
+      };
+    }
+
+    if (!(await insertPatternIntoEditor(page, ownContent, verbose))) {
       await deletePage(page, options.adminUrl, pageId, verbose);
       return fail(patternName, patternPath, startTime, 'insertion_error', 'Failed to insert pattern into editor');
     }
 
     const saveResult  = await savePage(page, verbose);
+    saveResult.errors.push(...refErrors);
     const blockErrors = await checkBlockValidation(page, verbose);
 
     if (blockErrors.length > 0) {
@@ -219,7 +241,7 @@ async function validatePatternFile(patternPath, options, context) {
       })));
     }
 
-    const comparison = await compareContent(page, blockContent, verbose);
+    const comparison = await compareContent(page, ownContent, verbose);
     saveResult.errors.push(...comparison.errors);
     saveResult.warnings.push(...comparison.warnings);
 
@@ -231,7 +253,7 @@ async function validatePatternFile(patternPath, options, context) {
       pattern:      patternName,
       patternPath,
       hash:         hashContent(fileContent),
-      passed:       saveResult.success && comparison.matches && blockErrors.length === 0,
+      passed:       saveResult.success && comparison.matches && blockErrors.length === 0 && refErrors.length === 0,
       errors:       saveResult.errors,
       warnings:     saveResult.warnings,
       duration:     Date.now() - startTime,

package/src/validation.js

@@ -93,6 +93,62 @@ const collapseInterTagWhitespace = str => str.replace(/>\s+</g, '><');
 const normalizeForComparison = str =>
   collapseInterTagWhitespace(normalizeBlockAttrJson(normalizeCssProps(stripNavRef(str))));
 
+/**
+ * Matches a nested pattern reference: `<!-- wp:pattern {"slug":"theme/x"} /-->`.
+ * A reference is a link to another pattern, not content of this one: the
+ * referenced pattern is validated by its own run, so here we only check that
+ * the slug resolves and validate whatever markup the pattern adds itself.
+ */
+const PATTERN_REF = /<!-- wp:pattern (\{[\s\S]*?\}) \/-->/g;
+
+/**
+ * Split block content into the slugs it references and its own markup with
+ * those references removed. `ownContent` is '' for a pattern that only
+ * composes other patterns. A reference with unparseable JSON is left in
+ * place, so the editor flags it like any other invalid block.
+ */
+export function splitPatternRefs(content) {
+  const slugs = [];
+  const ownContent = content.replace(PATTERN_REF, (match, json) => {
+    try {
+      const { slug } = JSON.parse(json);
+      if (typeof slug !== 'string') return match;
+      slugs.push(slug);
+      return '';
+    } catch {
+      return match;
+    }
+  }).trim();
+  return { slugs, ownContent };
+}
+
+/**
+ * Check every referenced slug is a registered pattern on the site. An
+ * unregistered slug (a typo, or a pattern missing from the synced theme)
+ * renders nothing on the page, so it is an error, not a warning.
+ */
+export async function checkPatternRefs(page, slugs, verbose = false) {
+  if (slugs.length === 0) return [];
+  if (verbose) log('    → Checking nested pattern references...', 'gray');
+  try {
+    const registered = await page.evaluate(async () => {
+      const patterns = await window.wp.apiFetch({ path: '/wp/v2/block-patterns/patterns' });
+      return patterns.map(p => p.name);
+    });
+    return [...new Set(slugs)]
+      .filter(slug => !registered.includes(slug))
+      .map(slug => ({
+        type:    'pattern_ref_missing',
+        message: `Referenced pattern "${slug}" is not registered on the site`,
+      }));
+  } catch (error) {
+    return [{
+      type:    'pattern_ref_error',
+      message: `Could not check nested pattern references: ${error.message}`,
+    }];
+  }
+}
+
 /**
  * Compare the editor's serialized output against the original source.
  * Whitespace-normalizes both sides before diffing to avoid false positives