@wp-typia/block-types 0.3.0 → 0.3.1

package/dist/blocks/supports.d.ts

@@ -3,6 +3,7 @@ import type { BlockBorderSupportAttributes, BlockColorSupportAttributes, BlockDi
 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 DiagnosticLogger } from "./shared/diagnostics.js";
 /**
  * Derived from Gutenberg block support keys and commonly used block.json
  * support sections.
@@ -191,12 +192,14 @@ type HasNestedSupport<TSupports, TSection extends keyof BlockSupports, TKey exte
 type IfSupport<TCondition, TAttributes> = TCondition extends true ? TAttributes : {};
 export interface DefineSupportsInlineOptions {
     readonly allowUnknownFutureKeys?: boolean;
+    readonly logger?: DiagnosticLogger<WordPressBlockApiCompatibilityDiagnostic>;
     readonly minVersion?: WordPressVersion;
     readonly minWordPress?: WordPressVersion;
     readonly onDiagnostic?: (diagnostic: WordPressBlockApiCompatibilityDiagnostic) => void;
     readonly strict?: boolean;
 }
 export interface DefineSupportsOptions extends WordPressCompatibilitySettings {
+    readonly logger?: DiagnosticLogger<WordPressBlockApiCompatibilityDiagnostic>;
     readonly minWordPress?: WordPressVersion;
     readonly onDiagnostic?: (diagnostic: WordPressBlockApiCompatibilityDiagnostic) => void;
 }

package/dist/blocks/supports.js

@@ -1,4 +1,6 @@
 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',
@@ -56,6 +58,7 @@ export const DEFINED_BLOCK_SUPPORTS_METADATA = Symbol.for("@wp-typia/block-types
 const KNOWN_BLOCK_SUPPORT_FEATURES = new Set(BLOCK_SUPPORT_FEATURES);
 const DEFINE_SUPPORTS_INLINE_OPTION_KEYS = new Set([
     "allowUnknownFutureKeys",
+    "logger",
     "minVersion",
     "minWordPress",
     "onDiagnostic",
@@ -85,21 +88,18 @@ const TOP_LEVEL_COMPATIBILITY_SUPPORT_KEYS = [
     "shadow",
     "visibility",
 ];
-function isSupportObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function isEnabledSupportValue(value) {
     return value !== false && value !== null && value !== undefined;
 }
 function isEnabledTopLevelSupportValue(value) {
-    if (!isSupportObject(value)) {
-        return isEnabledSupportValue(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 isSupportObject(section) && isEnabledSupportValue(section[key]);
+    return isObjectRecord(section) && isEnabledSupportValue(section[key]);
 }
 function addCompatibilityFeature(features, seen, feature) {
     const id = `blockSupports.${feature}`;
@@ -133,7 +133,7 @@ export function collectBlockSupportsCompatibilityFeatures(supports) {
         }
     }
     const color = supports.color;
-    if (isSupportObject(color)) {
+    if (isObjectRecord(color)) {
         for (const key of COLOR_COMPATIBILITY_SUPPORT_KEYS) {
             if (isEnabledSupportValue(color[key])) {
                 addCompatibilityFeature(features, seen, `color.${key}`);
@@ -190,24 +190,14 @@ export function createBlockSupportsCompatibilityManifest(supports, settings = {}
     const compatibilitySettings = resolveDefineSupportsSettings({}, settings);
     return createWordPressBlockApiCompatibilityManifest(collectBlockSupportsCompatibilityFeatures(supports), compatibilitySettings);
 }
-function handleDefineSupportsDiagnostics(diagnostics, onDiagnostic) {
-    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
-    if (errors.length > 0) {
-        throw new Error([
-            "WordPress block supports compatibility 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}`);
-    }
+function handleDefineSupportsDiagnostics(diagnostics, onDiagnostic, logger) {
+    handleDiagnostics(diagnostics, onDiagnostic, {
+        failureHeading: "WordPress block supports compatibility check failed:",
+        logger,
+    });
 }
 export function getDefinedSupportsCompatibilityManifest(supports) {
-    return isSupportObject(supports)
+    return isObjectRecord(supports)
         ? supports[DEFINED_BLOCK_SUPPORTS_METADATA]?.manifest
         : undefined;
 }
@@ -215,7 +205,7 @@ export function defineSupports(supports, options = {}) {
     const { inlineOptions, supports: normalizedSupports } = splitDefineSupportsInput(supports);
     const settings = resolveDefineSupportsSettings(inlineOptions, options);
     const manifest = createBlockSupportsCompatibilityManifest(normalizedSupports, settings);
-    handleDefineSupportsDiagnostics(manifest.diagnostics, options.onDiagnostic ?? inlineOptions.onDiagnostic);
+    handleDefineSupportsDiagnostics(manifest.diagnostics, options.onDiagnostic ?? inlineOptions.onDiagnostic, options.logger ?? inlineOptions.logger);
     Object.defineProperty(normalizedSupports, DEFINED_BLOCK_SUPPORTS_METADATA, {
         configurable: false,
         enumerable: false,

package/dist/blocks/variations.d.ts

@@ -1,5 +1,6 @@
 import type { BlockAttributes, BlockVariation, BlockVariationScope } from "./registration.js";
 import { type WordPressBlockApiCompatibilityDiagnostic, type WordPressBlockApiCompatibilityFeature, type WordPressBlockApiCompatibilityManifest, type WordPressCompatibilitySettings, type WordPressVersion } from "./compatibility.js";
+import { type DiagnosticLogger } from "./shared/diagnostics.js";
 export type BlockVariationAttributeMap<TAttributes extends BlockAttributes = BlockAttributes> = Partial<TAttributes> & BlockAttributes;
 export type BlockVariationInnerBlockTemplate = readonly [
     name: string,
@@ -20,6 +21,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 +30,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;

package/dist/blocks/variations.js

@@ -1,8 +1,12 @@
 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";
 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",
@@ -14,9 +18,6 @@ const STABLE_VARIATION_MARKER_ATTRIBUTES = [
     "namespace",
     "wpTypiaVariation",
 ];
-function isObjectRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function splitDefineVariationInput(variation) {
     const inlineOptions = {};
     const normalizedVariation = {};
@@ -54,12 +55,10 @@ function resolveDefineVariationSettings(inlineOptions, options) {
             requireIsActive: options.requireIsActive ?? inlineOptions.requireIsActive ?? true,
             strict,
         },
+        logger: options.logger ?? inlineOptions.logger,
         onDiagnostic: options.onDiagnostic ?? inlineOptions.onDiagnostic,
     };
 }
-function getDiagnosticSeverity(strict) {
-    return strict ? "error" : "warning";
-}
 export function collectBlockVariationCompatibilityFeatures() {
     return [
         {
@@ -124,21 +123,11 @@ function createVariationDiagnostics(blockName, variation, options) {
     }
     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}`);
-    }
+function handleVariationDiagnostics(diagnostics, onDiagnostic, logger) {
+    handleDiagnostics(diagnostics, onDiagnostic, {
+        failureHeading: "WordPress block variation check failed:",
+        logger,
+    });
 }
 export function getDefinedVariationMetadata(variation) {
     return isObjectRecord(variation)
@@ -164,7 +153,7 @@ export function defineVariation(blockName, variation, options = {}) {
         ...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,
@@ -234,7 +223,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 +236,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.1",
   "description": "Shared WordPress block semantic types derived from Gutenberg and unofficial declarations",
   "type": "module",
   "main": "dist/index.js",