@wp-typia/block-types 0.3.1 → 0.3.2

package/dist/blocks/supports-diagnostics.js

@@ -0,0 +1,7 @@
+import { handleDiagnostics } from "./shared/diagnostics.js";
+export function handleDefineSupportsDiagnostics(diagnostics, onDiagnostic, logger) {
+    handleDiagnostics(diagnostics, onDiagnostic, {
+        failureHeading: "WordPress block supports compatibility check failed:",
+        logger,
+    });
+}

package/dist/blocks/supports-features.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Derived from Gutenberg block support keys and commonly used block.json
+ * support sections.
+ */
+export type BlockSupportFeature = "align" | "alignWide" | "allowedBlocks" | "anchor" | "ariaLabel" | "autoRegister" | "background" | "border" | "className" | "color" | "contentRole" | "customClassName" | "dimensions" | "filter" | "html" | "inserter" | "interactivity" | "js" | "layout" | "lightbox" | "listView" | "lock" | "locking" | "multiple" | "position" | "renaming" | "reusable" | "shadow" | "spacing" | "splitting" | "visibility" | "typography";
+export declare const BLOCK_SUPPORT_FEATURES: readonly ["align", "alignWide", "allowedBlocks", "anchor", "ariaLabel", "autoRegister", "background", "border", "className", "color", "contentRole", "customClassName", "dimensions", "filter", "html", "inserter", "interactivity", "js", "layout", "lightbox", "listView", "lock", "locking", "multiple", "position", "renaming", "reusable", "shadow", "spacing", "splitting", "typography", "visibility"];
+export type TypographySupportKey = "fontFamily" | "fontSize" | "fontStyle" | "fontWeight" | "letterSpacing" | "lineHeight" | "dropCap" | "textAlign" | "textColumns" | "textDecoration" | "textTransform" | "writingMode";
+export declare const TYPOGRAPHY_SUPPORT_KEYS: readonly ["fontFamily", "fontSize", "fontStyle", "fontWeight", "letterSpacing", "lineHeight", "dropCap", "textAlign", "textColumns", "textDecoration", "textTransform", "writingMode"];
+export type SpacingSupportKey = "blockGap" | "margin" | "padding";
+export declare const SPACING_SUPPORT_KEYS: readonly ["blockGap", "margin", "padding"];

package/dist/blocks/supports-features.js

@@ -0,0 +1,53 @@
+export const BLOCK_SUPPORT_FEATURES = [
+    "align",
+    "alignWide",
+    "allowedBlocks",
+    "anchor",
+    "ariaLabel",
+    "autoRegister",
+    "background",
+    "border",
+    "className",
+    "color",
+    "contentRole",
+    "customClassName",
+    "dimensions",
+    "filter",
+    "html",
+    "inserter",
+    "interactivity",
+    "js",
+    "layout",
+    "lightbox",
+    "listView",
+    "lock",
+    "locking",
+    "multiple",
+    "position",
+    "renaming",
+    "reusable",
+    "shadow",
+    "spacing",
+    "splitting",
+    "typography",
+    "visibility",
+];
+export const TYPOGRAPHY_SUPPORT_KEYS = [
+    "fontFamily",
+    "fontSize",
+    "fontStyle",
+    "fontWeight",
+    "letterSpacing",
+    "lineHeight",
+    "dropCap",
+    "textAlign",
+    "textColumns",
+    "textDecoration",
+    "textTransform",
+    "writingMode",
+];
+export const SPACING_SUPPORT_KEYS = [
+    "blockGap",
+    "margin",
+    "padding",
+];

package/dist/blocks/supports-manifest.d.ts

@@ -0,0 +1,4 @@
+import { type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest } from "./compatibility.js";
+import type { BlockSupportsInput, DefineSupportsOptions } from "./supports.js";
+export declare function collectBlockSupportsCompatibilityFeatures(supports: BlockSupportsInput): readonly WordPressBlockApiCompatibilityFeature[];
+export declare function createBlockSupportsCompatibilityManifest(supports: BlockSupportsInput, settings?: DefineSupportsOptions): WordPressBlockApiCompatibilityManifest;

package/dist/blocks/supports-manifest.js

@@ -0,0 +1,97 @@
+import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.js";
+import { BLOCK_SUPPORT_FEATURES, SPACING_SUPPORT_KEYS, } from "./supports-features.js";
+import { DEFINE_SUPPORTS_INLINE_OPTION_KEYS, resolveDefineSupportsSettings, } from "./supports-settings.js";
+import { isNonArrayObject, isObjectRecord, } from "./shared/object-utils.js";
+const KNOWN_BLOCK_SUPPORT_FEATURES = new Set(BLOCK_SUPPORT_FEATURES);
+const COLOR_COMPATIBILITY_SUPPORT_KEYS = [
+    "button",
+    "enableContrastChecker",
+    "heading",
+];
+const TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS = [
+    "fontSize",
+    "letterSpacing",
+    "lineHeight",
+    "textAlign",
+    "textDecoration",
+    "textTransform",
+];
+const TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS = [
+    "allowedBlocks",
+    "background",
+    "contentRole",
+    "dimensions",
+    "listView",
+    "position",
+    "renaming",
+    "shadow",
+    "visibility",
+];
+function isEnabledSupportValue(value) {
+    return value !== false && value !== null && value !== undefined;
+}
+function isEnabledTopLevelSupportValue(value) {
+    if (!isObjectRecord(value)) {
+        return isNonArrayObject(value) ? false : isEnabledSupportValue(value);
+    }
+    return Object.entries(value).some(([key, nestedValue]) => !key.startsWith("__experimental") &&
+        isEnabledSupportValue(nestedValue));
+}
+function hasEnabledNestedSupport(section, key) {
+    return isObjectRecord(section) && isEnabledSupportValue(section[key]);
+}
+function addCompatibilityFeature(features, seen, feature) {
+    const id = `blockSupports.${feature}`;
+    if (seen.has(id)) {
+        return;
+    }
+    seen.add(id);
+    features.push({
+        area: "blockSupports",
+        feature,
+    });
+}
+export function collectBlockSupportsCompatibilityFeatures(supports) {
+    const features = [];
+    const seen = new Set();
+    for (const key of TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS) {
+        if (isEnabledTopLevelSupportValue(supports[key])) {
+            addCompatibilityFeature(features, seen, key);
+        }
+    }
+    const spacing = supports.spacing;
+    for (const key of SPACING_SUPPORT_KEYS) {
+        if (hasEnabledNestedSupport(spacing, key)) {
+            addCompatibilityFeature(features, seen, `spacing.${key}`);
+        }
+    }
+    const typography = supports.typography;
+    for (const key of TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS) {
+        if (hasEnabledNestedSupport(typography, key)) {
+            addCompatibilityFeature(features, seen, `typography.${key}`);
+        }
+    }
+    const color = supports.color;
+    if (isObjectRecord(color)) {
+        for (const key of COLOR_COMPATIBILITY_SUPPORT_KEYS) {
+            if (isEnabledSupportValue(color[key])) {
+                addCompatibilityFeature(features, seen, `color.${key}`);
+            }
+        }
+    }
+    if (hasEnabledNestedSupport(supports.filter, "duotone")) {
+        addCompatibilityFeature(features, seen, "filter.duotone");
+    }
+    for (const key of Object.keys(supports)) {
+        if (!KNOWN_BLOCK_SUPPORT_FEATURES.has(key) &&
+            !DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key) &&
+            isEnabledTopLevelSupportValue(supports[key])) {
+            addCompatibilityFeature(features, seen, key);
+        }
+    }
+    return features;
+}
+export function createBlockSupportsCompatibilityManifest(supports, settings = {}) {
+    const compatibilitySettings = resolveDefineSupportsSettings({}, settings);
+    return createWordPressBlockApiCompatibilityManifest(collectBlockSupportsCompatibilityFeatures(supports), compatibilitySettings);
+}

package/dist/blocks/supports-settings.d.ts

@@ -0,0 +1,8 @@
+import type { WordPressCompatibilitySettings } from "./compatibility.js";
+import type { BlockSupportsInput, DefineSupportsInlineOptions, DefineSupportsOptions, StripDefineSupportsOptions } from "./supports.js";
+export declare const DEFINE_SUPPORTS_INLINE_OPTION_KEYS: Set<string>;
+export declare function splitDefineSupportsInput<TSupports extends BlockSupportsInput>(supports: TSupports & DefineSupportsInlineOptions): {
+    inlineOptions: DefineSupportsInlineOptions;
+    supports: StripDefineSupportsOptions<TSupports> & BlockSupportsInput;
+};
+export declare function resolveDefineSupportsSettings(inlineOptions: DefineSupportsInlineOptions, options: DefineSupportsOptions): WordPressCompatibilitySettings;

package/dist/blocks/supports-settings.js

@@ -0,0 +1,42 @@
+export const DEFINE_SUPPORTS_INLINE_OPTION_KEYS = new Set([
+    "allowUnknownFutureKeys",
+    "logger",
+    "minVersion",
+    "minWordPress",
+    "onDiagnostic",
+    "strict",
+]);
+export function splitDefineSupportsInput(supports) {
+    const normalizedSupports = {};
+    const inlineOptions = {};
+    for (const [key, value] of Object.entries(supports)) {
+        if (DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key)) {
+            Object.assign(inlineOptions, { [key]: value });
+            continue;
+        }
+        normalizedSupports[key] = value;
+    }
+    return {
+        inlineOptions,
+        supports: normalizedSupports,
+    };
+}
+export function resolveDefineSupportsSettings(inlineOptions, options) {
+    const settings = {};
+    const allowUnknownFutureKeys = options.allowUnknownFutureKeys ?? inlineOptions.allowUnknownFutureKeys;
+    const minVersion = options.minVersion ??
+        options.minWordPress ??
+        inlineOptions.minVersion ??
+        inlineOptions.minWordPress;
+    const strict = options.strict ?? inlineOptions.strict;
+    if (allowUnknownFutureKeys !== undefined) {
+        Object.assign(settings, { allowUnknownFutureKeys });
+    }
+    if (minVersion !== undefined) {
+        Object.assign(settings, { minVersion });
+    }
+    if (strict !== undefined) {
+        Object.assign(settings, { strict });
+    }
+    return settings;
+}

package/dist/blocks/supports.d.ts

@@ -2,18 +2,12 @@ import type { BlockAlignment, BlockVerticalAlignment, JustifyContent, TextAlignm
 import type { BlockBorderSupportAttributes, BlockColorSupportAttributes, BlockDimensionsSupportAttributes, BlockSpacingSupportAttributes, BlockStyleAttributes, BlockTypographySupportAttributes } from "../block-editor/style-attributes.js";
 import type { FlexWrap, LayoutType, Orientation } from "../block-editor/layout.js";
 import type { SpacingAxis, SpacingDimension } from "../block-editor/spacing.js";
-import { type WordPressBlockApiCompatibilityDiagnostic, type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings, type WordPressVersion } from "./compatibility.js";
+import { type WordPressBlockApiCompatibilityDiagnostic, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings, type WordPressVersion } from "./compatibility.js";
+import { BLOCK_SUPPORT_FEATURES, SPACING_SUPPORT_KEYS, TYPOGRAPHY_SUPPORT_KEYS, type BlockSupportFeature, type SpacingSupportKey, type TypographySupportKey } from "./supports-features.js";
+import { collectBlockSupportsCompatibilityFeatures, createBlockSupportsCompatibilityManifest } from "./supports-manifest.js";
+export { BLOCK_SUPPORT_FEATURES, SPACING_SUPPORT_KEYS, TYPOGRAPHY_SUPPORT_KEYS, collectBlockSupportsCompatibilityFeatures, createBlockSupportsCompatibilityManifest, };
+export type { BlockSupportFeature, SpacingSupportKey, TypographySupportKey, };
 import { type DiagnosticLogger } from "./shared/diagnostics.js";
-/**
- * Derived from Gutenberg block support keys and commonly used block.json
- * support sections.
- */
-export type BlockSupportFeature = 'align' | 'alignWide' | 'allowedBlocks' | 'anchor' | 'ariaLabel' | 'autoRegister' | 'background' | 'border' | 'className' | 'color' | 'contentRole' | 'customClassName' | 'dimensions' | 'filter' | 'html' | 'inserter' | 'interactivity' | 'js' | 'layout' | 'lightbox' | 'listView' | 'lock' | 'locking' | 'multiple' | 'position' | 'renaming' | 'reusable' | 'shadow' | 'spacing' | 'splitting' | 'visibility' | 'typography';
-export declare const BLOCK_SUPPORT_FEATURES: readonly ["align", "alignWide", "allowedBlocks", "anchor", "ariaLabel", "autoRegister", "background", "border", "className", "color", "contentRole", "customClassName", "dimensions", "filter", "html", "inserter", "interactivity", "js", "layout", "lightbox", "listView", "lock", "locking", "multiple", "position", "renaming", "reusable", "shadow", "spacing", "splitting", "typography", "visibility"];
-export type TypographySupportKey = 'fontFamily' | 'fontSize' | 'fontStyle' | 'fontWeight' | 'letterSpacing' | 'lineHeight' | 'dropCap' | 'textAlign' | 'textColumns' | 'textDecoration' | 'textTransform' | 'writingMode';
-export declare const TYPOGRAPHY_SUPPORT_KEYS: readonly ["fontFamily", "fontSize", "fontStyle", "fontWeight", "letterSpacing", "lineHeight", "dropCap", "textAlign", "textColumns", "textDecoration", "textTransform", "writingMode"];
-export type SpacingSupportKey = 'blockGap' | 'margin' | 'padding';
-export declare const SPACING_SUPPORT_KEYS: readonly ["blockGap", "margin", "padding"];
 type BlockSupportDefaultControls<TFeature extends string> = Readonly<Partial<Record<TFeature, boolean>> & Record<string, boolean | undefined>>;
 export type SkipSerialization<TFeature extends string> = boolean | readonly TFeature[];
 export interface BlockBorderSupport {
@@ -215,8 +209,5 @@ export type DefinedBlockSupports<TSupports extends BlockSupportsInput = BlockSup
 };
 export type SupportAttributes<TSupports> = TSupports extends DefinedBlockSupports<infer TDefinedSupports> ? SupportAttributesFromBlockSupports<StripDefineSupportsOptions<TDefinedSupports>> : TSupports extends BlockSupportsInput ? SupportAttributesFromBlockSupports<StripDefineSupportsOptions<TSupports>> : {};
 export type SupportAttributesFromBlockSupports<TSupports> = IfSupport<HasSupport<TSupports, "align">, BlockAlignSupportAttributes> & IfSupport<HasSupport<TSupports, "allowedBlocks">, BlockAllowedBlocksSupportAttributes> & IfSupport<HasSupport<TSupports, "layout">, BlockLayoutSupportAttributes> & IfSupport<HasSupport<TSupports, "color">, BlockColorSupportAttributes> & IfSupport<HasSupport<TSupports, "typography">, BlockTypographySupportAttributes> & IfSupport<HasSupport<TSupports, "spacing">, BlockSpacingSupportAttributes> & IfSupport<HasSupport<TSupports, "dimensions">, BlockDimensionsSupportAttributes> & IfSupport<HasSupport<TSupports, "border">, BlockBorderSupportAttributes> & IfSupport<HasSupport<TSupports, "background">, BlockStyleAttributeSupportAttributes> & IfSupport<HasNestedSupport<TSupports, "filter", "duotone">, BlockStyleAttributeSupportAttributes> & IfSupport<HasSupport<TSupports, "position">, BlockStyleAttributeSupportAttributes> & IfSupport<HasSupport<TSupports, "shadow">, BlockStyleAttributeSupportAttributes>;
-export declare function collectBlockSupportsCompatibilityFeatures(supports: BlockSupportsInput): readonly WordPressBlockApiCompatibilityFeature[];
-export declare function createBlockSupportsCompatibilityManifest(supports: BlockSupportsInput, settings?: DefineSupportsOptions): WordPressBlockApiCompatibilityManifest;
 export declare function getDefinedSupportsCompatibilityManifest(supports: unknown): WordPressBlockApiCompatibilityManifest | undefined;
 export declare function defineSupports<const TSupports extends BlockSupportsInput & DefineSupportsInlineOptions>(supports: TSupports, options?: DefineSupportsOptions): DefinedBlockSupports<TSupports>;
-export {};

package/dist/blocks/supports.js

@@ -1,201 +1,10 @@
-import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.js";
-import { handleDiagnostics, } from "./shared/diagnostics.js";
-import { isNonArrayObject, isObjectRecord, } from "./shared/object-utils.js";
-export const BLOCK_SUPPORT_FEATURES = [
-    'align',
-    'alignWide',
-    'allowedBlocks',
-    'anchor',
-    'ariaLabel',
-    'autoRegister',
-    'background',
-    'border',
-    'className',
-    'color',
-    'contentRole',
-    'customClassName',
-    'dimensions',
-    'filter',
-    'html',
-    'inserter',
-    'interactivity',
-    'js',
-    'layout',
-    'lightbox',
-    'listView',
-    'lock',
-    'locking',
-    'multiple',
-    'position',
-    'renaming',
-    'reusable',
-    'shadow',
-    'spacing',
-    'splitting',
-    'typography',
-    'visibility',
-];
-export const TYPOGRAPHY_SUPPORT_KEYS = [
-    'fontFamily',
-    'fontSize',
-    'fontStyle',
-    'fontWeight',
-    'letterSpacing',
-    'lineHeight',
-    'dropCap',
-    'textAlign',
-    'textColumns',
-    'textDecoration',
-    'textTransform',
-    'writingMode',
-];
-export const SPACING_SUPPORT_KEYS = [
-    'blockGap',
-    'margin',
-    'padding',
-];
+import { handleDefineSupportsDiagnostics } from "./supports-diagnostics.js";
+import { BLOCK_SUPPORT_FEATURES, SPACING_SUPPORT_KEYS, TYPOGRAPHY_SUPPORT_KEYS, } from "./supports-features.js";
+import { collectBlockSupportsCompatibilityFeatures, createBlockSupportsCompatibilityManifest, } from "./supports-manifest.js";
+import { resolveDefineSupportsSettings, splitDefineSupportsInput, } from "./supports-settings.js";
+export { BLOCK_SUPPORT_FEATURES, SPACING_SUPPORT_KEYS, TYPOGRAPHY_SUPPORT_KEYS, collectBlockSupportsCompatibilityFeatures, createBlockSupportsCompatibilityManifest, };
+import { isObjectRecord } from "./shared/object-utils.js";
 export const DEFINED_BLOCK_SUPPORTS_METADATA = Symbol.for("@wp-typia/block-types/defined-supports");
-const KNOWN_BLOCK_SUPPORT_FEATURES = new Set(BLOCK_SUPPORT_FEATURES);
-const DEFINE_SUPPORTS_INLINE_OPTION_KEYS = new Set([
-    "allowUnknownFutureKeys",
-    "logger",
-    "minVersion",
-    "minWordPress",
-    "onDiagnostic",
-    "strict",
-]);
-const COLOR_COMPATIBILITY_SUPPORT_KEYS = [
-    "button",
-    "enableContrastChecker",
-    "heading",
-];
-const TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS = [
-    "fontSize",
-    "letterSpacing",
-    "lineHeight",
-    "textAlign",
-    "textDecoration",
-    "textTransform",
-];
-const TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS = [
-    "allowedBlocks",
-    "background",
-    "contentRole",
-    "dimensions",
-    "listView",
-    "position",
-    "renaming",
-    "shadow",
-    "visibility",
-];
-function isEnabledSupportValue(value) {
-    return value !== false && value !== null && value !== undefined;
-}
-function isEnabledTopLevelSupportValue(value) {
-    if (!isObjectRecord(value)) {
-        return isNonArrayObject(value) ? false : isEnabledSupportValue(value);
-    }
-    return Object.entries(value).some(([key, nestedValue]) => !key.startsWith("__experimental") &&
-        isEnabledSupportValue(nestedValue));
-}
-function hasEnabledNestedSupport(section, key) {
-    return isObjectRecord(section) && isEnabledSupportValue(section[key]);
-}
-function addCompatibilityFeature(features, seen, feature) {
-    const id = `blockSupports.${feature}`;
-    if (seen.has(id)) {
-        return;
-    }
-    seen.add(id);
-    features.push({
-        area: "blockSupports",
-        feature,
-    });
-}
-export function collectBlockSupportsCompatibilityFeatures(supports) {
-    const features = [];
-    const seen = new Set();
-    for (const key of TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS) {
-        if (isEnabledTopLevelSupportValue(supports[key])) {
-            addCompatibilityFeature(features, seen, key);
-        }
-    }
-    const spacing = supports.spacing;
-    for (const key of SPACING_SUPPORT_KEYS) {
-        if (hasEnabledNestedSupport(spacing, key)) {
-            addCompatibilityFeature(features, seen, `spacing.${key}`);
-        }
-    }
-    const typography = supports.typography;
-    for (const key of TYPOGRAPHY_COMPATIBILITY_SUPPORT_KEYS) {
-        if (hasEnabledNestedSupport(typography, key)) {
-            addCompatibilityFeature(features, seen, `typography.${key}`);
-        }
-    }
-    const color = supports.color;
-    if (isObjectRecord(color)) {
-        for (const key of COLOR_COMPATIBILITY_SUPPORT_KEYS) {
-            if (isEnabledSupportValue(color[key])) {
-                addCompatibilityFeature(features, seen, `color.${key}`);
-            }
-        }
-    }
-    if (hasEnabledNestedSupport(supports.filter, "duotone")) {
-        addCompatibilityFeature(features, seen, "filter.duotone");
-    }
-    for (const key of Object.keys(supports)) {
-        if (!KNOWN_BLOCK_SUPPORT_FEATURES.has(key) &&
-            !DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key) &&
-            isEnabledTopLevelSupportValue(supports[key])) {
-            addCompatibilityFeature(features, seen, key);
-        }
-    }
-    return features;
-}
-function splitDefineSupportsInput(supports) {
-    const normalizedSupports = {};
-    const inlineOptions = {};
-    for (const [key, value] of Object.entries(supports)) {
-        if (DEFINE_SUPPORTS_INLINE_OPTION_KEYS.has(key)) {
-            Object.assign(inlineOptions, { [key]: value });
-            continue;
-        }
-        normalizedSupports[key] = value;
-    }
-    return {
-        inlineOptions,
-        supports: normalizedSupports,
-    };
-}
-function resolveDefineSupportsSettings(inlineOptions, options) {
-    const settings = {};
-    const allowUnknownFutureKeys = options.allowUnknownFutureKeys ?? inlineOptions.allowUnknownFutureKeys;
-    const minVersion = options.minVersion ??
-        options.minWordPress ??
-        inlineOptions.minVersion ??
-        inlineOptions.minWordPress;
-    const strict = options.strict ?? inlineOptions.strict;
-    if (allowUnknownFutureKeys !== undefined) {
-        Object.assign(settings, { allowUnknownFutureKeys });
-    }
-    if (minVersion !== undefined) {
-        Object.assign(settings, { minVersion });
-    }
-    if (strict !== undefined) {
-        Object.assign(settings, { strict });
-    }
-    return settings;
-}
-export function createBlockSupportsCompatibilityManifest(supports, settings = {}) {
-    const compatibilitySettings = resolveDefineSupportsSettings({}, settings);
-    return createWordPressBlockApiCompatibilityManifest(collectBlockSupportsCompatibilityFeatures(supports), compatibilitySettings);
-}
-function handleDefineSupportsDiagnostics(diagnostics, onDiagnostic, logger) {
-    handleDiagnostics(diagnostics, onDiagnostic, {
-        failureHeading: "WordPress block supports compatibility check failed:",
-        logger,
-    });
-}
 export function getDefinedSupportsCompatibilityManifest(supports) {
     return isObjectRecord(supports)
         ? supports[DEFINED_BLOCK_SUPPORTS_METADATA]?.manifest

package/dist/blocks/variations-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { BlockAttributes } from "./registration.js";
+import type { BlockVariationAuthoringDiagnostic, BlockVariationDefinition, BlockVariationDiagnostic, BlockVariationRegistrationEntry, DefineVariationOptions } from "./variations.js";
+import type { ResolvedDefineVariationSettings } from "./variations-settings.js";
+export declare function createVariationDiagnostics<TAttributes extends BlockAttributes>(blockName: string, variation: BlockVariationDefinition<TAttributes>, options: ResolvedDefineVariationSettings["diagnostics"]): readonly BlockVariationAuthoringDiagnostic[];
+export declare function createCollectionDiagnostics(entries: readonly BlockVariationRegistrationEntry[], strict: boolean): readonly BlockVariationAuthoringDiagnostic[];
+export declare function handleVariationDiagnostics(diagnostics: readonly BlockVariationDiagnostic[], onDiagnostic: DefineVariationOptions["onDiagnostic"], logger: DefineVariationOptions["logger"]): void;

package/dist/blocks/variations-diagnostics.js

@@ -0,0 +1,123 @@
+import { getDiagnosticSeverity, handleDiagnostics } from "./shared/diagnostics.js";
+import { isObjectRecord } from "./shared/object-utils.js";
+const STABLE_VARIATION_MARKER_ATTRIBUTES = [
+    "className",
+    "namespace",
+    "wpTypiaVariation",
+];
+function hasStableMarkerAttribute(attributes) {
+    if (!isObjectRecord(attributes)) {
+        return false;
+    }
+    return STABLE_VARIATION_MARKER_ATTRIBUTES.some((key) => key in attributes);
+}
+function stringifyActiveMarkerValue(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function createActiveMarker(entry) {
+    const isActive = entry.variation.isActive;
+    if (!Array.isArray(isActive) || isActive.length === 0) {
+        return undefined;
+    }
+    const attributes = isObjectRecord(entry.variation.attributes)
+        ? entry.variation.attributes
+        : {};
+    return [...isActive]
+        .sort()
+        .map((attribute) => {
+        const value = attribute in attributes ? attributes[attribute] : "";
+        return `${attribute}=${stringifyActiveMarkerValue(value)}`;
+    })
+        .join("|");
+}
+export function createVariationDiagnostics(blockName, variation, options) {
+    const diagnostics = [];
+    const variationName = variation.name;
+    const attributes = variation.attributes;
+    const isActive = variation.isActive;
+    if (options.requireIsActive &&
+        !options.allowMissingIsActive &&
+        !variation.isDefault &&
+        isActive === undefined) {
+        diagnostics.push({
+            blockName,
+            code: "missing-is-active",
+            message: `Block variation "${variationName}" for "${blockName}" does not declare isActive; add an active discriminator or set allowMissingIsActive.`,
+            severity: "warning",
+            variationName,
+        });
+    }
+    if (options.requireIsActive &&
+        !options.allowMissingIsActive &&
+        !variation.isDefault &&
+        isActive === undefined &&
+        !hasStableMarkerAttribute(attributes)) {
+        diagnostics.push({
+            blockName,
+            code: "missing-stable-marker",
+            message: `Block variation "${variationName}" for "${blockName}" has no stable marker attribute such as className, namespace, or wpTypiaVariation.`,
+            severity: "warning",
+            variationName,
+        });
+    }
+    if (Array.isArray(isActive)) {
+        for (const attribute of isActive) {
+            if (!isObjectRecord(attributes) || !(attribute in attributes)) {
+                diagnostics.push({
+                    attribute,
+                    blockName,
+                    code: "unknown-is-active-attribute",
+                    message: `Block variation "${variationName}" for "${blockName}" uses isActive attribute "${attribute}" that is not present in its attributes.`,
+                    severity: "warning",
+                    variationName,
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+export function createCollectionDiagnostics(entries, strict) {
+    const diagnostics = [];
+    const seenNames = new Map();
+    const seenActiveMarkers = new Map();
+    for (const entry of entries) {
+        const nameKey = `${entry.blockName}:${entry.variation.name}`;
+        const activeMarker = createActiveMarker(entry);
+        if (seenNames.has(nameKey)) {
+            diagnostics.push({
+                blockName: entry.blockName,
+                code: "duplicate-variation-name",
+                message: `Duplicate block variation name "${entry.variation.name}" for "${entry.blockName}".`,
+                severity: getDiagnosticSeverity(strict),
+                variationName: entry.variation.name,
+            });
+        }
+        seenNames.set(nameKey, entry);
+        if (activeMarker && activeMarker.length > 0) {
+            const markerKey = `${entry.blockName}:${activeMarker}`;
+            const existing = seenActiveMarkers.get(markerKey);
+            if (existing) {
+                diagnostics.push({
+                    blockName: entry.blockName,
+                    code: "duplicate-active-marker",
+                    message: `Block variations "${existing.variation.name}" and "${entry.variation.name}" for "${entry.blockName}" share the same isActive discriminator "${activeMarker}".`,
+                    severity: "warning",
+                    variationName: entry.variation.name,
+                });
+            }
+            seenActiveMarkers.set(markerKey, entry);
+        }
+    }
+    return diagnostics;
+}
+export function handleVariationDiagnostics(diagnostics, onDiagnostic, logger) {
+    handleDiagnostics(diagnostics, onDiagnostic, {
+        failureHeading: "WordPress block variation check failed:",
+        logger,
+    });
+}

package/dist/blocks/variations-manifest.d.ts

@@ -0,0 +1,5 @@
+import { type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings } from "./compatibility.js";
+import type { DefineVariationOptions } from "./variations.js";
+export declare function collectBlockVariationCompatibilityFeatures(): readonly WordPressBlockApiCompatibilityFeature[];
+export declare function createBlockVariationCompatibilityManifest(settings?: DefineVariationOptions): WordPressBlockApiCompatibilityManifest;
+export declare function createBlockVariationCompatibilityManifestFromSettings(settings: WordPressCompatibilitySettings): WordPressBlockApiCompatibilityManifest;

package/dist/blocks/variations-manifest.js

@@ -0,0 +1,17 @@
+import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.js";
+import { resolveDefineVariationSettings } from "./variations-settings.js";
+export function collectBlockVariationCompatibilityFeatures() {
+    return [
+        {
+            area: "blockVariations",
+            feature: "editorRegistration",
+        },
+    ];
+}
+export function createBlockVariationCompatibilityManifest(settings = {}) {
+    const resolved = resolveDefineVariationSettings({}, settings);
+    return createBlockVariationCompatibilityManifestFromSettings(resolved.compatibility);
+}
+export function createBlockVariationCompatibilityManifestFromSettings(settings) {
+    return createWordPressBlockApiCompatibilityManifest(collectBlockVariationCompatibilityFeatures(), settings);
+}

package/dist/blocks/variations-settings.d.ts

@@ -0,0 +1,18 @@
+import type { WordPressCompatibilitySettings } from "./compatibility.js";
+import type { BlockAttributes } from "./registration.js";
+import type { BlockVariationDefinition, DefineVariationInlineOptions, DefineVariationOptions, StripDefineVariationOptions } from "./variations.js";
+export interface ResolvedDefineVariationSettings {
+    readonly compatibility: WordPressCompatibilitySettings;
+    readonly diagnostics: {
+        readonly allowMissingIsActive: boolean;
+        readonly requireIsActive: boolean;
+        readonly strict: boolean;
+    };
+    readonly logger: DefineVariationOptions["logger"];
+    readonly onDiagnostic: DefineVariationOptions["onDiagnostic"];
+}
+export declare function splitDefineVariationInput<TAttributes extends BlockAttributes, TVariation extends BlockVariationDefinition<TAttributes> & DefineVariationInlineOptions>(variation: TVariation): {
+    inlineOptions: DefineVariationInlineOptions;
+    variation: StripDefineVariationOptions<TVariation> & BlockVariationDefinition<TAttributes>;
+};
+export declare function resolveDefineVariationSettings(inlineOptions: DefineVariationInlineOptions, options: DefineVariationOptions): ResolvedDefineVariationSettings;