@10up/block-renderer-validator 0.1.4

package/README.md

@@ -0,0 +1,352 @@
+# @10up/block-renderer-validator
+
+Validate JSON block trees against schemas, nesting rules, and theme tokens. This package ensures block trees are valid before rendering.
+
+## Installation
+
+```bash
+npm install @10up/block-renderer-validator
+# or
+pnpm add @10up/block-renderer-validator
+```
+
+## Overview
+
+This package provides comprehensive validation for block trees:
+
+1. **Schema Validation** - Validates block props against Zod schemas from block definitions
+2. **Nesting Validation** - Checks parent/ancestor/allowedBlocks constraints
+3. **Token Validation** - Verifies theme token references (colors, spacing, etc.)
+4. **Pattern Validation** - Confirms pattern slugs exist in the registry
+
+## Usage
+
+### Full Tree Validation
+
+The main entry point - validates a tree with all available validators:
+
+```typescript
+import { validateTree } from '@10up/block-renderer-validator';
+
+const tree = {
+  root: 'para-1',
+  elements: {
+    'para-1': {
+      key: 'para-1',
+      type: 'core/paragraph',
+      props: {
+        content: 'Hello',
+        style: { color: { background: 'var:preset|color|primary' } }
+      }
+    }
+  }
+};
+
+const result = validateTree(tree, {
+  catalog: blockCatalog,     // Block definitions for schema/nesting
+  tokens: themeTokens,       // Theme tokens for color/spacing validation
+  patterns: patternRegistry  // Pattern definitions
+});
+
+if (result.valid) {
+  console.log('Tree is valid');
+} else {
+  console.log('Errors:', result.errors);
+  // ['Unknown color token: primary', 'Invalid block type: core/unknown']
+}
+```
+
+### Validation Options
+
+```typescript
+interface ValidateTreeOptions {
+  /** Block catalog for schema and nesting validation */
+  catalog?: BlockCatalog;
+  /** Theme tokens for token validation */
+  tokens?: ThemeTokens;
+  /** Pattern registry for pattern validation */
+  patterns?: PatternRegistry;
+  /** Whether to validate schemas (default: true if catalog provided) */
+  validateSchemas?: boolean;
+  /** Whether to validate nesting rules (default: true if catalog provided) */
+  validateNesting?: boolean;
+  /** Whether to validate theme tokens (default: true if tokens provided) */
+  validateTokens?: boolean;
+  /** Whether to validate pattern references (default: true if patterns provided) */
+  validatePatterns?: boolean;
+}
+```
+
+### Create Reusable Validator
+
+```typescript
+import { createTreeValidator } from '@10up/block-renderer-validator';
+
+const validator = createTreeValidator({
+  catalog: blockCatalog,
+  tokens: themeTokens,
+  patterns: patternRegistry,
+});
+
+// Use the pre-configured validator
+const result1 = validator(tree1);
+const result2 = validator(tree2);
+```
+
+## Schema Validation
+
+Validate block props against their Zod schemas:
+
+```typescript
+import { validateBlockProps, validateTreeSchemas } from '@10up/block-renderer-validator';
+
+// Validate a single element's props
+const result = validateBlockProps(element.props, blockDefinition.schema);
+if (!result.valid) {
+  console.log(result.errors);
+  // ['content: Expected string, received number']
+}
+
+// Validate all elements in a tree
+const treeResult = validateTreeSchemas(tree, catalog);
+```
+
+### Create Block Validator
+
+Create a validator for a specific block:
+
+```typescript
+import { createBlockValidator } from '@10up/block-renderer-validator';
+
+const validateParagraph = createBlockValidator(paragraphDefinition);
+const result = validateParagraph({ content: 'Hello', dropCap: true });
+```
+
+### Get Valid Attributes
+
+Filter props to only include valid attributes:
+
+```typescript
+import { getValidAttributes } from '@10up/block-renderer-validator';
+
+const cleanProps = getValidAttributes(props, blockDefinition.schema);
+// Returns only props that match the schema
+```
+
+## Nesting Validation
+
+Validate block nesting rules:
+
+```typescript
+import { validateTreeNesting } from '@10up/block-renderer-validator';
+
+const result = validateTreeNesting(tree, catalog);
+if (!result.valid) {
+  console.log(result.errors);
+  // ['core/column must be inside core/columns']
+}
+```
+
+### Individual Nesting Validators
+
+```typescript
+import {
+  validateParent,
+  validateAncestor,
+  validateChildren,
+  validateMultiple,
+} from '@10up/block-renderer-validator';
+
+// Check if element has valid parent
+validateParent(element, parentElement, blockDefinition);
+
+// Check if element has valid ancestor chain
+validateAncestor(element, ancestorChain, blockDefinition);
+
+// Check if children are valid for this block
+validateChildren(element, childElements, blockDefinition);
+
+// Check if multiple instances are allowed
+validateMultiple(elements, blockDefinition);
+```
+
+## Token Validation
+
+Validate theme token references in block props:
+
+```typescript
+import { validateTreeTokens, validateElementTokens } from '@10up/block-renderer-validator';
+
+// Validate all tokens in a tree
+const result = validateTreeTokens(tree, themeTokens);
+if (!result.valid) {
+  console.log(result.errors);
+  // ['Unknown color token: invalid-color']
+}
+
+// Validate a single element's tokens
+const elementResult = validateElementTokens(element, themeTokens);
+```
+
+### Specific Token Validators
+
+```typescript
+import {
+  validateColorTokens,
+  validateTypographyTokens,
+  validateSpacingTokens,
+} from '@10up/block-renderer-validator';
+
+// Validate specific token types
+validateColorTokens(props, themeTokens);
+validateTypographyTokens(props, themeTokens);
+validateSpacingTokens(props, themeTokens);
+```
+
+## Pattern Validation
+
+Validate pattern block references:
+
+```typescript
+import {
+  validatePatternReference,
+  validateTreePatterns,
+  isPatternReference,
+  getPatternReferences,
+} from '@10up/block-renderer-validator';
+
+// Check if an element is a pattern reference
+if (isPatternReference(element)) {
+  const result = validatePatternReference(element, patternRegistry);
+  if (!result.valid) {
+    console.log(result.errors);
+    // ['Unknown pattern: theme/nonexistent-pattern']
+  }
+}
+
+// Validate all patterns in a tree
+const treeResult = validateTreePatterns(tree, patternRegistry);
+
+// Get all pattern references from a tree
+const patternRefs = getPatternReferences(tree);
+// ['theme/hero-section', 'theme/footer']
+```
+
+## Template Validation
+
+Validate BlockTemplate format (PHP-style nested arrays):
+
+```typescript
+import {
+  validateTemplate,
+  validateTemplateStructure,
+  validateTemplateBlockTypes,
+  validateTemplateNesting,
+} from '@10up/block-renderer-validator';
+
+const template = [
+  ['core/group', { layout: { type: 'constrained' } }, [
+    ['core/heading', { content: 'Title', level: 2 }],
+    ['core/paragraph', { content: 'Content' }],
+  ]],
+];
+
+// Full template validation
+const result = validateTemplate(template, {
+  catalog: blockCatalog,
+});
+
+if (!result.valid) {
+  console.log('Errors:', result.errors);
+}
+
+// Validate just structure (correct array format)
+const structureResult = validateTemplateStructure(template);
+
+// Validate block types exist
+const typesResult = validateTemplateBlockTypes(template, catalog);
+
+// Validate nesting rules
+const nestingResult = validateTemplateNesting(template, catalog);
+```
+
+### Template Validation Options
+
+```typescript
+interface ValidateTemplateOptions {
+  /** Block catalog for type and nesting validation */
+  catalog?: BlockCatalog;
+  /** Whether to validate that block types exist (default: true if catalog provided) */
+  validateBlockTypes?: boolean;
+  /** Whether to validate nesting rules (default: true if catalog provided) */
+  validateNesting?: boolean;
+}
+```
+
+## Complete Exports
+
+### Main Functions
+
+| Function | Description |
+|----------|-------------|
+| `validateTree(tree, options)` | Full tree validation with all validators |
+| `createTreeValidator(options)` | Create reusable validator function |
+
+### Schema Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateBlockProps(props, schema)` | Validate props against Zod schema |
+| `validateTreeSchemas(tree, catalog)` | Validate all elements in tree |
+| `createBlockValidator(definition)` | Create validator for specific block |
+| `getValidAttributes(props, schema)` | Filter to valid attributes only |
+
+### Nesting Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateTreeNesting(tree, catalog)` | Validate all nesting rules in tree |
+| `validateParent(element, parent, def)` | Check valid parent constraint |
+| `validateAncestor(element, ancestors, def)` | Check valid ancestor constraint |
+| `validateChildren(element, children, def)` | Check valid children constraint |
+| `validateMultiple(elements, def)` | Check multiple instance constraint |
+
+### Token Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateTreeTokens(tree, tokens)` | Validate all tokens in tree |
+| `validateElementTokens(element, tokens)` | Validate single element tokens |
+| `validateColorTokens(props, tokens)` | Validate color token references |
+| `validateTypographyTokens(props, tokens)` | Validate typography tokens |
+| `validateSpacingTokens(props, tokens)` | Validate spacing tokens |
+
+### Pattern Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateTreePatterns(tree, patterns)` | Validate all pattern refs in tree |
+| `validatePatternReference(element, patterns)` | Validate single pattern ref |
+| `isPatternReference(element)` | Check if element is a pattern |
+| `getPatternReferences(tree)` | Get all pattern slugs from tree |
+
+### Template Validation
+
+| Function | Description |
+|----------|-------------|
+| `validateTemplate(template, options)` | Full template validation |
+| `validateTemplateStructure(template)` | Validate template array structure |
+| `validateTemplateBlockTypes(template, catalog)` | Validate block types exist |
+| `validateTemplateNesting(template, catalog)` | Validate nesting rules |
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `ValidateTreeOptions` | Options for validateTree |
+| `ValidateTemplateOptions` | Options for validateTemplate |
+| `TemplateValidationResult` | Result from template validation |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import type { BlockTree, BlockCatalog, TreeValidationResult } from '@10up/block-renderer-core';
+import type { ThemeTokens } from '@10up/block-renderer-theme-json';
+import type { PatternRegistry } from '@10up/block-renderer-patterns';
+export { validateBlockProps, validateTreeSchemas, createBlockValidator, getValidAttributes, } from './schema-validator.js';
+export { validateParent, validateAncestor, validateChildren, validateMultiple, validateTreeNesting, } from './tree-validator.js';
+export { validateColorTokens, validateTypographyTokens, validateSpacingTokens, validateElementTokens, validateTreeTokens, } from './token-validator.js';
+export { isPatternReference, validatePatternReference, validateTreePatterns, getPatternReferences, } from './pattern-validator.js';
+export { validateTemplateStructure, validateTemplateBlockTypes, validateTemplateNesting, validateTemplate, } from './template-validator.js';
+export type { TemplateValidationResult, ValidateTemplateOptions, } from './template-validator.js';
+/**
+ * Options for full tree validation.
+ */
+export interface ValidateTreeOptions {
+    /** Block catalog for schema and nesting validation */
+    catalog?: BlockCatalog;
+    /** Theme tokens for token validation */
+    tokens?: ThemeTokens;
+    /** Pattern registry for pattern validation */
+    patterns?: PatternRegistry;
+    /** Whether to validate schemas (default: true if catalog provided) */
+    validateSchemas?: boolean;
+    /** Whether to validate nesting rules (default: true if catalog provided) */
+    validateNesting?: boolean;
+    /** Whether to validate theme tokens (default: true if tokens provided) */
+    validateTokens?: boolean;
+    /** Whether to validate pattern references (default: true if patterns provided) */
+    validatePatterns?: boolean;
+}
+/**
+ * Validates a complete block tree with all available validations.
+ *
+ * @param tree - The block tree to validate
+ * @param options - Validation options
+ * @returns Combined validation result
+ */
+export declare function validateTree(tree: BlockTree, options?: ValidateTreeOptions): TreeValidationResult;
+/**
+ * Creates a tree validator with pre-configured options.
+ *
+ * @param options - Default validation options
+ * @returns A validator function
+ */
+export declare function createTreeValidator(options: ValidateTreeOptions): (tree: BlockTree) => TreeValidationResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EAEZ,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAQrE,OAAO,EAEL,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAEL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAEL,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,kBAAkB,EAClB,wBAAwB,EACxB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAEL,yBAAyB,EACzB,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAEjC;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,wCAAwC;IACxC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,sEAAsE;IACtE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4EAA4E;IAC5E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,0EAA0E;IAC1E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,mBAAwB,GAChC,oBAAoB,CA4CtB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,mBAAmB,GAC3B,CAAC,IAAI,EAAE,SAAS,KAAK,oBAAoB,CAE3C"}

package/dist/index.js

@@ -0,0 +1,77 @@
+import { validateTreeSchemas } from './schema-validator.js';
+import { validateTreeNesting } from './tree-validator.js';
+import { validateTreeTokens } from './token-validator.js';
+import { validateTreePatterns } from './pattern-validator.js';
+// Re-export individual validators
+export { 
+// Schema validation
+validateBlockProps, validateTreeSchemas, createBlockValidator, getValidAttributes, } from './schema-validator.js';
+export { 
+// Nesting validation
+validateParent, validateAncestor, validateChildren, validateMultiple, validateTreeNesting, } from './tree-validator.js';
+export { 
+// Token validation
+validateColorTokens, validateTypographyTokens, validateSpacingTokens, validateElementTokens, validateTreeTokens, } from './token-validator.js';
+export { 
+// Pattern validation
+isPatternReference, validatePatternReference, validateTreePatterns, getPatternReferences, } from './pattern-validator.js';
+export { 
+// Template validation
+validateTemplateStructure, validateTemplateBlockTypes, validateTemplateNesting, validateTemplate, } from './template-validator.js';
+/**
+ * Validates a complete block tree with all available validations.
+ *
+ * @param tree - The block tree to validate
+ * @param options - Validation options
+ * @returns Combined validation result
+ */
+export function validateTree(tree, options = {}) {
+    const errors = [];
+    const warnings = [];
+    const elementResults = {};
+    // Schema validation
+    if (options.catalog && options.validateSchemas !== false) {
+        const schemaResult = validateTreeSchemas(tree, options.catalog);
+        errors.push(...schemaResult.errors);
+        if (schemaResult.warnings) {
+            warnings.push(...schemaResult.warnings);
+        }
+    }
+    // Nesting validation
+    if (options.catalog && options.validateNesting !== false) {
+        const nestingResult = validateTreeNesting(tree, options.catalog);
+        errors.push(...nestingResult.errors);
+        if (nestingResult.warnings) {
+            warnings.push(...nestingResult.warnings);
+        }
+    }
+    // Token validation
+    if (options.tokens && options.validateTokens !== false) {
+        const tokenResult = validateTreeTokens(tree, options.tokens);
+        errors.push(...tokenResult.errors);
+        if (tokenResult.warnings) {
+            warnings.push(...tokenResult.warnings);
+        }
+    }
+    // Pattern validation
+    if (options.patterns && options.validatePatterns !== false) {
+        const patternResult = validateTreePatterns(tree, options.patterns);
+        errors.push(...patternResult.errors);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings: warnings.length > 0 ? warnings : undefined,
+        elementResults: Object.keys(elementResults).length > 0 ? elementResults : undefined,
+    };
+}
+/**
+ * Creates a tree validator with pre-configured options.
+ *
+ * @param options - Default validation options
+ * @returns A validator function
+ */
+export function createTreeValidator(options) {
+    return (tree) => validateTree(tree, options);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/pattern-validator.d.ts

@@ -0,0 +1,19 @@
+import type { BlockTree, BlockElement, ValidationResult } from '@10up/block-renderer-core';
+import type { PatternRegistry } from '@10up/block-renderer-patterns';
+/**
+ * Checks if a block element is a pattern reference.
+ */
+export declare function isPatternReference(element: BlockElement): boolean;
+/**
+ * Validates a pattern reference exists in the registry.
+ */
+export declare function validatePatternReference(element: BlockElement, registry: PatternRegistry): ValidationResult;
+/**
+ * Validates all pattern references in a block tree.
+ */
+export declare function validateTreePatterns(tree: BlockTree, registry: PatternRegistry): ValidationResult;
+/**
+ * Gets all pattern references from a block tree.
+ */
+export declare function getPatternReferences(tree: BlockTree): string[];
+//# sourceMappingURL=pattern-validator.d.ts.map

package/dist/pattern-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-validator.d.ts","sourceRoot":"","sources":["../src/pattern-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAEjE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,eAAe,GACxB,gBAAgB,CAiBlB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,eAAe,GACxB,gBAAgB,CAYlB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAU9D"}

package/dist/pattern-validator.js

@@ -0,0 +1,47 @@
+/**
+ * Checks if a block element is a pattern reference.
+ */
+export function isPatternReference(element) {
+    return element.type === 'core/pattern' && typeof element.props.slug === 'string';
+}
+/**
+ * Validates a pattern reference exists in the registry.
+ */
+export function validatePatternReference(element, registry) {
+    const errors = [];
+    if (!isPatternReference(element)) {
+        return { valid: true, errors: [] };
+    }
+    const slug = element.props.slug;
+    if (!registry.has(slug)) {
+        errors.push(`[${element.key}] Unknown pattern slug "${slug}". ` +
+            `Available patterns: ${Array.from(registry.keys()).join(', ')}`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Validates all pattern references in a block tree.
+ */
+export function validateTreePatterns(tree, registry) {
+    const errors = [];
+    for (const element of Object.values(tree.elements)) {
+        const result = validatePatternReference(element, registry);
+        if (!result.valid) {
+            errors.push(...result.errors);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Gets all pattern references from a block tree.
+ */
+export function getPatternReferences(tree) {
+    const patterns = [];
+    for (const element of Object.values(tree.elements)) {
+        if (isPatternReference(element)) {
+            patterns.push(element.props.slug);
+        }
+    }
+    return patterns;
+}
+//# sourceMappingURL=pattern-validator.js.map

package/dist/pattern-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-validator.js","sourceRoot":"","sources":["../src/pattern-validator.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAqB;IACtD,OAAO,OAAO,CAAC,IAAI,KAAK,cAAc,IAAI,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;AACnF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAAqB,EACrB,QAAyB;IAEzB,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;QACjC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACrC,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAc,CAAC;IAE1C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,CACT,IAAI,OAAO,CAAC,GAAG,2BAA2B,IAAI,KAAK;YACjD,uBAAuB,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAClE,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;AAChD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAe,EACf,QAAyB;IAEzB,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,wBAAwB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAE3D,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;AAChD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAe;IAClD,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnD,IAAI,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAc,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/schema-validator.d.ts

@@ -0,0 +1,18 @@
+import type { BlockTree, BlockElement, BlockDefinition, BlockCatalog, ValidationResult } from '@10up/block-renderer-core';
+/**
+ * Validates a block element's props against its schema.
+ */
+export declare function validateBlockProps(element: BlockElement, definition: BlockDefinition): ValidationResult;
+/**
+ * Validates all blocks in a tree against their schemas.
+ */
+export declare function validateTreeSchemas(tree: BlockTree, catalog: BlockCatalog): ValidationResult;
+/**
+ * Creates a validator function for a specific block type.
+ */
+export declare function createBlockValidator(definition: BlockDefinition): (props: unknown) => ValidationResult;
+/**
+ * Gets a list of valid attribute names for a block.
+ */
+export declare function getValidAttributes(definition: BlockDefinition): string[];
+//# sourceMappingURL=schema-validator.d.ts.map

package/dist/schema-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.d.ts","sourceRoot":"","sources":["../src/schema-validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAEnC;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,eAAe,GAC1B,gBAAgB,CA8BlB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,YAAY,GACpB,gBAAgB,CA6BlB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,eAAe,GAC1B,CAAC,KAAK,EAAE,OAAO,KAAK,gBAAgB,CAetC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,EAAE,CAGxE"}

package/dist/schema-validator.js

@@ -0,0 +1,76 @@
+/**
+ * Validates a block element's props against its schema.
+ */
+export function validateBlockProps(element, definition) {
+    const errors = [];
+    const warnings = [];
+    try {
+        // Validate props against the schema
+        const result = definition.schema.safeParse(element.props);
+        if (!result.success) {
+            // Extract error messages from Zod
+            for (const issue of result.error.issues) {
+                const path = issue.path.join('.');
+                errors.push(`[${element.key}] Invalid prop "${path}": ${issue.message}`);
+            }
+        }
+    }
+    catch (error) {
+        errors.push(`[${element.key}] Schema validation error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}
+/**
+ * Validates all blocks in a tree against their schemas.
+ */
+export function validateTreeSchemas(tree, catalog) {
+    const errors = [];
+    const warnings = [];
+    for (const element of Object.values(tree.elements)) {
+        const definition = catalog.get(element.type);
+        if (!definition) {
+            // Unknown block type - could be a 3rd party block
+            warnings.push(`[${element.key}] Unknown block type: ${element.type}`);
+            continue;
+        }
+        const result = validateBlockProps(element, definition);
+        if (!result.valid) {
+            errors.push(...result.errors);
+        }
+        if (result.warnings) {
+            warnings.push(...result.warnings);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}
+/**
+ * Creates a validator function for a specific block type.
+ */
+export function createBlockValidator(definition) {
+    return (props) => {
+        const result = definition.schema.safeParse(props);
+        if (result.success) {
+            return { valid: true, errors: [] };
+        }
+        return {
+            valid: false,
+            errors: result.error.issues.map(issue => `Invalid prop "${issue.path.join('.')}": ${issue.message}`),
+        };
+    };
+}
+/**
+ * Gets a list of valid attribute names for a block.
+ */
+export function getValidAttributes(definition) {
+    const shape = definition.schema.shape;
+    return Object.keys(shape);
+}
+//# sourceMappingURL=schema-validator.js.map

package/dist/schema-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.js","sourceRoot":"","sources":["../src/schema-validator.ts"],"names":[],"mappings":"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"}