@wp-typia/project-tools 0.16.10 → 0.16.12

package/README.md

@@ -26,6 +26,12 @@ Implementation note:
 - The shared implementation now lives in `@wp-typia/block-runtime/schema-core`.
 - Shared manifest/migration contract types now live in
   `@wp-typia/block-runtime/migration-types`.
+- The public `doctor` surface still lives on `@wp-typia/project-tools`, while
+  environment and workspace checks now sit behind focused helper modules.
+- These splits are maintainability refactors behind stable public facades. Keep
+  importing the documented `@wp-typia/project-tools` and
+  `@wp-typia/project-tools/schema-core` surfaces rather than the focused helper
+  files directly.
 
 Example:
 
@@ -63,9 +69,9 @@ instead of local casts:
 The higher-level generator architecture record, including the current phase map
 and the non-mutating `plan -> validate -> render -> apply` tool-facing usage
 model, lives in
-[`docs/block-generator-architecture.md`](../../docs/block-generator-architecture.md).
+[`docs/block-generator-architecture.md`](https://imjlk.github.io/wp-typia/architecture/block-generator-architecture/).
 The public non-mutating controller/tool contract now lives in
-[`docs/block-generator-tool-contract.md`](../../docs/block-generator-tool-contract.md).
+[`docs/block-generator-tool-contract.md`](https://imjlk.github.io/wp-typia/architecture/block-generator-tool-contract/).
 
 Reusable external layer packages on top of the built-in shared scaffold model
 are now available through the canonical built-in CLI flags
@@ -73,6 +79,6 @@ are now available through the canonical built-in CLI flags
 `wp-typia add block --external-layer-source ... [--external-layer-id ...]`,
 and programmatically through `scaffoldProject(...)`, `BlockGeneratorService`,
 and `inspectBlockGeneration(...)`. The layer contract record lives in
-[`docs/external-template-layer-composition.md`](../../docs/external-template-layer-composition.md).
+[`docs/external-template-layer-composition.md`](https://imjlk.github.io/wp-typia/architecture/external-template-layer-composition/).
 
 If you need metadata sync, editor helpers, validation helpers, or other generated-project runtime utilities, import them directly from `@wp-typia/block-runtime/*`.

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

@@ -0,0 +1,3 @@
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export type { AttributeDescription, EmittedAttributeDefinition, } from "./built-in-block-attribute-emitters.js";
+export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/built-in-block-artifact-documents.js

@@ -0,0 +1,2 @@
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/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/built-in-block-artifact-types.js

@@ -0,0 +1,304 @@
+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`,
+            },
+        ],
+        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 = variables.compoundPersistenceEnabled === "true";
+    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>`,
+            },
+        ],
+    });
+}