@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/templates/built-in-block-artifact-types.d.ts

@@ -0,0 +1,51 @@
+import type { ScaffoldTemplateVariables } from "./scaffold.js";
+interface AttributeDescription {
+    lines: string[];
+}
+interface EmittedAttributeDefinition {
+    description?: AttributeDescription;
+    name: string;
+    optional: boolean;
+    typeExpression: string;
+}
+/**
+ * Builds the generated attributes and validation type source for a basic block scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the basic block attribute and validation types.
+ */
+export declare function buildBasicTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes, context, and validation type source for an interactivity scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the interactivity block attribute, context, and validation types.
+ */
+export declare function buildInteractivityTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes, context, state, client, and validation type source for a persistence scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the persistence block runtime types.
+ */
+export declare function buildPersistenceTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes and optional persistence runtime type source for a compound parent scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound parent runtime types.
+ */
+export declare function buildCompoundTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes and validation type source for a compound child scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound child attribute and validation types.
+ */
+export declare function buildCompoundChildTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+export {};

package/dist/runtime/templates/built-in-block-artifact-types.js

@@ -0,0 +1,316 @@
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
+const STANDARD_PREAMBLE_LINES = [
+    '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";',
+];
+const VALIDATION_ONLY_PREAMBLE_LINES = [
+    'import type { ValidationResult } from "@wp-typia/block-runtime/validation";',
+    'import { tags } from "typia";',
+    "",
+    'export type { ValidationResult } from "@wp-typia/block-runtime/validation";',
+];
+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`;
+}
+/**
+ * Builds the generated attributes and validation type source for a basic block scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the basic block attribute and validation types.
+ */
+export function buildBasicTypesSource(variables, attributes) {
+    return emitTypesModule({
+        preambleLines: [...STANDARD_PREAMBLE_LINES],
+        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>`,
+            },
+        ],
+    });
+}
+/**
+ * Builds the generated attributes, context, and validation type source for an interactivity scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the interactivity block attribute, context, and validation types.
+ */
+export function buildInteractivityTypesSource(variables, attributes) {
+    return emitTypesModule({
+        preambleLines: [...STANDARD_PREAMBLE_LINES],
+        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`,
+            },
+            {
+                members: [
+                    { name: "clicks", typeExpression: "number" },
+                    { name: "isAnimating", typeExpression: "boolean" },
+                    { name: "isVisible", typeExpression: "boolean" },
+                    { name: "progress", typeExpression: "number" },
+                    { name: "clampedClicks", typeExpression: "number" },
+                    { name: "isComplete", typeExpression: "boolean" },
+                ],
+                name: `${variables.pascalCase}State`,
+            },
+        ],
+        typeAliases: [
+            {
+                name: `${variables.pascalCase}ValidationResult`,
+                value: `ValidationResult<${variables.pascalCase}Attributes>`,
+            },
+        ],
+    });
+}
+/**
+ * Builds the generated attributes, context, state, client, and validation type source for a persistence scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the persistence block runtime types.
+ */
+export function buildPersistenceTypesSource(variables, attributes) {
+    return emitTypesModule({
+        preambleLines: [...STANDARD_PREAMBLE_LINES],
+        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>`,
+            },
+        ],
+    });
+}
+/**
+ * Builds the generated attributes and optional persistence runtime type source for a compound parent scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound parent runtime types.
+ */
+export function buildCompoundTypesSource(variables, attributes) {
+    const persistenceEnabled = isCompoundPersistenceEnabled(variables);
+    return emitTypesModule({
+        preambleLines: persistenceEnabled
+            ? [...STANDARD_PREAMBLE_LINES]
+            : [...VALIDATION_ONLY_PREAMBLE_LINES],
+        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>`,
+            },
+        ],
+    });
+}
+/**
+ * Builds the generated attributes and validation type source for a compound child scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound child attribute and validation types.
+ */
+export function buildCompoundChildTypesSource(variables, attributes) {
+    return emitTypesModule({
+        preambleLines: [...VALIDATION_ONLY_PREAMBLE_LINES],
+        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>`,
+            },
+        ],
+    });
+}

package/dist/runtime/templates/built-in-block-artifacts.d.ts

@@ -0,0 +1,37 @@
+import type { ManifestDocument } from "../migration/migration-types.js";
+import type { ScaffoldTemplateVariables } from "./scaffold.js";
+import type { BuiltInTemplateId } from "./template-registry.js";
+export interface BuiltInBlockArtifact {
+    blockJsonDocument: Record<string, unknown>;
+    manifestDocument: ManifestDocument;
+    relativeDir: string;
+    typesSource: string;
+}
+/**
+ * Builds a starter manifest document for a generated compound child block.
+ *
+ * @param childTypeName TypeScript source type name for the child manifest.
+ * @param childTitle Default title used by the child block.
+ * @param bodyPlaceholder Optional placeholder used for the child body field.
+ * @returns Starter manifest metadata for the compound child block.
+ */
+export declare function buildCompoundChildStarterManifestDocument(childTypeName: string, childTitle: string, bodyPlaceholder?: string): ManifestDocument;
+/**
+ * Generates typed structural artifacts for a built-in block scaffold.
+ *
+ * @param options.templateId Built-in template family to emit.
+ * @param options.variables Resolved scaffold template variables.
+ * @returns Structural artifacts for the built-in block, including compound
+ * parent and child outputs when applicable.
+ */
+export declare function buildBuiltInBlockArtifacts({ templateId, variables, }: {
+    templateId: BuiltInTemplateId;
+    variables: ScaffoldTemplateVariables;
+}): BuiltInBlockArtifact[];
+/**
+ * Serializes a generated `block.json` document using scaffold formatting.
+ *
+ * @param document Structured `block.json` document.
+ * @returns Pretty-printed JSON with a trailing newline.
+ */
+export declare function stringifyBuiltInBlockJsonDocument(document: Record<string, unknown>): string;

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

@@ -0,0 +1,223 @@
+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";
+import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
+function stringifyBlockJsonDocument(document) {
+    return `${JSON.stringify(document, null, "\t")}\n`;
+}
+function buildBasicArtifact(variables) {
+    const attributes = buildBasicAttributes();
+    return {
+        blockJsonDocument: {
+            $schema: "https://schemas.wp.org/trunk/block.json",
+            apiVersion: 3,
+            name: `${variables.namespace}/${variables.slug}`,
+            version: variables.blockMetadataVersion,
+            title: variables.title,
+            category: variables.category,
+            icon: variables.icon,
+            description: variables.description,
+            keywords: [variables.keyword, "typia", "block"],
+            example: {
+                attributes: {
+                    content: "Example content",
+                    alignment: "center",
+                    isVisible: true,
+                },
+            },
+            supports: {
+                html: false,
+            },
+            textdomain: variables.textDomain,
+            editorScript: "file:./index.js",
+            editorStyle: "file:./index.css",
+            style: "file:./style-index.css",
+            attributes: buildBlockJsonAttributes(attributes),
+        },
+        manifestDocument: buildManifestDocument(`${variables.pascalCase}Attributes`, attributes),
+        relativeDir: "src",
+        typesSource: buildBasicTypesSource(variables, attributes),
+    };
+}
+function buildInteractivityArtifact(variables) {
+    const attributes = buildInteractivityAttributes(variables);
+    return {
+        blockJsonDocument: {
+            $schema: "https://schemas.wp.org/trunk/block.json",
+            apiVersion: 3,
+            name: `${variables.namespace}/${variables.slugKebabCase}`,
+            version: variables.blockMetadataVersion,
+            title: variables.title,
+            category: variables.category,
+            icon: variables.icon,
+            description: variables.description,
+            example: {},
+            supports: {
+                html: false,
+                align: true,
+                anchor: true,
+                className: true,
+                interactivity: true,
+            },
+            attributes: buildBlockJsonAttributes(attributes),
+            textdomain: variables.textDomain,
+            editorScript: "file:./index.js",
+            editorStyle: "file:./index.css",
+            style: "file:./style-index.css",
+            viewScriptModule: "file:./interactivity.js",
+        },
+        manifestDocument: buildManifestDocument(`${variables.pascalCase}Attributes`, attributes),
+        relativeDir: "src",
+        typesSource: buildInteractivityTypesSource(variables, attributes),
+    };
+}
+function buildPersistenceArtifact(variables) {
+    const attributes = buildPersistenceAttributes(variables);
+    return {
+        blockJsonDocument: {
+            $schema: "https://schemas.wp.org/trunk/block.json",
+            apiVersion: 3,
+            name: `${variables.namespace}/${variables.slugKebabCase}`,
+            version: variables.blockMetadataVersion,
+            title: variables.title,
+            category: variables.category,
+            icon: variables.icon,
+            description: variables.description,
+            example: {},
+            supports: {
+                html: false,
+                align: true,
+                anchor: true,
+                className: true,
+                interactivity: true,
+            },
+            attributes: buildBlockJsonAttributes(attributes),
+            textdomain: variables.textDomain,
+            editorScript: "file:./index.js",
+            style: "file:./style-index.css",
+            viewScriptModule: "file:./interactivity.js",
+            render: "file:./render.php",
+        },
+        manifestDocument: buildManifestDocument(`${variables.pascalCase}Attributes`, attributes),
+        relativeDir: "src",
+        typesSource: buildPersistenceTypesSource(variables, attributes),
+    };
+}
+function buildCompoundParentArtifact(variables) {
+    const attributes = buildCompoundParentAttributes(variables);
+    const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+    const persistenceEnabled = compoundGroup.enabled && compoundGroup.persistenceEnabled;
+    return {
+        blockJsonDocument: {
+            $schema: "https://schemas.wp.org/trunk/block.json",
+            apiVersion: 3,
+            name: `${variables.namespace}/${variables.slugKebabCase}`,
+            version: variables.blockMetadataVersion,
+            title: variables.title,
+            category: variables.category,
+            icon: variables.icon,
+            description: variables.description,
+            example: {},
+            allowedBlocks: [`${variables.namespace}/${variables.slugKebabCase}-item`],
+            supports: persistenceEnabled
+                ? {
+                    html: false,
+                    anchor: true,
+                    className: true,
+                    interactivity: true,
+                }
+                : {
+                    html: false,
+                    anchor: true,
+                    className: true,
+                },
+            attributes: buildBlockJsonAttributes(attributes),
+            textdomain: variables.textDomain,
+            editorScript: "file:./index.js",
+            style: "file:./style-index.css",
+            ...(persistenceEnabled
+                ? {
+                    viewScriptModule: "file:./interactivity.js",
+                    render: "file:./render.php",
+                }
+                : {}),
+        },
+        manifestDocument: buildManifestDocument(`${variables.pascalCase}Attributes`, attributes),
+        relativeDir: `src/blocks/${variables.slugKebabCase}`,
+        typesSource: buildCompoundTypesSource(variables, attributes),
+    };
+}
+function buildCompoundChildArtifact(variables, bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER) {
+    const attributes = buildCompoundChildAttributes(variables.compoundChildTitle, variables.compoundChildCssClassName, bodyPlaceholder);
+    return {
+        blockJsonDocument: {
+            $schema: "https://schemas.wp.org/trunk/block.json",
+            apiVersion: 3,
+            name: `${variables.namespace}/${variables.slugKebabCase}-item`,
+            version: variables.blockMetadataVersion,
+            title: variables.compoundChildTitle,
+            category: variables.compoundChildCategory,
+            icon: variables.compoundChildIcon,
+            description: `Internal item block used by ${variables.title}.`,
+            parent: [`${variables.namespace}/${variables.slugKebabCase}`],
+            example: {},
+            supports: {
+                html: false,
+                inserter: false,
+                reusable: false,
+            },
+            attributes: buildBlockJsonAttributes(attributes),
+            textdomain: variables.textDomain,
+            editorScript: "file:./index.js",
+        },
+        manifestDocument: buildManifestDocument(`${variables.pascalCase}ItemAttributes`, attributes),
+        relativeDir: `src/blocks/${variables.slugKebabCase}-item`,
+        typesSource: buildCompoundChildTypesSource(variables, attributes),
+    };
+}
+/**
+ * Builds a starter manifest document for a generated compound child block.
+ *
+ * @param childTypeName TypeScript source type name for the child manifest.
+ * @param childTitle Default title used by the child block.
+ * @param bodyPlaceholder Optional placeholder used for the child body field.
+ * @returns Starter manifest metadata for the compound child block.
+ */
+export function buildCompoundChildStarterManifestDocument(childTypeName, childTitle, bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER) {
+    const attributes = buildCompoundChildAttributes(childTitle, null, bodyPlaceholder);
+    return buildManifestDocument(childTypeName, attributes);
+}
+/**
+ * Generates typed structural artifacts for a built-in block scaffold.
+ *
+ * @param options.templateId Built-in template family to emit.
+ * @param options.variables Resolved scaffold template variables.
+ * @returns Structural artifacts for the built-in block, including compound
+ * parent and child outputs when applicable.
+ */
+export function buildBuiltInBlockArtifacts({ templateId, variables, }) {
+    if (templateId === "basic") {
+        return [buildBasicArtifact(variables)];
+    }
+    if (templateId === "interactivity") {
+        return [buildInteractivityArtifact(variables)];
+    }
+    if (templateId === "persistence") {
+        return [buildPersistenceArtifact(variables)];
+    }
+    if (templateId === "compound") {
+        return [
+            buildCompoundParentArtifact(variables),
+            buildCompoundChildArtifact(variables),
+        ];
+    }
+    return [];
+}
+/**
+ * Serializes a generated `block.json` document using scaffold formatting.
+ *
+ * @param document Structured `block.json` document.
+ * @returns Pretty-printed JSON with a trailing newline.
+ */
+export function stringifyBuiltInBlockJsonDocument(document) {
+    return stringifyBlockJsonDocument(document);
+}