@wp-typia/block-types 0.3.0 → 0.3.2

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;

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,5 +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,
@@ -20,6 +23,7 @@ export interface BlockVariationDefinition<TAttributes extends BlockAttributes =
 }
 export interface DefineVariationInlineOptions {
     readonly allowMissingIsActive?: boolean;
+    readonly logger?: DiagnosticLogger<BlockVariationDiagnostic>;
     readonly minVersion?: WordPressVersion;
     readonly minWordPress?: WordPressVersion;
     readonly onDiagnostic?: (diagnostic: BlockVariationDiagnostic) => void;
@@ -28,6 +32,7 @@ export interface DefineVariationInlineOptions {
 }
 export interface DefineVariationOptions extends WordPressCompatibilitySettings {
     readonly allowMissingIsActive?: boolean;
+    readonly logger?: DiagnosticLogger<BlockVariationDiagnostic>;
     readonly minWordPress?: WordPressVersion;
     readonly onDiagnostic?: (diagnostic: BlockVariationDiagnostic) => void;
     readonly requireIsActive?: boolean;
@@ -72,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,145 +1,11 @@
-import { createWordPressBlockApiCompatibilityManifest, } from "./compatibility.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",
-    "minVersion",
-    "minWordPress",
-    "onDiagnostic",
-    "requireIsActive",
-    "strict",
-]);
-const STABLE_VARIATION_MARKER_ATTRIBUTES = [
-    "className",
-    "namespace",
-    "wpTypiaVariation",
-];
-function isObjectRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-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,
-        },
-        onDiagnostic: options.onDiagnostic ?? inlineOptions.onDiagnostic,
-    };
-}
-function getDiagnosticSeverity(strict) {
-    return strict ? "error" : "warning";
-}
-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) {
-    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
-    if (errors.length > 0) {
-        throw new Error([
-            "WordPress block variation check failed:",
-            ...errors.map((diagnostic) => `- ${diagnostic.message}`),
-        ].join("\n"));
-    }
-    for (const diagnostic of diagnostics) {
-        if (onDiagnostic) {
-            onDiagnostic(diagnostic);
-            continue;
-        }
-        console.warn(`[wp-typia] ${diagnostic.message}`);
-    }
-}
 export function getDefinedVariationMetadata(variation) {
     return isObjectRecord(variation)
         ? variation[DEFINED_BLOCK_VARIATION_METADATA]
@@ -159,12 +25,12 @@ 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),
     ];
-    handleVariationDiagnostics(diagnostics, resolved.onDiagnostic);
+    handleVariationDiagnostics(diagnostics, resolved.onDiagnostic, resolved.logger);
     Object.defineProperty(normalizedVariation, DEFINED_BLOCK_VARIATION_METADATA, {
         configurable: false,
         enumerable: false,
@@ -177,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);
@@ -234,7 +64,7 @@ export function defineVariations(variations, options = {}) {
         ...variationDiagnostics,
         ...collectionDiagnostics,
     ];
-    handleVariationDiagnostics(collectionDiagnostics, options.onDiagnostic);
+    handleVariationDiagnostics(collectionDiagnostics, options.onDiagnostic, options.logger);
     const normalizedVariations = [...variations];
     Object.defineProperty(normalizedVariations, DEFINED_BLOCK_VARIATIONS_METADATA, {
         configurable: false,
@@ -247,41 +77,12 @@ export function defineVariations(variations, options = {}) {
     });
     return normalizedVariations;
 }
-function normalizeStaticRegistrationValue(value, path) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === null ||
-        typeof value === "boolean" ||
-        typeof value === "number" ||
-        typeof value === "string") {
-        return value;
-    }
-    if (typeof value === "function") {
-        throw new Error(`Cannot generate static variation registration code for function value at ${path}.`);
-    }
-    if (typeof value === "bigint" || typeof value === "symbol") {
-        throw new Error(`Cannot generate static variation registration code for ${typeof value} value at ${path}.`);
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry, index) => normalizeStaticRegistrationValue(entry, `${path}[${index}]`));
-    }
-    if (isObjectRecord(value)) {
-        const normalized = {};
-        for (const [key, nestedValue] of Object.entries(value)) {
-            const nextValue = normalizeStaticRegistrationValue(nestedValue, `${path}.${key}`);
-            if (nextValue !== undefined) {
-                normalized[key] = nextValue;
-            }
-        }
-        return normalized;
-    }
-    throw new Error(`Cannot generate static variation registration code for unsupported value at ${path}.`);
-}
 export function createStaticBlockVariationRegistrationSource(variations, options = {}) {
     const importSource = options.importSource ?? "@wordpress/blocks";
     const functionName = options.functionName ?? "registerWpTypiaBlockVariations";
-    const entries = createBlockVariationRegistrationPlan(variations).map((entry, index) => normalizeStaticRegistrationValue(entry, `variations[${index}]`));
+    const entries = createBlockVariationRegistrationPlan(variations).map((entry, index) => normalizeStaticRegistrationValue(entry, `variations[${index}]`, {
+        description: "variation",
+    }));
     const serializedEntries = JSON.stringify(entries, null, 2);
     return [
         `import { registerBlockVariation } from ${JSON.stringify(importSource)};`,

package/package.json

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