@wp-typia/project-tools 0.16.11 → 0.16.12

package/dist/runtime/built-in-block-artifacts.js

@@ -1,807 +1,8 @@
-const ALIGNMENT_VALUES = ["left", "center", "right"];
-const BASIC_ALIGNMENT_VALUES = ["left", "center", "right", "justify"];
-const INTERACTIVE_MODE_VALUES = ["click", "hover"];
-const ANIMATION_VALUES = ["none", "bounce", "pulse", "shake", "flip"];
-const DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER = "Add supporting details for this internal item.";
-function createConstraints(overrides = {}) {
-    return {
-        exclusiveMaximum: null,
-        exclusiveMinimum: null,
-        format: null,
-        maxLength: null,
-        maxItems: null,
-        maximum: null,
-        minLength: null,
-        minItems: null,
-        minimum: null,
-        multipleOf: null,
-        pattern: null,
-        typeTag: null,
-        ...overrides,
-    };
-}
-function createManifestAttribute({ constraints, defaultValue, enumValues = null, kind, required, selector = null, source = null, sourceType, }) {
-    const hasDefault = defaultValue !== undefined;
-    return {
-        ts: {
-            items: null,
-            kind,
-            properties: null,
-            required,
-            union: null,
-        },
-        typia: {
-            constraints: createConstraints(constraints),
-            defaultValue: hasDefault ? defaultValue : null,
-            hasDefault,
-        },
-        wp: {
-            defaultValue: hasDefault ? defaultValue : null,
-            enum: enumValues,
-            hasDefault,
-            ...(selector ? { selector } : {}),
-            ...(source ? { source } : {}),
-            type: sourceType,
-        },
-    };
-}
-function createBlockJsonAttribute({ defaultValue, enumValues = null, selector, source, type, }) {
-    const attribute = {
-        type,
-    };
-    if (defaultValue !== undefined) {
-        attribute.default = defaultValue;
-    }
-    if (enumValues !== null && enumValues.length > 0) {
-        attribute.enum = enumValues;
-    }
-    if (source) {
-        attribute.source = source;
-    }
-    if (selector) {
-        attribute.selector = selector;
-    }
-    return attribute;
-}
-function describe(...lines) {
-    return {
-        lines,
-    };
-}
-function defineAttribute({ blockJsonDefaultValue, constraints, defaultValue, description, enumValues = null, kind, manifestDefaultValue, name, optional, selector = null, source = null, sourceType, typeExpression, }) {
-    const resolvedBlockJsonDefaultValue = blockJsonDefaultValue !== undefined ? blockJsonDefaultValue : defaultValue;
-    const resolvedManifestDefaultValue = manifestDefaultValue !== undefined ? manifestDefaultValue : defaultValue;
-    return {
-        blockJson: {
-            defaultValue: resolvedBlockJsonDefaultValue,
-            enumValues,
-            ...(selector ? { selector } : {}),
-            ...(source ? { source } : {}),
-            type: sourceType,
-        },
-        description,
-        manifest: {
-            constraints,
-            defaultValue: resolvedManifestDefaultValue,
-            enumValues,
-            kind,
-            required: !optional,
-            selector,
-            source,
-            sourceType,
-        },
-        name,
-        optional,
-        typeExpression,
-    };
-}
-function defineStringAttribute(spec) {
-    return defineAttribute({
-        ...spec,
-        kind: "string",
-        sourceType: "string",
-    });
-}
-function defineBooleanAttribute(spec) {
-    return defineAttribute({
-        ...spec,
-        kind: "boolean",
-        sourceType: "boolean",
-    });
-}
-function defineNumberAttribute(spec) {
-    return defineAttribute({
-        ...spec,
-        kind: "number",
-        sourceType: "number",
-    });
-}
-function resolveBuiltInAttributeValue(value, context) {
-    if (typeof value === "function") {
-        return value(context);
-    }
-    return value;
-}
-function buildAttributesFromSpecs(specs, context) {
-    return specs.map((spec) => {
-        const resolvedSpec = {
-            blockJsonDefaultValue: resolveBuiltInAttributeValue(spec.blockJsonDefaultValue, context),
-            constraints: resolveBuiltInAttributeValue(spec.constraints, context),
-            defaultValue: resolveBuiltInAttributeValue(spec.defaultValue, context),
-            description: resolveBuiltInAttributeValue(spec.description, context),
-            enumValues: resolveBuiltInAttributeValue(spec.enumValues, context),
-            manifestDefaultValue: resolveBuiltInAttributeValue(spec.manifestDefaultValue, context),
-            name: spec.name,
-            optional: spec.optional,
-            selector: resolveBuiltInAttributeValue(spec.selector, context),
-            source: resolveBuiltInAttributeValue(spec.source, context),
-            typeExpression: resolveBuiltInAttributeValue(spec.typeExpression, context) ?? "unknown",
-        };
-        if (spec.attributeType === "boolean") {
-            return defineBooleanAttribute(resolvedSpec);
-        }
-        if (spec.attributeType === "number") {
-            return defineNumberAttribute(resolvedSpec);
-        }
-        return defineStringAttribute(resolvedSpec);
-    });
-}
-function buildManifestDocument(sourceType, attributes) {
-    return {
-        attributes: Object.fromEntries(attributes.map((attribute) => [
-            attribute.name,
-            createManifestAttribute(attribute.manifest),
-        ])),
-        manifestVersion: 2,
-        sourceType,
-    };
-}
-function buildBlockJsonAttributes(attributes) {
-    return Object.fromEntries(attributes.map((attribute) => [
-        attribute.name,
-        createBlockJsonAttribute(attribute.blockJson),
-    ]));
-}
-function quote(value) {
-    return JSON.stringify(value);
-}
-function emitDocComment(description, indent = "") {
-    if (!description) {
-        return [];
-    }
-    return [
-        `${indent}/**`,
-        ...description.lines.map((line) => line.length === 0 ? `${indent} *` : `${indent} * ${line}`),
-        `${indent} */`,
-    ];
-}
-function emitInterface(definition) {
-    const lines = [
-        ...emitDocComment(definition.description),
-        `export interface ${definition.name} {`,
-    ];
-    for (const member of definition.members) {
-        lines.push(...emitDocComment(member.description, "\t"));
-        lines.push(`\t${member.name}${member.optional ? "?" : ""}: ${member.typeExpression};`);
-    }
-    lines.push("}");
-    return lines;
-}
-function emitTypesModule({ preambleLines, interfaces, typeAliases, }) {
-    const sections = [];
-    if (preambleLines.length > 0) {
-        sections.push(preambleLines.join("\n"));
-    }
-    for (const definition of interfaces) {
-        sections.push(emitInterface(definition).join("\n"));
-    }
-    if (typeAliases.length > 0) {
-        sections.push(typeAliases
-            .map((alias) => `export type ${alias.name} = ${alias.value};`)
-            .join("\n"));
-    }
-    return `${sections.join("\n\n")}\n`;
-}
+import { buildBasicAttributes, buildBlockJsonAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildManifestDocument, buildPersistenceAttributes, DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, } from "./built-in-block-artifact-documents.js";
+import { buildBasicTypesSource, buildCompoundChildTypesSource, buildCompoundTypesSource, buildInteractivityTypesSource, buildPersistenceTypesSource, } from "./built-in-block-artifact-types.js";
 function stringifyBlockJsonDocument(document) {
     return `${JSON.stringify(document, null, "\t")}\n`;
 }
-const BASIC_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 1000,
-        },
-        defaultValue: "",
-        description: describe("Main block content"),
-        name: "content",
-        optional: false,
-        typeExpression: 'string & tags.MaxLength<1000> & tags.Default<"">',
-    },
-    {
-        attributeType: "string",
-        defaultValue: "left",
-        description: describe("Alignment"),
-        enumValues: [...BASIC_ALIGNMENT_VALUES],
-        name: "alignment",
-        optional: true,
-        typeExpression: 'TextAlignment & tags.Default<"left">',
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        description: describe("Visibility toggle"),
-        name: "isVisible",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 100,
-        },
-        defaultValue: "",
-        description: describe("Custom CSS class"),
-        name: "className",
-        optional: true,
-        typeExpression: 'string & tags.MaxLength<100> & tags.Default<"">',
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            format: "uuid",
-        },
-        description: describe("Generated runtime ID"),
-        name: "id",
-        optional: true,
-        typeExpression: 'string & tags.Format<"uuid">',
-    },
-    {
-        attributeType: "number",
-        constraints: {
-            typeTag: "uint32",
-        },
-        defaultValue: 1,
-        description: describe("Block version for migrations"),
-        name: "schemaVersion",
-        optional: true,
-        typeExpression: 'number & tags.Type<"uint32"> & tags.Default<1>',
-    },
-];
-const INTERACTIVITY_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 1000,
-        },
-        defaultValue: "",
-        name: "content",
-        optional: false,
-        selector: (variables) => `.${variables.cssClassName}__content`,
-        source: "html",
-        typeExpression: 'string & tags.MaxLength<1000> & tags.Default<"">',
-    },
-    {
-        attributeType: "string",
-        defaultValue: "left",
-        enumValues: [...ALIGNMENT_VALUES],
-        name: "alignment",
-        optional: true,
-        typeExpression: 'TextAlignment & tags.Default<"left">',
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "isVisible",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "string",
-        defaultValue: "click",
-        enumValues: [...INTERACTIVE_MODE_VALUES],
-        name: "interactiveMode",
-        optional: true,
-        typeExpression: '("click" | "hover") & tags.Default<"click">',
-    },
-    {
-        attributeType: "string",
-        defaultValue: "none",
-        enumValues: [...ANIMATION_VALUES],
-        name: "animation",
-        optional: true,
-        typeExpression: '("none" | "bounce" | "pulse" | "shake" | "flip") & tags.Default<"none">',
-    },
-    {
-        attributeType: "number",
-        constraints: {
-            minimum: 0,
-            typeTag: "uint32",
-        },
-        defaultValue: 0,
-        name: "clickCount",
-        optional: true,
-        typeExpression: 'number & tags.Minimum<0> & tags.Type<"uint32"> & tags.Default<0>',
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: false,
-        name: "isAnimating",
-        optional: true,
-        typeExpression: "boolean & tags.Default<false>",
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "showCounter",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "number",
-        constraints: {
-            minimum: 0,
-            typeTag: "uint32",
-        },
-        defaultValue: 10,
-        name: "maxClicks",
-        optional: true,
-        typeExpression: 'number & tags.Minimum<0> & tags.Type<"uint32"> & tags.Default<10>',
-    },
-];
-const PERSISTENCE_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 250,
-            minLength: 1,
-        },
-        defaultValue: (variables) => `${variables.title} persistence block`,
-        name: "content",
-        optional: false,
-        selector: (variables) => `.${variables.cssClassName}__content`,
-        source: "html",
-        typeExpression: (variables) => `string & tags.MinLength<1> & tags.MaxLength<250> & tags.Default<${quote(`${variables.title} persistence block`)}>`,
-    },
-    {
-        attributeType: "string",
-        defaultValue: "left",
-        enumValues: [...ALIGNMENT_VALUES],
-        name: "alignment",
-        optional: true,
-        typeExpression: 'TextAlignment & tags.Default<"left">',
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "isVisible",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "showCount",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 40,
-            minLength: 1,
-        },
-        defaultValue: "Persist Count",
-        name: "buttonLabel",
-        optional: true,
-        typeExpression: 'string & tags.MinLength<1> & tags.MaxLength<40> & tags.Default<"Persist Count">',
-    },
-    {
-        attributeType: "string",
-        blockJsonDefaultValue: "",
-        constraints: {
-            maxLength: 100,
-            minLength: 1,
-        },
-        manifestDefaultValue: "primary",
-        name: "resourceKey",
-        optional: true,
-        typeExpression: 'string & tags.MinLength<1> & tags.MaxLength<100> & tags.Default<"primary">',
-    },
-];
-const COMPOUND_PARENT_BASE_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 80,
-            minLength: 1,
-        },
-        defaultValue: (variables) => variables.title,
-        name: "heading",
-        optional: false,
-        selector: (variables) => `.${variables.cssClassName}__heading`,
-        source: "html",
-        typeExpression: (variables) => `string & tags.MinLength<1> & tags.MaxLength<80> & tags.Default<${quote(variables.title)}>`,
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 180,
-            minLength: 1,
-        },
-        defaultValue: "Add and reorder internal items inside this compound block.",
-        name: "intro",
-        optional: true,
-        selector: (variables) => `.${variables.cssClassName}__intro`,
-        source: "html",
-        typeExpression: 'string & tags.MinLength<1> & tags.MaxLength<180> & tags.Default<"Add and reorder internal items inside this compound block.">',
-    },
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "showDividers",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-];
-const COMPOUND_PARENT_PERSISTENCE_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "boolean",
-        defaultValue: true,
-        name: "showCount",
-        optional: true,
-        typeExpression: "boolean & tags.Default<true>",
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 40,
-            minLength: 1,
-        },
-        defaultValue: "Persist Count",
-        name: "buttonLabel",
-        optional: true,
-        typeExpression: 'string & tags.MinLength<1> & tags.MaxLength<40> & tags.Default<"Persist Count">',
-    },
-    {
-        attributeType: "string",
-        blockJsonDefaultValue: "",
-        constraints: {
-            maxLength: 100,
-            minLength: 1,
-        },
-        manifestDefaultValue: "primary",
-        name: "resourceKey",
-        optional: true,
-        typeExpression: 'string & tags.MinLength<1> & tags.MaxLength<100> & tags.Default<"primary">',
-    },
-];
-const COMPOUND_CHILD_ATTRIBUTE_SPECS = [
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 80,
-            minLength: 1,
-        },
-        defaultValue: ({ childTitle }) => childTitle,
-        name: "title",
-        optional: false,
-        selector: ({ childCssClassName }) => childCssClassName ? `.${childCssClassName}__title` : null,
-        source: ({ childCssClassName }) => childCssClassName ? "html" : null,
-        typeExpression: ({ childTitle }) => `string & tags.MinLength<1> & tags.MaxLength<80> & tags.Default<${quote(childTitle)}>`,
-    },
-    {
-        attributeType: "string",
-        constraints: {
-            maxLength: 280,
-            minLength: 1,
-        },
-        defaultValue: ({ bodyPlaceholder }) => bodyPlaceholder,
-        name: "body",
-        optional: false,
-        selector: ({ childCssClassName }) => childCssClassName ? `.${childCssClassName}__body` : null,
-        source: ({ childCssClassName }) => childCssClassName ? "html" : null,
-        typeExpression: ({ bodyPlaceholder }) => `string & tags.MinLength<1> & tags.MaxLength<280> & tags.Default<${quote(bodyPlaceholder)}>`,
-    },
-];
-function buildBasicAttributes() {
-    return buildAttributesFromSpecs(BASIC_ATTRIBUTE_SPECS, undefined);
-}
-function buildInteractivityAttributes(variables) {
-    return buildAttributesFromSpecs(INTERACTIVITY_ATTRIBUTE_SPECS, variables);
-}
-function buildPersistenceAttributes(variables) {
-    return buildAttributesFromSpecs(PERSISTENCE_ATTRIBUTE_SPECS, variables);
-}
-function buildCompoundParentAttributes(variables) {
-    return buildAttributesFromSpecs(variables.compoundPersistenceEnabled === "true"
-        ? [
-            ...COMPOUND_PARENT_BASE_ATTRIBUTE_SPECS,
-            ...COMPOUND_PARENT_PERSISTENCE_ATTRIBUTE_SPECS,
-        ]
-        : COMPOUND_PARENT_BASE_ATTRIBUTE_SPECS, variables);
-}
-function buildCompoundChildAttributes(bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, childTitle, childCssClassName) {
-    return buildAttributesFromSpecs(COMPOUND_CHILD_ATTRIBUTE_SPECS, {
-        bodyPlaceholder,
-        childCssClassName,
-        childTitle,
-    });
-}
-function buildBasicTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [
-            'import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";',
-            "import type {",
-            "\tTypiaValidationError,",
-            "\tValidationResult,",
-            '} from "@wp-typia/block-runtime/validation";',
-            'import { tags } from "typia";',
-            "",
-            'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
-        ],
-        interfaces: [
-            {
-                description: {
-                    lines: [
-                        "Block attributes interface",
-                        "Typia tags define runtime validation rules",
-                    ],
-                },
-                members: attributes.map((attribute) => ({
-                    description: attribute.description,
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-function buildInteractivityTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [
-            'import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";',
-            "import type {",
-            "\tTypiaValidationError,",
-            "\tValidationResult,",
-            '} from "@wp-typia/block-runtime/validation";',
-            'import { tags } from "typia";',
-            "",
-            'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
-        ],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            {
-                members: [
-                    {
-                        name: "clicks",
-                        typeExpression: "number",
-                    },
-                    {
-                        name: "isAnimating",
-                        typeExpression: "boolean",
-                    },
-                    {
-                        name: "isVisible",
-                        typeExpression: "boolean",
-                    },
-                    {
-                        name: "animation",
-                        typeExpression: '"none" | "bounce" | "pulse" | "shake" | "flip"',
-                    },
-                    {
-                        name: "maxClicks",
-                        typeExpression: "number",
-                    },
-                ],
-                name: `${variables.pascalCase}Context`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-function buildPersistenceTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [
-            'import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";',
-            "import type {",
-            "\tTypiaValidationError,",
-            "\tValidationResult,",
-            '} from "@wp-typia/block-runtime/validation";',
-            'import { tags } from "typia";',
-            "",
-            'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
-        ],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            {
-                members: [
-                    { name: "buttonLabel", typeExpression: "string" },
-                    { name: "bootstrapReady", typeExpression: "boolean" },
-                    { name: "canWrite", typeExpression: "boolean" },
-                    { name: "count", typeExpression: "number" },
-                    { name: "error", typeExpression: "string" },
-                    { name: "isBootstrapping", typeExpression: "boolean" },
-                    { name: "isLoading", typeExpression: "boolean" },
-                    { name: "isSaving", typeExpression: "boolean" },
-                    {
-                        name: "persistencePolicy",
-                        typeExpression: '"authenticated" | "public"',
-                    },
-                    { name: "postId", typeExpression: "number" },
-                    { name: "resourceKey", typeExpression: "string" },
-                    {
-                        name: "storage",
-                        typeExpression: '"post-meta" | "custom-table"',
-                    },
-                    { name: "isVisible", typeExpression: "boolean" },
-                    {
-                        name: "client",
-                        optional: true,
-                        typeExpression: `${variables.pascalCase}ClientState`,
-                    },
-                ],
-                name: `${variables.pascalCase}Context`,
-            },
-            {
-                members: [
-                    { name: "isHydrated", typeExpression: "boolean" },
-                ],
-                name: `${variables.pascalCase}State`,
-            },
-            {
-                members: [
-                    { name: "bootstrapError", typeExpression: "string" },
-                    { name: "writeExpiry", typeExpression: "number" },
-                    { name: "writeNonce", typeExpression: "string" },
-                    { name: "writeToken", typeExpression: "string" },
-                ],
-                name: `${variables.pascalCase}ClientState`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-function buildCompoundTypesSource(variables, attributes) {
-    const persistenceEnabled = variables.compoundPersistenceEnabled === "true";
-    return emitTypesModule({
-        preambleLines: persistenceEnabled
-            ? [
-                "import type {",
-                "\tTypiaValidationError,",
-                "\tValidationResult,",
-                '} from "@wp-typia/block-runtime/validation";',
-                'import { tags } from "typia";',
-                "",
-                'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
-            ]
-            : [
-                'import type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-                'import { tags } from "typia";',
-                "",
-                'export type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-            ],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}Attributes`,
-            },
-            ...(persistenceEnabled
-                ? [
-                    {
-                        members: [
-                            { name: "buttonLabel", typeExpression: "string" },
-                            { name: "bootstrapReady", typeExpression: "boolean" },
-                            { name: "canWrite", typeExpression: "boolean" },
-                            { name: "count", typeExpression: "number" },
-                            { name: "error", typeExpression: "string" },
-                            { name: "isBootstrapping", typeExpression: "boolean" },
-                            { name: "isLoading", typeExpression: "boolean" },
-                            { name: "isSaving", typeExpression: "boolean" },
-                            {
-                                name: "persistencePolicy",
-                                typeExpression: '"authenticated" | "public"',
-                            },
-                            { name: "postId", typeExpression: "number" },
-                            { name: "resourceKey", typeExpression: "string" },
-                            { name: "showCount", typeExpression: "boolean" },
-                            {
-                                name: "storage",
-                                typeExpression: '"post-meta" | "custom-table"',
-                            },
-                            {
-                                name: "client",
-                                optional: true,
-                                typeExpression: `${variables.pascalCase}ClientState`,
-                            },
-                        ],
-                        name: `${variables.pascalCase}Context`,
-                    },
-                    {
-                        members: [{ name: "isHydrated", typeExpression: "boolean" }],
-                        name: `${variables.pascalCase}State`,
-                    },
-                    {
-                        members: [
-                            { name: "bootstrapError", typeExpression: "string" },
-                            { name: "writeExpiry", typeExpression: "number" },
-                            { name: "writeNonce", typeExpression: "string" },
-                            { name: "writeToken", typeExpression: "string" },
-                        ],
-                        name: `${variables.pascalCase}ClientState`,
-                    },
-                ]
-                : []),
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}Attributes>`,
-            },
-        ],
-    });
-}
-function buildCompoundChildTypesSource(variables, attributes) {
-    return emitTypesModule({
-        preambleLines: [
-            'import type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-            'import { tags } from "typia";',
-            "",
-            'export type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-        ],
-        interfaces: [
-            {
-                members: attributes.map((attribute) => ({
-                    name: attribute.name,
-                    optional: attribute.optional,
-                    typeExpression: attribute.typeExpression,
-                })),
-                name: `${variables.pascalCase}ItemAttributes`,
-            },
-        ],
-        typeAliases: [
-            {
-                name: `${variables.pascalCase}ItemValidationResult`,
-                value: `ValidationResult<${variables.pascalCase}ItemAttributes>`,
-            },
-        ],
-    });
-}
 function buildBasicArtifact(variables) {
     const attributes = buildBasicAttributes();
     return {
@@ -943,7 +144,7 @@ function buildCompoundParentArtifact(variables) {
     };
 }
 function buildCompoundChildArtifact(variables, bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER) {
-    const attributes = buildCompoundChildAttributes(bodyPlaceholder, variables.compoundChildTitle, variables.compoundChildCssClassName);
+    const attributes = buildCompoundChildAttributes(variables.compoundChildTitle, variables.compoundChildCssClassName, bodyPlaceholder);
     return {
         blockJsonDocument: {
             $schema: "https://schemas.wp.org/trunk/block.json",
@@ -979,7 +180,7 @@ function buildCompoundChildArtifact(variables, bodyPlaceholder = DEFAULT_COMPOUN
  * @returns Starter manifest metadata for the compound child block.
  */
 export function buildCompoundChildStarterManifestDocument(childTypeName, childTitle, bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER) {
-    const attributes = buildCompoundChildAttributes(bodyPlaceholder, childTitle, null);
+    const attributes = buildCompoundChildAttributes(childTitle, null, bodyPlaceholder);
     return buildManifestDocument(childTypeName, attributes);
 }
 /**