@wp-typia/block-types 0.3.1 → 0.3.2

package/dist/blocks/variations-settings.js

@@ -0,0 +1,50 @@
+const DEFINE_VARIATION_INLINE_OPTION_KEYS = new Set([
+    "allowMissingIsActive",
+    "logger",
+    "minVersion",
+    "minWordPress",
+    "onDiagnostic",
+    "requireIsActive",
+    "strict",
+]);
+export function splitDefineVariationInput(variation) {
+    const inlineOptions = {};
+    const normalizedVariation = {};
+    for (const [key, value] of Object.entries(variation)) {
+        if (DEFINE_VARIATION_INLINE_OPTION_KEYS.has(key)) {
+            Object.assign(inlineOptions, { [key]: value });
+            continue;
+        }
+        normalizedVariation[key] = value;
+    }
+    return {
+        inlineOptions,
+        variation: normalizedVariation,
+    };
+}
+export function resolveDefineVariationSettings(inlineOptions, options) {
+    const compatibility = {};
+    const allowUnknownFutureKeys = options.allowUnknownFutureKeys;
+    const minVersion = options.minVersion ??
+        options.minWordPress ??
+        inlineOptions.minVersion ??
+        inlineOptions.minWordPress;
+    const strict = options.strict ?? inlineOptions.strict ?? true;
+    if (allowUnknownFutureKeys !== undefined) {
+        Object.assign(compatibility, { allowUnknownFutureKeys });
+    }
+    if (minVersion !== undefined) {
+        Object.assign(compatibility, { minVersion });
+    }
+    Object.assign(compatibility, { strict });
+    return {
+        compatibility,
+        diagnostics: {
+            allowMissingIsActive: options.allowMissingIsActive ?? inlineOptions.allowMissingIsActive ?? false,
+            requireIsActive: options.requireIsActive ?? inlineOptions.requireIsActive ?? true,
+            strict,
+        },
+        logger: options.logger ?? inlineOptions.logger,
+        onDiagnostic: options.onDiagnostic ?? inlineOptions.onDiagnostic,
+    };
+}

package/dist/blocks/variations.d.ts

@@ -1,6 +1,8 @@
 import type { BlockAttributes, BlockVariation, BlockVariationScope } from "./registration.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 { type DiagnosticLogger } from "./shared/diagnostics.js";
+import { collectBlockVariationCompatibilityFeatures, createBlockVariationCompatibilityManifest } from "./variations-manifest.js";
+export { collectBlockVariationCompatibilityFeatures, createBlockVariationCompatibilityManifest, };
 export type BlockVariationAttributeMap<TAttributes extends BlockAttributes = BlockAttributes> = Partial<TAttributes> & BlockAttributes;
 export type BlockVariationInnerBlockTemplate = readonly [
     name: string,
@@ -75,8 +77,6 @@ export interface CreateBlockVariationRegistrationSourceOptions {
     readonly functionName?: string;
     readonly importSource?: string;
 }
-export declare function collectBlockVariationCompatibilityFeatures(): readonly WordPressBlockApiCompatibilityFeature[];
-export declare function createBlockVariationCompatibilityManifest(settings?: DefineVariationOptions): WordPressBlockApiCompatibilityManifest;
 export declare function getDefinedVariationMetadata(variation: unknown): DefinedBlockVariationMetadata | undefined;
 export declare function getDefinedVariationBlockName(variation: unknown): string | undefined;
 export declare function getDefinedVariationCompatibilityManifest(variation: unknown): WordPressBlockApiCompatibilityManifest | undefined;

package/dist/blocks/variations.js

@@ -1,134 +1,11 @@
-import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.js";
-import { getDiagnosticSeverity, handleDiagnostics, } from "./shared/diagnostics.js";
 import { isObjectRecord } from "./shared/object-utils.js";
 import { normalizeStaticRegistrationValue } from "./shared/static-registration.js";
+import { createCollectionDiagnostics, createVariationDiagnostics, handleVariationDiagnostics, } from "./variations-diagnostics.js";
+import { collectBlockVariationCompatibilityFeatures, createBlockVariationCompatibilityManifest, createBlockVariationCompatibilityManifestFromSettings, } from "./variations-manifest.js";
+import { resolveDefineVariationSettings, splitDefineVariationInput, } from "./variations-settings.js";
+export { collectBlockVariationCompatibilityFeatures, createBlockVariationCompatibilityManifest, };
 export const DEFINED_BLOCK_VARIATION_METADATA = Symbol.for("@wp-typia/block-types/defined-variation");
 export const DEFINED_BLOCK_VARIATIONS_METADATA = Symbol.for("@wp-typia/block-types/defined-variations");
-const DEFINE_VARIATION_INLINE_OPTION_KEYS = new Set([
-    "allowMissingIsActive",
-    "logger",
-    "minVersion",
-    "minWordPress",
-    "onDiagnostic",
-    "requireIsActive",
-    "strict",
-]);
-const STABLE_VARIATION_MARKER_ATTRIBUTES = [
-    "className",
-    "namespace",
-    "wpTypiaVariation",
-];
-function splitDefineVariationInput(variation) {
-    const inlineOptions = {};
-    const normalizedVariation = {};
-    for (const [key, value] of Object.entries(variation)) {
-        if (DEFINE_VARIATION_INLINE_OPTION_KEYS.has(key)) {
-            Object.assign(inlineOptions, { [key]: value });
-            continue;
-        }
-        normalizedVariation[key] = value;
-    }
-    return {
-        inlineOptions,
-        variation: normalizedVariation,
-    };
-}
-function resolveDefineVariationSettings(inlineOptions, options) {
-    const compatibility = {};
-    const allowUnknownFutureKeys = options.allowUnknownFutureKeys;
-    const minVersion = options.minVersion ??
-        options.minWordPress ??
-        inlineOptions.minVersion ??
-        inlineOptions.minWordPress;
-    const strict = options.strict ?? inlineOptions.strict ?? true;
-    if (allowUnknownFutureKeys !== undefined) {
-        Object.assign(compatibility, { allowUnknownFutureKeys });
-    }
-    if (minVersion !== undefined) {
-        Object.assign(compatibility, { minVersion });
-    }
-    Object.assign(compatibility, { strict });
-    return {
-        compatibility,
-        diagnostics: {
-            allowMissingIsActive: options.allowMissingIsActive ?? inlineOptions.allowMissingIsActive ?? false,
-            requireIsActive: options.requireIsActive ?? inlineOptions.requireIsActive ?? true,
-            strict,
-        },
-        logger: options.logger ?? inlineOptions.logger,
-        onDiagnostic: options.onDiagnostic ?? inlineOptions.onDiagnostic,
-    };
-}
-export function collectBlockVariationCompatibilityFeatures() {
-    return [
-        {
-            area: "blockVariations",
-            feature: "editorRegistration",
-        },
-    ];
-}
-export function createBlockVariationCompatibilityManifest(settings = {}) {
-    const resolved = resolveDefineVariationSettings({}, settings);
-    return createWordPressBlockApiCompatibilityManifest(collectBlockVariationCompatibilityFeatures(), resolved.compatibility);
-}
-function hasStableMarkerAttribute(attributes) {
-    if (!isObjectRecord(attributes)) {
-        return false;
-    }
-    return STABLE_VARIATION_MARKER_ATTRIBUTES.some((key) => key in attributes);
-}
-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;
-}
-function handleVariationDiagnostics(diagnostics, onDiagnostic, logger) {
-    handleDiagnostics(diagnostics, onDiagnostic, {
-        failureHeading: "WordPress block variation check failed:",
-        logger,
-    });
-}
 export function getDefinedVariationMetadata(variation) {
     return isObjectRecord(variation)
         ? variation[DEFINED_BLOCK_VARIATION_METADATA]
@@ -148,7 +25,7 @@ export function getDefinedVariationsMetadata(variations) {
 export function defineVariation(blockName, variation, options = {}) {
     const { inlineOptions, variation: normalizedVariation } = splitDefineVariationInput(variation);
     const resolved = resolveDefineVariationSettings(inlineOptions, options);
-    const manifest = createWordPressBlockApiCompatibilityManifest(collectBlockVariationCompatibilityFeatures(), resolved.compatibility);
+    const manifest = createBlockVariationCompatibilityManifestFromSettings(resolved.compatibility);
     const diagnostics = [
         ...manifest.diagnostics,
         ...createVariationDiagnostics(blockName, normalizedVariation, resolved.diagnostics),
@@ -166,42 +43,6 @@ export function defineVariation(blockName, variation, options = {}) {
     });
     return normalizedVariation;
 }
-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 = Array.isArray(entry.variation.isActive)
-            ? entry.variation.isActive.join("|")
-            : undefined;
-        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 createBlockVariationRegistrationPlan(variations) {
     return variations.map((variation) => {
         const metadata = getDefinedVariationMetadata(variation);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/block-types",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Shared WordPress block semantic types derived from Gutenberg and unofficial declarations",
   "type": "module",
   "main": "dist/index.js",