@imwz/wp-pattern-sentinel 1.1.2 → 1.1.3

package/package.json

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

package/src/editor.js

@@ -113,21 +113,6 @@ export async function insertPatternIntoEditor(page, blockContent, verbose = fals
       { timeout: 15000 }
     );
 
-    // Nested `core/pattern` placeholders are swapped for the referenced
-    // pattern's blocks asynchronously, once the pattern registry has loaded.
-    // Wait for that so the save and the content comparison see the expanded
-    // tree. Unregistered slugs never expand, so a timeout here is non-fatal.
-    if (/<!-- wp:pattern\s/.test(blockContent)) {
-      await page
-        .waitForFunction(() => {
-          const hasPattern = blocks => blocks.some(
-            b => b.name === 'core/pattern' || hasPattern(b.innerBlocks ?? [])
-          );
-          return !hasPattern(window.wp.data.select('core/block-editor').getBlocks());
-        }, { timeout: 10000 })
-        .catch(() => {});
-    }
-
     if (verbose) log('    → Pattern inserted', 'gray');
     return true;
   } catch (error) {

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

@@ -95,30 +95,59 @@ const normalizeForComparison = str =>
 
 /**
  * Matches a nested pattern reference: `<!-- wp:pattern {"slug":"theme/x"} /-->`.
- * The editor replaces these with the referenced pattern's blocks, so the
- * source must be expanded the same way before it can be diffed.
+ * 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;
 
-/** Map of registered pattern name → raw content, read from the REST API. */
-const fetchRegisteredPatterns = page =>
-  page.evaluate(async () => {
-    const patterns = await window.wp.apiFetch({ path: '/wp/v2/block-patterns/patterns' });
-    return Object.fromEntries(patterns.map(p => [p.name, p.content]));
-  });
+/**
+ * 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 };
+}
 
 /**
- * Recursively substitute each `wp:pattern` reference with the referenced
- * pattern's content. Unregistered slugs and self-references are left as-is,
- * mirroring the editor, which leaves those `core/pattern` blocks unexpanded.
+ * 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.
  */
-const expandPatternRefs = (str, registry, seen = []) =>
-  str.replace(PATTERN_REF, (match, json) => {
-    let slug;
-    try { slug = JSON.parse(json).slug; } catch { return match; }
-    if (typeof registry[slug] !== 'string' || seen.includes(slug)) return match;
-    return expandPatternRefs(registry[slug], registry, [...seen, slug]);
-  });
+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.
@@ -135,17 +164,6 @@ export async function compareContent(page, originalContent, verbose = false) {
     );
     result.savedContent = savedContent;
 
-    if (originalContent.includes('<!-- wp:pattern ')) {
-      try {
-        originalContent = expandPatternRefs(originalContent, await fetchRegisteredPatterns(page));
-      } catch (error) {
-        result.warnings.push({
-          type: 'pattern_ref_unresolved',
-          message: `Could not resolve nested wp:pattern references: ${error.message}`,
-        });
-      }
-    }
-
     const normalize = str => str.replace(/\s+/g, ' ').trim();
     if (normalize(normalizeForComparison(savedContent)) === normalize(normalizeForComparison(originalContent))) {
       if (verbose) log('    → Content matches', 'gray');