@imwz/wp-pattern-sentinel 1.1.1 → 1.1.2

package/package.json

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

package/src/editor.js

@@ -113,6 +113,21 @@ 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/validation.js

@@ -93,6 +93,33 @@ 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"} /-->`.
+ * The editor replaces these with the referenced pattern's blocks, so the
+ * source must be expanded the same way before it can be diffed.
+ */
+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]));
+  });
+
+/**
+ * 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.
+ */
+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]);
+  });
+
 /**
  * Compare the editor's serialized output against the original source.
  * Whitespace-normalizes both sides before diffing to avoid false positives
@@ -108,6 +135,17 @@ 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');