@wp-typia/block-runtime 0.2.3 → 0.3.0

package/README.md

@@ -1,22 +1,19 @@
 # `@wp-typia/block-runtime`
 
-Prototype block runtime helpers for `wp-typia` generated projects.
+Generated-project runtime and metadata sync helpers for `wp-typia`.
 
-This package is the current graduation path for the stable generated-project
-runtime helpers that still live canonically under `@wp-typia/create`.
-
-It currently re-exports the block runtime helper surface for:
+This is the supported generated-project package boundary for:
 
 - manifest-driven defaults
 - editor model generation
 - manifest-driven inspector helpers
 - validation-aware attribute updates
+- TypeScript-to-metadata sync
+- manifest-first REST/OpenAPI/client codegen
 
 It does not include:
 
 - scaffold or CLI internals
-- REST/OpenAPI metadata generation
-- schema generation helpers
 - migration tooling
 
 Typical usage:
@@ -25,8 +22,12 @@ Typical usage:
 import { createEditorModel } from "@wp-typia/block-runtime/editor";
 import { InspectorFromManifest, useEditorFields } from "@wp-typia/block-runtime/inspector";
 import { createNestedAttributeUpdater } from "@wp-typia/block-runtime/validation";
+import { runSyncBlockMetadata } from "@wp-typia/block-runtime/metadata-core";
 ```
 
-`@wp-typia/create` remains the canonical generated-project import surface
-through v1. This package exists to validate the long-term package boundary and
-migration path without changing scaffolds yet.
+`@wp-typia/create` remains the CLI/scaffolding package.
+
+`@wp-typia/create/metadata-core` and `@wp-typia/create/runtime/*` remain
+available as backward-compatible facades, but newly generated projects should
+prefer `@wp-typia/block-runtime/*` and
+`@wp-typia/block-runtime/metadata-core`.

package/dist/blocks.d.ts

@@ -0,0 +1,180 @@
+import type { BlockSupports as WordPressBlockSupports } from "@wordpress/blocks";
+type EntryMap = Record<string, string>;
+type ScaffoldLayoutType = "flow" | "constrained" | "flex" | "grid";
+type ScaffoldFlexWrap = "wrap" | "nowrap";
+type ScaffoldOrientation = "horizontal" | "vertical";
+type ScaffoldJustifyContent = "left" | "center" | "right" | "space-between" | "stretch";
+type ScaffoldBlockAlignment = "left" | "center" | "right" | "wide" | "full";
+type ScaffoldBlockVerticalAlignment = "top" | "center" | "bottom";
+type ScaffoldSpacingAxis = "horizontal" | "vertical";
+type ScaffoldSpacingDimension = "top" | "right" | "bottom" | "left" | ScaffoldSpacingAxis;
+type ScaffoldTypographySupportKey = "fontFamily" | "fontSize" | "fontStyle" | "fontWeight" | "letterSpacing" | "lineHeight" | "textAlign" | "textColumns" | "textDecoration" | "textTransform" | "writingMode";
+type ScaffoldSpacingSupportKey = "blockGap" | "margin" | "padding";
+type ScaffoldTypographyTextAlignment = "left" | "center" | "right";
+export interface TypiaWebpackArtifactEntry {
+    inputPath: string;
+    outputPath: string;
+}
+export interface TypiaWebpackConfigOptions {
+    defaultConfig: unknown;
+    fs: {
+        existsSync(path: string): boolean;
+        readFileSync(path: string, encoding?: string): string | Buffer;
+        writeFileSync(path: string, data: string): void;
+    };
+    getArtifactEntries: () => TypiaWebpackArtifactEntry[];
+    getEditorEntries?: () => EntryMap;
+    getOptionalModuleEntries?: () => EntryMap;
+    importTypiaWebpackPlugin: () => Promise<{
+        default: () => unknown;
+    }>;
+    isScriptModuleAsset?: (assetName: string) => boolean;
+    moduleEntriesMode?: "merge" | "replace";
+    nonModuleEntriesMode?: "merge" | "replace";
+    path: {
+        join(...paths: string[]): string;
+    };
+}
+type OverrideProperties<TBase, TOverride> = Omit<TBase, keyof TOverride> & TOverride;
+type ScaffoldSupportDefaultControls<TFeature extends string> = Readonly<Partial<Record<TFeature, boolean>> & Record<string, boolean | undefined>>;
+interface ScaffoldBlockBorderSupport {
+    readonly color?: boolean;
+    readonly radius?: boolean;
+    readonly style?: boolean;
+    readonly width?: boolean;
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<"color" | "radius" | "style" | "width">;
+}
+interface ScaffoldBlockColorSupport {
+    readonly background?: boolean;
+    readonly button?: boolean;
+    readonly enableContrastChecker?: boolean;
+    readonly gradients?: boolean;
+    readonly heading?: boolean;
+    readonly link?: boolean;
+    readonly text?: boolean;
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<"background" | "gradients" | "link" | "text">;
+}
+interface ScaffoldBlockDimensionsSupport {
+    readonly aspectRatio?: boolean;
+    readonly height?: boolean;
+    readonly minHeight?: boolean;
+    readonly width?: boolean;
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<"aspectRatio" | "height" | "minHeight" | "width">;
+}
+interface ScaffoldBlockFilterSupport {
+    readonly duotone?: boolean;
+}
+interface ScaffoldBlockInteractivitySupport {
+    readonly clientNavigation?: boolean;
+    readonly interactive?: boolean;
+}
+interface ScaffoldBlockLayoutDefault {
+    readonly columnCount?: number;
+    readonly contentSize?: string;
+    readonly allowInheriting?: boolean;
+    readonly allowSizingOnChildren?: boolean;
+    readonly flexWrap?: ScaffoldFlexWrap;
+    readonly justifyContent?: ScaffoldJustifyContent;
+    readonly minimumColumnWidth?: string;
+    readonly orientation?: ScaffoldOrientation;
+    readonly type?: ScaffoldLayoutType;
+    readonly verticalAlignment?: ScaffoldBlockVerticalAlignment;
+    readonly wideSize?: string;
+}
+interface ScaffoldBlockLayoutSupport {
+    readonly allowCustomContentAndWideSize?: boolean;
+    readonly allowEditing?: boolean;
+    readonly allowInheriting?: boolean;
+    readonly allowJustification?: boolean;
+    readonly allowOrientation?: boolean;
+    readonly allowSizingOnChildren?: boolean;
+    readonly allowSwitching?: boolean;
+    readonly allowVerticalAlignment?: boolean;
+    readonly allowWrap?: boolean;
+    readonly default?: ScaffoldBlockLayoutDefault;
+}
+interface ScaffoldBlockLightboxSupport {
+    readonly allowEditing?: boolean;
+    readonly enabled?: boolean;
+}
+interface ScaffoldBlockPositionSupport {
+    readonly fixed?: boolean;
+    readonly sticky?: boolean;
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<"fixed" | "sticky">;
+}
+interface ScaffoldBlockShadowSupport {
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<"shadow">;
+}
+interface ScaffoldBlockSpacingSupport {
+    readonly blockGap?: boolean | readonly ScaffoldSpacingAxis[];
+    readonly margin?: boolean | readonly ScaffoldSpacingDimension[];
+    readonly padding?: boolean | readonly ScaffoldSpacingDimension[];
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<ScaffoldSpacingSupportKey>;
+}
+interface ScaffoldBlockTypographySupport {
+    readonly fontFamily?: boolean;
+    readonly fontSize?: boolean;
+    readonly fontStyle?: boolean;
+    readonly fontWeight?: boolean;
+    readonly letterSpacing?: boolean;
+    readonly lineHeight?: boolean;
+    readonly textAlign?: boolean | readonly ScaffoldTypographyTextAlignment[];
+    readonly textColumns?: boolean;
+    readonly textDecoration?: boolean;
+    readonly textTransform?: boolean;
+    readonly writingMode?: boolean;
+    readonly __experimentalDefaultControls?: ScaffoldSupportDefaultControls<ScaffoldTypographySupportKey>;
+}
+type ScaffoldBlockSupportsOverride = {
+    readonly align?: boolean | readonly ScaffoldBlockAlignment[];
+    readonly alignWide?: boolean;
+    readonly anchor?: boolean;
+    readonly ariaLabel?: boolean;
+    readonly border?: boolean | ScaffoldBlockBorderSupport;
+    readonly className?: boolean;
+    readonly color?: boolean | ScaffoldBlockColorSupport;
+    readonly customClassName?: boolean;
+    readonly dimensions?: boolean | ScaffoldBlockDimensionsSupport;
+    readonly filter?: boolean | ScaffoldBlockFilterSupport;
+    readonly html?: boolean;
+    readonly inserter?: boolean;
+    readonly interactivity?: boolean | ScaffoldBlockInteractivitySupport;
+    readonly layout?: boolean | ScaffoldBlockLayoutSupport;
+    readonly lightbox?: boolean | ScaffoldBlockLightboxSupport;
+    readonly lock?: boolean;
+    readonly multiple?: boolean;
+    readonly position?: boolean | ScaffoldBlockPositionSupport;
+    readonly renaming?: boolean;
+    readonly reusable?: boolean;
+    readonly shadow?: boolean | ScaffoldBlockShadowSupport;
+    readonly spacing?: boolean | ScaffoldBlockSpacingSupport;
+    readonly typography?: boolean | ScaffoldBlockTypographySupport;
+};
+export type ScaffoldBlockSupports = OverrideProperties<WordPressBlockSupports, ScaffoldBlockSupportsOverride>;
+export interface ScaffoldBlockRegistrationSettings {
+    ancestor?: readonly string[];
+    attributes?: Record<string, unknown>;
+    category?: unknown;
+    description?: unknown;
+    example?: unknown;
+    icon?: unknown;
+    parent?: readonly string[];
+    supports?: ScaffoldBlockSupports;
+    title?: unknown;
+}
+export interface ScaffoldBlockMetadata extends ScaffoldBlockRegistrationSettings {
+    name: string;
+}
+export interface BuildScaffoldBlockRegistrationResult<TSettings extends object> {
+    name: string;
+    settings: TSettings;
+}
+export declare function buildScaffoldBlockRegistration<TSettings extends object>(metadata: ScaffoldBlockMetadata, overrides: Partial<TSettings> & Record<string, unknown>): BuildScaffoldBlockRegistrationResult<TSettings>;
+export declare function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset, moduleEntriesMode, nonModuleEntriesMode, path, }: TypiaWebpackConfigOptions): Promise<{
+    entry: () => Promise<Record<string, unknown>>;
+    plugins: unknown[];
+} | {
+    entry: () => Promise<Record<string, unknown>>;
+    plugins: unknown[];
+}[]>;
+export {};

package/dist/blocks.js

@@ -0,0 +1,108 @@
+function normalizeScriptModuleAssetSource(source) {
+    return String(source).replace(/'dependencies'\s*=>\s*array\([^)]*\)/, "'dependencies' => array()");
+}
+function normalizeEntryMap(entry) {
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+        return { ...entry };
+    }
+    return {};
+}
+function toWebpackConfigs(config) {
+    return Array.isArray(config) ? config : [config];
+}
+function isModuleConfig(config) {
+    return (typeof config === "object" &&
+        config !== null &&
+        config.output?.module === true);
+}
+function mergeEntries(existingEntries, nextEntries, mode) {
+    if (!nextEntries) {
+        return existingEntries;
+    }
+    return mode === "replace"
+        ? { ...nextEntries }
+        : {
+            ...existingEntries,
+            ...nextEntries,
+        };
+}
+export function buildScaffoldBlockRegistration(metadata, overrides) {
+    const name = metadata.name;
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error("Scaffold block metadata must include a string name.");
+    }
+    const { name: _ignoredName, ...metadataSettings } = metadata;
+    return {
+        name,
+        settings: {
+            ...metadataSettings,
+            ...overrides,
+        },
+    };
+}
+export async function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset = (assetName) => /(^|\/)(interactivity|view)\.asset\.php$/.test(assetName), moduleEntriesMode = "merge", nonModuleEntriesMode = "merge", path, }) {
+    const { default: UnpluginTypia } = await importTypiaWebpackPlugin();
+    const resolvedDefaultConfig = typeof defaultConfig === "function"
+        ? await defaultConfig()
+        : defaultConfig;
+    class TypiaArtifactAssetPlugin {
+        apply(compiler) {
+            compiler.hooks.thisCompilation.tap("TypiaArtifactAssetPlugin", (compilation) => {
+                compilation.hooks.processAssets.tap({
+                    name: "TypiaArtifactAssetPlugin",
+                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+                }, () => {
+                    const artifactEntries = getArtifactEntries();
+                    for (const entry of artifactEntries) {
+                        if (compilation.getAsset(entry.outputPath)) {
+                            continue;
+                        }
+                        compilation.emitAsset(entry.outputPath, new compiler.webpack.sources.RawSource(fs.readFileSync(entry.inputPath)));
+                    }
+                    for (const asset of compilation.getAssets()) {
+                        if (!isScriptModuleAsset(asset.name)) {
+                            continue;
+                        }
+                        compilation.updateAsset(asset.name, new compiler.webpack.sources.RawSource(normalizeScriptModuleAssetSource(asset.source.source())));
+                    }
+                });
+            });
+            compiler.hooks.afterEmit.tap("TypiaArtifactAssetPlugin", (compilation) => {
+                const outputPath = compilation.outputOptions.path;
+                if (!outputPath) {
+                    return;
+                }
+                for (const asset of compilation.getAssets()) {
+                    if (!isScriptModuleAsset(asset.name)) {
+                        continue;
+                    }
+                    const assetPath = path.join(outputPath, asset.name);
+                    if (!fs.existsSync(assetPath)) {
+                        continue;
+                    }
+                    fs.writeFileSync(assetPath, normalizeScriptModuleAssetSource(fs.readFileSync(assetPath, "utf8")));
+                }
+            });
+        }
+    }
+    const configs = toWebpackConfigs(resolvedDefaultConfig).map((config) => ({
+        ...config,
+        entry: async () => {
+            const existingEntries = normalizeEntryMap(typeof config.entry === "function"
+                ? await config.entry()
+                : config.entry);
+            const editorEntries = getEditorEntries?.();
+            const optionalModuleEntries = getOptionalModuleEntries?.();
+            if (isModuleConfig(config)) {
+                return mergeEntries(existingEntries, optionalModuleEntries, moduleEntriesMode);
+            }
+            return mergeEntries(existingEntries, editorEntries, nonModuleEntriesMode);
+        },
+        plugins: [
+            UnpluginTypia(),
+            ...(config.plugins ?? []),
+            new TypiaArtifactAssetPlugin(),
+        ],
+    }));
+    return configs.length === 1 ? configs[0] : configs;
+}

package/dist/defaults.d.ts

@@ -1 +1,25 @@
-export { applyTemplateDefaultsFromManifest, type ManifestDefaultAttribute, type ManifestDefaultsDocument, } from "@wp-typia/create/runtime/defaults";
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface ManifestDefaultAttribute {
+    typia: {
+        defaultValue: JsonValue | null;
+        hasDefault: boolean;
+    };
+    ts: {
+        items: ManifestDefaultAttribute | null;
+        kind: "string" | "number" | "boolean" | "array" | "object" | "union";
+        properties: Record<string, ManifestDefaultAttribute> | null;
+        required: boolean;
+        union: {
+            branches: Record<string, ManifestDefaultAttribute>;
+            discriminator: string;
+        } | null;
+    };
+}
+export interface ManifestDefaultsDocument {
+    attributes: Record<string, ManifestDefaultAttribute>;
+}
+export declare function applyTemplateDefaultsFromManifest<T extends object>(manifest: ManifestDefaultsDocument, value: Partial<T>): Partial<T>;
+export {};

package/dist/defaults.js

@@ -1 +1,73 @@
-export { applyTemplateDefaultsFromManifest, } from "@wp-typia/create/runtime/defaults";
+import { cloneJsonValue } from "./json-utils.js";
+function isListArray(value) {
+    return value.every((_, index) => index in value);
+}
+function deriveDefaultValue(attribute) {
+    if (attribute.typia.hasDefault) {
+        return cloneJsonValue(attribute.typia.defaultValue);
+    }
+    if (attribute.ts.kind !== "object" || !attribute.ts.properties) {
+        return undefined;
+    }
+    const objectValue = {};
+    for (const [name, child] of Object.entries(attribute.ts.properties)) {
+        const childDefault = deriveDefaultValue(child);
+        if (childDefault !== undefined) {
+            objectValue[name] = childDefault;
+        }
+    }
+    return Object.keys(objectValue).length > 0 ? objectValue : undefined;
+}
+function applyDefaultsForObject(value, schema) {
+    const result = { ...value };
+    for (const [name, attribute] of Object.entries(schema)) {
+        if (!(name in result)) {
+            const derivedDefault = deriveDefaultValue(attribute);
+            if (derivedDefault !== undefined) {
+                result[name] = derivedDefault;
+            }
+            continue;
+        }
+        result[name] = applyDefaultsForNode(result[name], attribute);
+    }
+    return result;
+}
+function applyDefaultsForUnion(value, attribute) {
+    const union = attribute.ts.union;
+    if (!union) {
+        return value;
+    }
+    const discriminator = union.discriminator;
+    const branchKey = value[discriminator];
+    if (typeof branchKey !== "string" || !(branchKey in union.branches)) {
+        return value;
+    }
+    return applyDefaultsForNode(value, union.branches[branchKey]);
+}
+function applyDefaultsForNode(value, attribute) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (attribute.ts.kind) {
+        case "object":
+            if (typeof value === "object" && !Array.isArray(value) && attribute.ts.properties) {
+                return applyDefaultsForObject(value, attribute.ts.properties);
+            }
+            return value;
+        case "array":
+            if (Array.isArray(value) && isListArray(value) && attribute.ts.items) {
+                return value.map((item) => applyDefaultsForNode(item, attribute.ts.items));
+            }
+            return value;
+        case "union":
+            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                return applyDefaultsForUnion(value, attribute);
+            }
+            return value;
+        default:
+            return value;
+    }
+}
+export function applyTemplateDefaultsFromManifest(manifest, value) {
+    return applyDefaultsForObject(value, manifest.attributes);
+}

package/dist/editor.d.ts

@@ -1 +1,33 @@
-export { createEditorModel, describeEditorField, formatEditorFieldLabel, type EditorControlKind, type EditorFieldDescriptor, type EditorFieldOption, type EditorModelOptions, type JsonValue, type ManifestAttribute, type ManifestConstraints, type ManifestDocument, type ManifestTsKind, } from "@wp-typia/create/runtime/editor";
+import type { JsonValue, ManifestAttribute, ManifestConstraints, ManifestDocument, ManifestTsKind } from "./migration-types.js";
+export type { JsonValue, ManifestAttribute, ManifestConstraints, ManifestDocument, ManifestTsKind, } from "./migration-types.js";
+export type EditorControlKind = "toggle" | "select" | "range" | "number" | "text" | "textarea" | "unsupported";
+export interface EditorFieldOption {
+    label: string;
+    value: string | number | boolean;
+}
+export interface EditorFieldDescriptor {
+    constraints: ManifestConstraints;
+    control: EditorControlKind;
+    defaultValue: JsonValue | null;
+    hasDefault: boolean;
+    key: string;
+    kind: ManifestTsKind;
+    label: string;
+    maximum: number | null;
+    minimum: number | null;
+    options: EditorFieldOption[];
+    path: string;
+    reason?: string;
+    required: boolean;
+    step: number | null;
+    supported: boolean;
+}
+export interface EditorModelOptions {
+    hidden?: string[];
+    labels?: Record<string, string>;
+    manual?: string[];
+    preferTextarea?: string[];
+}
+export declare function formatEditorFieldLabel(path: string): string;
+export declare function describeEditorField(path: string, attribute: ManifestAttribute, options?: EditorModelOptions): EditorFieldDescriptor;
+export declare function createEditorModel(manifest: ManifestDocument, options?: EditorModelOptions): EditorFieldDescriptor[];

package/dist/editor.js

@@ -1 +1,165 @@
-export { createEditorModel, describeEditorField, formatEditorFieldLabel, } from "@wp-typia/create/runtime/editor";
+const FORMATTED_STRING_MANUAL_FORMATS = new Set([
+    "date-time",
+    "email",
+    "ipv4",
+    "ipv6",
+    "uri",
+    "url",
+    "uuid",
+]);
+const INTEGER_TYPE_TAGS = new Set(["int32", "uint32", "uint64"]);
+const UPPERCASE_TOKENS = new Map([
+    ["api", "API"],
+    ["css", "CSS"],
+    ["id", "ID"],
+    ["uri", "URI"],
+    ["url", "URL"],
+    ["uuid", "UUID"],
+]);
+function isScalarOptionValue(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+function isNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isPathFlagged(path, candidates) {
+    return candidates.some((candidate) => path === candidate || path.startsWith(`${candidate}.`));
+}
+function getLabel(path, labels) {
+    return labels?.[path] ?? formatEditorFieldLabel(path);
+}
+function getOptions(attribute) {
+    if (!Array.isArray(attribute.wp.enum)) {
+        return [];
+    }
+    return attribute.wp.enum.filter(isScalarOptionValue).map((value) => ({
+        label: formatEditorFieldLabel(String(value)),
+        value,
+    }));
+}
+function getStep(constraints) {
+    if (isNumber(constraints.multipleOf)) {
+        return constraints.multipleOf;
+    }
+    if (typeof constraints.typeTag === "string" &&
+        INTEGER_TYPE_TAGS.has(constraints.typeTag)) {
+        return 1;
+    }
+    return null;
+}
+function getControlKind(path, attribute, options) {
+    if (isPathFlagged(path, options.manual ?? [])) {
+        return {
+            control: "unsupported",
+            reason: "This field is intentionally handled manually in the editor.",
+        };
+    }
+    switch (attribute.ts.kind) {
+        case "boolean":
+            return { control: "toggle" };
+        case "number":
+            if (isNumber(attribute.typia.constraints.minimum) &&
+                isNumber(attribute.typia.constraints.maximum)) {
+                return { control: "range" };
+            }
+            return { control: "number" };
+        case "string":
+            if (typeof attribute.typia.constraints.format === "string" &&
+                FORMATTED_STRING_MANUAL_FORMATS.has(attribute.typia.constraints.format)) {
+                return {
+                    control: "unsupported",
+                    reason: `Formatted ${attribute.typia.constraints.format} strings should keep manual editor wiring.`,
+                };
+            }
+            if (getOptions(attribute).length > 0) {
+                return { control: "select" };
+            }
+            if (isPathFlagged(path, options.preferTextarea ?? [])) {
+                return { control: "textarea" };
+            }
+            return { control: "text" };
+        case "array":
+            return {
+                control: "unsupported",
+                reason: "Array fields are not auto-rendered by the editor helper.",
+            };
+        case "object":
+            return {
+                control: "unsupported",
+                reason: "Object fields are flattened into individual leaf controls.",
+            };
+        case "union":
+            return {
+                control: "unsupported",
+                reason: "Union fields must keep manual editor wiring.",
+            };
+        default:
+            return {
+                control: "unsupported",
+                reason: "This field kind is not supported by the editor helper.",
+            };
+    }
+}
+export function formatEditorFieldLabel(path) {
+    return path
+        .split(".")
+        .flatMap((segment) => segment.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/))
+        .filter(Boolean)
+        .map((part) => {
+        const normalized = part.toLowerCase();
+        const upper = UPPERCASE_TOKENS.get(normalized);
+        return upper ?? normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    })
+        .join(" ");
+}
+export function describeEditorField(path, attribute, options = {}) {
+    const { control, reason } = getControlKind(path, attribute, options);
+    const pathSegments = path.split(".");
+    const key = pathSegments[pathSegments.length - 1] ?? path;
+    return {
+        constraints: attribute.typia.constraints,
+        control,
+        defaultValue: attribute.typia.defaultValue ?? null,
+        hasDefault: attribute.typia.hasDefault === true,
+        key,
+        kind: attribute.ts.kind,
+        label: getLabel(path, options.labels),
+        maximum: isNumber(attribute.typia.constraints.maximum)
+            ? attribute.typia.constraints.maximum
+            : null,
+        minimum: isNumber(attribute.typia.constraints.minimum)
+            ? attribute.typia.constraints.minimum
+            : null,
+        // Preserve the legacy `@wp-typia/create/runtime/editor` descriptor contract
+        // for compatibility shims: enum options are only exposed for select controls.
+        options: control === "select" ? getOptions(attribute) : [],
+        path,
+        reason,
+        required: attribute.ts.required === true,
+        step: getStep(attribute.typia.constraints),
+        supported: control !== "unsupported",
+    };
+}
+function collectEditorFields(path, attribute, options) {
+    if (isPathFlagged(path, options.hidden ?? [])) {
+        return [];
+    }
+    if (isPathFlagged(path, options.manual ?? [])) {
+        return [describeEditorField(path, attribute, options)];
+    }
+    if (attribute.ts.kind === "object" && attribute.ts.properties) {
+        const childFields = Object.entries(attribute.ts.properties).flatMap(([key, child]) => collectEditorFields(`${path}.${key}`, child, options));
+        return childFields.length > 0
+            ? childFields
+            : [describeEditorField(path, attribute, options)];
+    }
+    return [describeEditorField(path, attribute, options)];
+}
+export function createEditorModel(manifest, options = {}) {
+    if (!manifest.attributes) {
+        return [];
+    }
+    return Object.entries(manifest.attributes).flatMap(([path, attribute]) => collectEditorFields(path, attribute, options));
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./blocks.js";
 export * from "./defaults.js";
 export * from "./editor.js";
 export * from "./validation.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from "./blocks.js";
 export * from "./defaults.js";
 export * from "./editor.js";
 export * from "./validation.js";