@wp-typia/block-types 0.2.4 → 0.3.1

package/dist/blocks/compatibility.d.ts

@@ -0,0 +1,296 @@
+export type WordPressVersion = `${number}.${number}` | `${number}.${number}.${number}`;
+export type WordPressBlockApiCompatibilityArea = 'blockSupports' | 'blockVariations' | 'blockBindings';
+export type WordPressBlockApiRuntime = 'block-json' | 'editor-js' | 'php';
+export type WordPressBlockApiCompatibilityStatus = 'supported' | 'unsupported' | 'unknown';
+export type WordPressBlockApiCompatibilityDiagnosticSeverity = 'error' | 'warning';
+export type WordPressBlockApiCompatibilityAction = 'generate' | 'guard' | 'skip' | 'pass-through';
+export interface WordPressBlockApiCompatibilityEntry {
+    readonly since: WordPressVersion;
+    readonly label: string;
+    readonly runtime: readonly WordPressBlockApiRuntime[];
+    readonly source: keyof typeof WORDPRESS_BLOCK_API_COMPATIBILITY_SOURCES;
+    readonly derivedAttributes?: readonly string[];
+    readonly fallback?: string;
+    readonly notes?: string;
+}
+export interface WordPressCompatibilitySettings {
+    readonly minVersion?: WordPressVersion;
+    readonly strict?: boolean;
+    readonly allowUnknownFutureKeys?: boolean;
+}
+export interface WordPressBlockApiCompatibilityFeature {
+    readonly area: WordPressBlockApiCompatibilityArea;
+    readonly feature: string;
+}
+export interface WordPressBlockApiCompatibilityDiagnostic {
+    readonly area: WordPressBlockApiCompatibilityArea;
+    readonly code: 'unsupported-wordpress-block-api-feature' | 'unknown-wordpress-block-api-feature';
+    readonly feature: string;
+    readonly message: string;
+    readonly minVersion: WordPressVersion;
+    readonly requiredVersion?: WordPressVersion;
+    readonly severity: WordPressBlockApiCompatibilityDiagnosticSeverity;
+}
+export interface WordPressBlockApiCompatibilityEvaluation extends WordPressBlockApiCompatibilityFeature {
+    readonly action: WordPressBlockApiCompatibilityAction;
+    readonly entry?: WordPressBlockApiCompatibilityEntry | undefined;
+    readonly diagnostic?: WordPressBlockApiCompatibilityDiagnostic | undefined;
+    readonly minVersion: WordPressVersion;
+    readonly status: WordPressBlockApiCompatibilityStatus;
+}
+export interface WordPressBlockApiCompatibilityManifest {
+    readonly allowUnknownFutureKeys: boolean;
+    readonly diagnostics: readonly WordPressBlockApiCompatibilityDiagnostic[];
+    readonly evaluations: readonly WordPressBlockApiCompatibilityEvaluation[];
+    readonly minVersion: WordPressVersion;
+    readonly strict: boolean;
+    readonly supported: readonly WordPressBlockApiCompatibilityEvaluation[];
+    readonly unknown: readonly WordPressBlockApiCompatibilityEvaluation[];
+    readonly unsupported: readonly WordPressBlockApiCompatibilityEvaluation[];
+}
+export declare const DEFAULT_WORDPRESS_COMPATIBILITY_MIN_VERSION: "6.7";
+export declare const WORDPRESS_VERSION_PATTERN: RegExp;
+export declare const WORDPRESS_BLOCK_API_COMPATIBILITY_SOURCES: {
+    readonly blockBindingsHandbook: "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/";
+    readonly blockBindingsReference: "https://developer.wordpress.org/reference/functions/register_block_bindings_source/";
+    readonly blockBindingsSupportedAttributes: "https://developer.wordpress.org/reference/functions/get_block_bindings_supported_attributes/";
+    readonly blockSupportsHandbook: "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-supports/";
+    readonly blockVariationsDevNote: "https://make.wordpress.org/core/2020/02/27/introduce-block-variations-api/";
+    readonly blockVariationsPhpDevNote: "https://make.wordpress.org/core/2024/02/29/performance-improvements-for-registering-block-variations-with-callbacks/";
+    readonly themeJsonStyleVersions: "https://developer.wordpress.org/block-editor/reference-guides/theme-json-reference/styles-versions/";
+    readonly wordpressBlocksPackage: "https://developer.wordpress.org/block-editor/reference-guides/packages/packages-blocks/";
+};
+export declare const WORDPRESS_BLOCK_API_COMPATIBILITY: {
+    readonly blockBindings: {
+        readonly 'metadata.bindings': {
+            readonly derivedAttributes: readonly ["metadata"];
+            readonly label: "block metadata.bindings";
+            readonly runtime: readonly ["block-json", "php"];
+            readonly since: "6.5";
+            readonly source: "blockBindingsHandbook";
+        };
+        readonly editorRegistration: {
+            readonly fallback: "Keep server-side registration only.";
+            readonly label: "registerBlockBindingsSource() editor registration";
+            readonly runtime: readonly ["editor-js"];
+            readonly since: "6.7";
+            readonly source: "wordpressBlocksPackage";
+        };
+        readonly editorFieldsList: {
+            readonly fallback: "Register the source without getFieldsList() or keep a custom editor UI.";
+            readonly label: "registerBlockBindingsSource() getFieldsList()";
+            readonly runtime: readonly ["editor-js"];
+            readonly since: "6.9";
+            readonly source: "blockBindingsHandbook";
+        };
+        readonly editorSourceLookup: {
+            readonly label: "getBlockBindingsSource() and getBlockBindingsSources()";
+            readonly runtime: readonly ["editor-js"];
+            readonly since: "6.7";
+            readonly source: "wordpressBlocksPackage";
+        };
+        readonly serverRegistration: {
+            readonly label: "register_block_bindings_source()";
+            readonly runtime: readonly ["php"];
+            readonly since: "6.5";
+            readonly source: "blockBindingsReference";
+        };
+        readonly supportedAttributesFilter: {
+            readonly fallback: "Keep the core supported-attributes list or guard the filter.";
+            readonly label: "block_bindings_supported_attributes filters";
+            readonly runtime: readonly ["php"];
+            readonly since: "6.9";
+            readonly source: "blockBindingsSupportedAttributes";
+        };
+    };
+    readonly blockSupports: {
+        readonly allowedBlocks: {
+            readonly derivedAttributes: readonly ["allowedBlocks"];
+            readonly fallback: "Pass allowedBlocks directly to useInnerBlocksProps() in custom editor code.";
+            readonly label: "supports.allowedBlocks";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.9";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly background: {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.background";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'color.button': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.color.button";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'color.enableContrastChecker': {
+            readonly label: "supports.color.enableContrastChecker";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'color.heading': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.color.heading";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly contentRole: {
+            readonly label: "supports.contentRole";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.9";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly dimensions: {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.dimensions";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.2";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'filter.duotone': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.filter.duotone";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly listView: {
+            readonly label: "supports.listView";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "7.0";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly position: {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.position";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.2";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly renaming: {
+            readonly label: "supports.renaming";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly shadow: {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.shadow";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.5";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'spacing.blockGap': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.spacing.blockGap";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'spacing.margin': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.spacing.margin";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'spacing.padding': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.spacing.padding";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'typography.fontSize': {
+            readonly derivedAttributes: readonly ["fontSize", "style"];
+            readonly label: "supports.typography.fontSize";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.8";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'typography.letterSpacing': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.typography.letterSpacing";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'typography.lineHeight': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.typography.lineHeight";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.8";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'typography.textAlign': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.typography.textAlign";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.6";
+            readonly source: "blockSupportsHandbook";
+        };
+        readonly 'typography.textDecoration': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.typography.textDecoration";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly 'typography.textTransform': {
+            readonly derivedAttributes: readonly ["style"];
+            readonly label: "supports.typography.textTransform";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.9";
+            readonly source: "themeJsonStyleVersions";
+        };
+        readonly visibility: {
+            readonly fallback: "Keep the default block options menu behavior.";
+            readonly label: "supports.visibility";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "6.9";
+            readonly source: "blockSupportsHandbook";
+        };
+    };
+    readonly blockVariations: {
+        readonly editorRegistration: {
+            readonly label: "registerBlockVariation() editor registration";
+            readonly runtime: readonly ["editor-js"];
+            readonly since: "5.4";
+            readonly source: "blockVariationsDevNote";
+        };
+        readonly phpVariationCallback: {
+            readonly fallback: "Build static variations or register them in editor JavaScript.";
+            readonly label: "WP_Block_Type variation_callback";
+            readonly runtime: readonly ["php"];
+            readonly since: "6.5";
+            readonly source: "blockVariationsPhpDevNote";
+        };
+        readonly phpVariationsFilter: {
+            readonly fallback: "Use JavaScript registration or guard the PHP filter path.";
+            readonly label: "get_block_type_variations filter";
+            readonly runtime: readonly ["php"];
+            readonly since: "6.5";
+            readonly source: "blockVariationsPhpDevNote";
+        };
+        readonly registrationMetadata: {
+            readonly label: "block registration variations metadata";
+            readonly runtime: readonly ["block-json", "editor-js"];
+            readonly since: "5.4";
+            readonly source: "blockVariationsDevNote";
+        };
+    };
+};
+export type WordPressBlockSupportCompatibilityFeature = keyof typeof WORDPRESS_BLOCK_API_COMPATIBILITY.blockSupports;
+export type WordPressBlockVariationCompatibilityFeature = keyof typeof WORDPRESS_BLOCK_API_COMPATIBILITY.blockVariations;
+export type WordPressBlockBindingCompatibilityFeature = keyof typeof WORDPRESS_BLOCK_API_COMPATIBILITY.blockBindings;
+export declare function assertWordPressVersion(value: string): asserts value is WordPressVersion;
+export declare function compareWordPressVersions(left: string, right: string): number;
+export declare function isWordPressVersionAtLeast(version: string, minimum: string): boolean;
+export declare function getWordPressBlockApiCompatibilityEntry(area: WordPressBlockApiCompatibilityArea, feature: string): WordPressBlockApiCompatibilityEntry | undefined;
+export declare function evaluateWordPressBlockApiCompatibility(feature: WordPressBlockApiCompatibilityFeature, settings?: WordPressCompatibilitySettings): WordPressBlockApiCompatibilityEvaluation;
+export declare function createWordPressBlockApiCompatibilityManifest(features: readonly WordPressBlockApiCompatibilityFeature[], settings?: WordPressCompatibilitySettings): WordPressBlockApiCompatibilityManifest;

package/dist/blocks/compatibility.js

@@ -0,0 +1,338 @@
+export const DEFAULT_WORDPRESS_COMPATIBILITY_MIN_VERSION = '6.7';
+export const WORDPRESS_VERSION_PATTERN = /^\d+\.\d+(?:\.\d+)?$/u;
+export const WORDPRESS_BLOCK_API_COMPATIBILITY_SOURCES = {
+    blockBindingsHandbook: 'https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/',
+    blockBindingsReference: 'https://developer.wordpress.org/reference/functions/register_block_bindings_source/',
+    blockBindingsSupportedAttributes: 'https://developer.wordpress.org/reference/functions/get_block_bindings_supported_attributes/',
+    blockSupportsHandbook: 'https://developer.wordpress.org/block-editor/reference-guides/block-api/block-supports/',
+    blockVariationsDevNote: 'https://make.wordpress.org/core/2020/02/27/introduce-block-variations-api/',
+    blockVariationsPhpDevNote: 'https://make.wordpress.org/core/2024/02/29/performance-improvements-for-registering-block-variations-with-callbacks/',
+    themeJsonStyleVersions: 'https://developer.wordpress.org/block-editor/reference-guides/theme-json-reference/styles-versions/',
+    wordpressBlocksPackage: 'https://developer.wordpress.org/block-editor/reference-guides/packages/packages-blocks/',
+};
+export const WORDPRESS_BLOCK_API_COMPATIBILITY = {
+    blockBindings: {
+        'metadata.bindings': {
+            derivedAttributes: ['metadata'],
+            label: 'block metadata.bindings',
+            runtime: ['block-json', 'php'],
+            since: '6.5',
+            source: 'blockBindingsHandbook',
+        },
+        editorRegistration: {
+            fallback: 'Keep server-side registration only.',
+            label: 'registerBlockBindingsSource() editor registration',
+            runtime: ['editor-js'],
+            since: '6.7',
+            source: 'wordpressBlocksPackage',
+        },
+        editorFieldsList: {
+            fallback: 'Register the source without getFieldsList() or keep a custom editor UI.',
+            label: 'registerBlockBindingsSource() getFieldsList()',
+            runtime: ['editor-js'],
+            since: '6.9',
+            source: 'blockBindingsHandbook',
+        },
+        editorSourceLookup: {
+            label: 'getBlockBindingsSource() and getBlockBindingsSources()',
+            runtime: ['editor-js'],
+            since: '6.7',
+            source: 'wordpressBlocksPackage',
+        },
+        serverRegistration: {
+            label: 'register_block_bindings_source()',
+            runtime: ['php'],
+            since: '6.5',
+            source: 'blockBindingsReference',
+        },
+        supportedAttributesFilter: {
+            fallback: 'Keep the core supported-attributes list or guard the filter.',
+            label: 'block_bindings_supported_attributes filters',
+            runtime: ['php'],
+            since: '6.9',
+            source: 'blockBindingsSupportedAttributes',
+        },
+    },
+    blockSupports: {
+        allowedBlocks: {
+            derivedAttributes: ['allowedBlocks'],
+            fallback: 'Pass allowedBlocks directly to useInnerBlocksProps() in custom editor code.',
+            label: 'supports.allowedBlocks',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.9',
+            source: 'blockSupportsHandbook',
+        },
+        background: {
+            derivedAttributes: ['style'],
+            label: 'supports.background',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        'color.button': {
+            derivedAttributes: ['style'],
+            label: 'supports.color.button',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        'color.enableContrastChecker': {
+            label: 'supports.color.enableContrastChecker',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        'color.heading': {
+            derivedAttributes: ['style'],
+            label: 'supports.color.heading',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        contentRole: {
+            label: 'supports.contentRole',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.9',
+            source: 'blockSupportsHandbook',
+        },
+        dimensions: {
+            derivedAttributes: ['style'],
+            label: 'supports.dimensions',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.2',
+            source: 'blockSupportsHandbook',
+        },
+        'filter.duotone': {
+            derivedAttributes: ['style'],
+            label: 'supports.filter.duotone',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        listView: {
+            label: 'supports.listView',
+            runtime: ['block-json', 'editor-js'],
+            since: '7.0',
+            source: 'blockSupportsHandbook',
+        },
+        position: {
+            derivedAttributes: ['style'],
+            label: 'supports.position',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.2',
+            source: 'blockSupportsHandbook',
+        },
+        renaming: {
+            label: 'supports.renaming',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        shadow: {
+            derivedAttributes: ['style'],
+            label: 'supports.shadow',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.5',
+            source: 'blockSupportsHandbook',
+        },
+        'spacing.blockGap': {
+            derivedAttributes: ['style'],
+            label: 'supports.spacing.blockGap',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        'spacing.margin': {
+            derivedAttributes: ['style'],
+            label: 'supports.spacing.margin',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        'spacing.padding': {
+            derivedAttributes: ['style'],
+            label: 'supports.spacing.padding',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        'typography.fontSize': {
+            derivedAttributes: ['fontSize', 'style'],
+            label: 'supports.typography.fontSize',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.8',
+            source: 'themeJsonStyleVersions',
+        },
+        'typography.letterSpacing': {
+            derivedAttributes: ['style'],
+            label: 'supports.typography.letterSpacing',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        'typography.lineHeight': {
+            derivedAttributes: ['style'],
+            label: 'supports.typography.lineHeight',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.8',
+            source: 'themeJsonStyleVersions',
+        },
+        'typography.textAlign': {
+            derivedAttributes: ['style'],
+            label: 'supports.typography.textAlign',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.6',
+            source: 'blockSupportsHandbook',
+        },
+        'typography.textDecoration': {
+            derivedAttributes: ['style'],
+            label: 'supports.typography.textDecoration',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        'typography.textTransform': {
+            derivedAttributes: ['style'],
+            label: 'supports.typography.textTransform',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.9',
+            source: 'themeJsonStyleVersions',
+        },
+        visibility: {
+            fallback: 'Keep the default block options menu behavior.',
+            label: 'supports.visibility',
+            runtime: ['block-json', 'editor-js'],
+            since: '6.9',
+            source: 'blockSupportsHandbook',
+        },
+    },
+    blockVariations: {
+        editorRegistration: {
+            label: 'registerBlockVariation() editor registration',
+            runtime: ['editor-js'],
+            since: '5.4',
+            source: 'blockVariationsDevNote',
+        },
+        phpVariationCallback: {
+            fallback: 'Build static variations or register them in editor JavaScript.',
+            label: 'WP_Block_Type variation_callback',
+            runtime: ['php'],
+            since: '6.5',
+            source: 'blockVariationsPhpDevNote',
+        },
+        phpVariationsFilter: {
+            fallback: 'Use JavaScript registration or guard the PHP filter path.',
+            label: 'get_block_type_variations filter',
+            runtime: ['php'],
+            since: '6.5',
+            source: 'blockVariationsPhpDevNote',
+        },
+        registrationMetadata: {
+            label: 'block registration variations metadata',
+            runtime: ['block-json', 'editor-js'],
+            since: '5.4',
+            source: 'blockVariationsDevNote',
+        },
+    },
+};
+function normalizeCompatibilitySettings(settings) {
+    return {
+        allowUnknownFutureKeys: settings.allowUnknownFutureKeys ?? false,
+        minVersion: settings.minVersion ?? DEFAULT_WORDPRESS_COMPATIBILITY_MIN_VERSION,
+        strict: settings.strict ?? true,
+    };
+}
+export function assertWordPressVersion(value) {
+    if (!WORDPRESS_VERSION_PATTERN.test(value)) {
+        throw new Error(`Invalid WordPress version "${value}". Expected dotted numeric version such as "6.7" or "6.7.1".`);
+    }
+}
+export function compareWordPressVersions(left, right) {
+    assertWordPressVersion(left);
+    assertWordPressVersion(right);
+    const leftParts = left.split('.').map((part) => Number.parseInt(part, 10));
+    const rightParts = right.split('.').map((part) => Number.parseInt(part, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] ?? 0;
+        const rightValue = rightParts[index] ?? 0;
+        if (leftValue > rightValue) {
+            return 1;
+        }
+        if (leftValue < rightValue) {
+            return -1;
+        }
+    }
+    return 0;
+}
+export function isWordPressVersionAtLeast(version, minimum) {
+    return compareWordPressVersions(version, minimum) >= 0;
+}
+export function getWordPressBlockApiCompatibilityEntry(area, feature) {
+    return WORDPRESS_BLOCK_API_COMPATIBILITY[area][feature];
+}
+export function evaluateWordPressBlockApiCompatibility(feature, settings = {}) {
+    const resolved = normalizeCompatibilitySettings(settings);
+    const entry = getWordPressBlockApiCompatibilityEntry(feature.area, feature.feature);
+    const severity = resolved.strict ? 'error' : 'warning';
+    if (!entry) {
+        const diagnostic = resolved.allowUnknownFutureKeys
+            ? undefined
+            : {
+                area: feature.area,
+                code: 'unknown-wordpress-block-api-feature',
+                feature: feature.feature,
+                message: `Unknown WordPress block API feature "${feature.area}.${feature.feature}".`,
+                minVersion: resolved.minVersion,
+                severity,
+            };
+        return {
+            ...feature,
+            action: resolved.allowUnknownFutureKeys ? 'pass-through' : 'guard',
+            diagnostic,
+            minVersion: resolved.minVersion,
+            status: 'unknown',
+        };
+    }
+    if (isWordPressVersionAtLeast(resolved.minVersion, entry.since)) {
+        return {
+            ...feature,
+            action: 'generate',
+            entry,
+            minVersion: resolved.minVersion,
+            status: 'supported',
+        };
+    }
+    const diagnostic = {
+        area: feature.area,
+        code: 'unsupported-wordpress-block-api-feature',
+        feature: feature.feature,
+        message: `${entry.label} requires WordPress ${entry.since}+ but the configured minimum is ${resolved.minVersion}.`,
+        minVersion: resolved.minVersion,
+        requiredVersion: entry.since,
+        severity,
+    };
+    return {
+        ...feature,
+        action: resolved.strict ? 'skip' : 'guard',
+        diagnostic,
+        entry,
+        minVersion: resolved.minVersion,
+        status: 'unsupported',
+    };
+}
+export function createWordPressBlockApiCompatibilityManifest(features, settings = {}) {
+    const resolved = normalizeCompatibilitySettings(settings);
+    const evaluations = features.map((feature) => evaluateWordPressBlockApiCompatibility(feature, resolved));
+    const diagnostics = evaluations.flatMap((evaluation) => evaluation.diagnostic ? [evaluation.diagnostic] : []);
+    return {
+        allowUnknownFutureKeys: resolved.allowUnknownFutureKeys,
+        diagnostics,
+        evaluations,
+        minVersion: resolved.minVersion,
+        strict: resolved.strict,
+        supported: evaluations.filter((evaluation) => evaluation.status === 'supported'),
+        unknown: evaluations.filter((evaluation) => evaluation.status === 'unknown'),
+        unsupported: evaluations.filter((evaluation) => evaluation.status === 'unsupported'),
+    };
+}

package/dist/blocks/index.d.ts

@@ -1,2 +1,5 @@
+export * from "./bindings.js";
+export * from "./compatibility.js";
 export * from "./registration.js";
 export * from "./supports.js";
+export * from "./variations.js";

package/dist/blocks/index.js

@@ -1,2 +1,5 @@
+export * from "./bindings.js";
+export * from "./compatibility.js";
 export * from "./registration.js";
 export * from "./supports.js";
+export * from "./variations.js";

package/dist/blocks/shared/diagnostics.d.ts

@@ -0,0 +1,13 @@
+export type DiagnosticSeverity = "error" | "warning";
+export interface DiagnosticWithMessage {
+    readonly message: string;
+    readonly severity: DiagnosticSeverity;
+}
+export interface DiagnosticLogger<TDiagnostic extends DiagnosticWithMessage = DiagnosticWithMessage> {
+    readonly warn: (message: string, diagnostic: TDiagnostic) => void;
+}
+export declare function getDiagnosticSeverity(strict: boolean): DiagnosticSeverity;
+export declare function handleDiagnostics<TDiagnostic extends DiagnosticWithMessage>(diagnostics: readonly TDiagnostic[], onDiagnostic: ((diagnostic: TDiagnostic) => void) | undefined, options: {
+    readonly failureHeading: string;
+    readonly logger?: DiagnosticLogger<TDiagnostic> | undefined;
+}): void;