@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/cli/cli-init.js

@@ -0,0 +1,21 @@
+import { applyInitPlan as applyInitPlanImpl } from "./cli-init-apply.js";
+import { getInitPlan as getInitPlanImpl } from "./cli-init-plan.js";
+export { applyInitPlan } from "./cli-init-apply.js";
+export { getInitPlan } from "./cli-init-plan.js";
+/**
+ * Execute `wp-typia init` in preview or apply mode.
+ *
+ * @param options Resolved command options including the target project
+ * directory, optional package-manager override, and whether writes should be
+ * applied.
+ * @returns The previewed or applied retrofit init plan.
+ */
+export async function runInitCommand(options) {
+    return options.apply
+        ? applyInitPlanImpl(options.projectDir, {
+            packageManager: options.packageManager,
+        })
+        : getInitPlanImpl(options.projectDir, {
+            packageManager: options.packageManager,
+        });
+}

package/dist/runtime/cli/cli-prompt.d.ts

@@ -0,0 +1,60 @@
+type ValidateInput = (value: string) => boolean | string;
+export type PromptLinePrinter = (line: string) => void;
+interface PromptOption<T extends string> {
+    hint?: string;
+    label: string;
+    value: T;
+}
+/**
+ * Prompt adapter used by CLI scaffold flows and migration wizard flows.
+ */
+export interface ReadlinePrompt {
+    close(): void;
+    select<T extends string>(message: string, options: PromptOption<T>[], defaultValue?: number): Promise<T>;
+    text(message: string, defaultValue: string, validate?: ValidateInput): Promise<string>;
+}
+/**
+ * Output adapters used by prompt rendering and validation feedback.
+ */
+export interface ReadlinePromptOutput {
+    /** Render one informational prompt line. */
+    printLine?: PromptLinePrinter;
+    /** Render one validation or selection error line. */
+    errorLine?: PromptLinePrinter;
+}
+/**
+ * Adapter interface for readline-style prompt interactions.
+ *
+ * Public CLI code uses the native readline implementation, while tests can
+ * substitute lightweight doubles that expose the same `question` and `close`
+ * methods.
+ */
+export interface ReadlineQuestionAdapter {
+    /** Close the underlying prompt interface and release any open handles. */
+    close(): void;
+    /**
+     * Render one prompt and resolve with the collected answer string.
+     *
+     * @param query Prompt text written to the active output stream.
+     * @param callback Callback that receives the entered answer.
+     */
+    question(query: string, callback: (answer: string) => void): void;
+}
+/**
+ * Create the default readline-backed prompt implementation for the CLI.
+ *
+ * @param output Optional line printers for prompt and validation output.
+ * @returns A prompt adapter that reads from stdin and writes to stdout.
+ */
+export declare function createReadlinePrompt(output?: ReadlinePromptOutput): ReadlinePrompt;
+/**
+ * Build a prompt adapter around a supplied readline-style question interface.
+ *
+ * This keeps the production CLI path unchanged while letting tests validate
+ * retry behavior without stubbing global stdin/stdout.
+ *
+ * @param rl Readline-compatible question adapter.
+ * @param output Optional line printers for prompt and validation output.
+ */
+export declare function createReadlinePromptWithInterface(rl: ReadlineQuestionAdapter, output?: ReadlinePromptOutput): ReadlinePrompt;
+export {};

package/dist/runtime/cli/cli-prompt.js

@@ -0,0 +1,141 @@
+import readline from "node:readline";
+/**
+ * Create the default readline-backed prompt implementation for the CLI.
+ *
+ * @param output Optional line printers for prompt and validation output.
+ * @returns A prompt adapter that reads from stdin and writes to stdout.
+ */
+export function createReadlinePrompt(output = {}) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return createReadlinePromptWithInterface(rl, output);
+}
+/**
+ * Build a prompt adapter around a supplied readline-style question interface.
+ *
+ * This keeps the production CLI path unchanged while letting tests validate
+ * retry behavior without stubbing global stdin/stdout.
+ *
+ * @param rl Readline-compatible question adapter.
+ * @param output Optional line printers for prompt and validation output.
+ */
+export function createReadlinePromptWithInterface(rl, output = {}) {
+    const { errorLine, printLine } = resolveReadlinePromptOutput(output);
+    const askQuestion = (query) => new Promise((resolve) => {
+        rl.question(query, resolve);
+    });
+    return {
+        async text(message, defaultValue, validate) {
+            while (true) {
+                const value = normalizePromptAnswer(await askQuestion(formatTextPrompt(message, defaultValue))) || defaultValue;
+                if (validate) {
+                    const result = validate(value);
+                    if (result !== true) {
+                        errorLine(formatValidationError(message, result, defaultValue));
+                        continue;
+                    }
+                }
+                return value;
+            }
+        },
+        async select(message, options, defaultValue = 1) {
+            if (options.length === 0) {
+                throw new Error(`select() requires at least one option for prompt: ${message}`);
+            }
+            const resolvedDefaultIndex = getResolvedDefaultIndex(options, defaultValue);
+            renderSelectPrompt(message, options, resolvedDefaultIndex, printLine);
+            while (true) {
+                const answer = normalizePromptAnswer(await askQuestion(formatChoicePrompt(resolvedDefaultIndex)));
+                if (answer.length === 0) {
+                    return options[resolvedDefaultIndex].value;
+                }
+                const selection = resolvePromptSelection(options, answer);
+                if (selection) {
+                    return selection.value;
+                }
+                if (isPromptHelpToken(answer)) {
+                    renderSelectPrompt(message, options, resolvedDefaultIndex, printLine);
+                    continue;
+                }
+                errorLine(formatInvalidSelectionError(answer, options, resolvedDefaultIndex));
+            }
+        },
+        close() {
+            rl.close();
+        },
+    };
+}
+function resolveReadlinePromptOutput({ errorLine, printLine, }) {
+    return {
+        errorLine: errorLine ?? writePromptErrorLine,
+        printLine: printLine ?? writePromptLine,
+    };
+}
+function writePromptLine(line) {
+    process.stdout.write(`${line}\n`);
+}
+function writePromptErrorLine(line) {
+    process.stderr.write(`${line}\n`);
+}
+function normalizePromptAnswer(value) {
+    return String(value).trim();
+}
+function normalizePromptToken(value) {
+    return value.trim().toLowerCase();
+}
+function getResolvedDefaultIndex(options, defaultValue) {
+    const candidateIndex = Number.isInteger(defaultValue) ? defaultValue - 1 : -1;
+    return options[candidateIndex] ? candidateIndex : 0;
+}
+function formatTextPrompt(message, defaultValue) {
+    const suffix = defaultValue.length > 0 ? ` [default: ${defaultValue}]` : "";
+    return `${message}${suffix}: `;
+}
+function formatValidationError(message, result, defaultValue) {
+    const detail = typeof result === "string" ? result : "Invalid input";
+    const retryHint = defaultValue.length > 0 ? ` Press Enter to keep "${defaultValue}".` : "";
+    return `❌ ${message}: ${detail}.${retryHint}`;
+}
+function formatChoicePrompt(defaultIndex) {
+    return `Choice [default: ${defaultIndex + 1}, ? for options]: `;
+}
+function renderSelectPrompt(message, options, defaultIndex, printLine) {
+    printLine(message);
+    printLine("  Enter a number, option label, or option value. Press Enter to keep the default, or type ? to list choices again.");
+    options.forEach((option, index) => {
+        const defaultMarker = index === defaultIndex ? " (default)" : "";
+        const valueHint = normalizePromptToken(option.label) === normalizePromptToken(option.value)
+            ? ""
+            : ` [${option.value}]`;
+        printLine(`  ${index + 1}. ${option.label}${valueHint}${defaultMarker}`);
+        if (option.hint) {
+            printLine(`     ${option.hint}`);
+        }
+    });
+}
+function isPromptHelpToken(answer) {
+    const normalized = normalizePromptToken(answer);
+    return normalized === "?" || normalized === "help" || normalized === "list";
+}
+function resolvePromptSelection(options, answer) {
+    const numericChoice = Number(answer);
+    if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
+        return options[numericChoice - 1];
+    }
+    const normalizedAnswer = normalizePromptToken(answer);
+    return options.find((option) => {
+        const normalizedLabel = normalizePromptToken(option.label);
+        const normalizedValue = normalizePromptToken(option.value);
+        return normalizedAnswer === normalizedLabel || normalizedAnswer === normalizedValue;
+    });
+}
+function formatInvalidSelectionError(answer, options, defaultIndex) {
+    const optionValues = options.map((option) => option.value).join(", ");
+    return [
+        `❌ Invalid selection: ${answer}.`,
+        `Enter 1-${options.length}, one of: ${optionValues},`,
+        `or press Enter for "${options[defaultIndex].label}".`,
+    ].join(" ");
+}

package/dist/runtime/cli/cli-validation.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Normalize one optional CLI string flag by trimming whitespace and collapsing
+ * empty strings to `undefined`.
+ *
+ * @param value Raw CLI value before normalization.
+ * @returns The trimmed string when present, otherwise `undefined`.
+ */
+export declare function normalizeOptionalCliString(value?: string): string | undefined;
+/**
+ * Resolve one CLI path flag relative to the caller when it is expressed as a
+ * local filesystem path.
+ *
+ * Non-local values such as npm package specs or `github:` locators pass
+ * through unchanged. Local relative and absolute paths are resolved against the
+ * provided `cwd` and must exist on disk.
+ *
+ * @param options Path resolution inputs for one CLI flag.
+ * @param options.cwd Caller working directory used for relative path
+ * resolution.
+ * @param options.label Human-readable option label used in thrown errors.
+ * @param options.value Raw CLI value before trimming and path resolution.
+ * @returns The normalized string, or `undefined` when the option was omitted.
+ * @throws When a local-looking path resolves to a missing filesystem entry.
+ */
+export declare function resolveLocalCliPathOption(options: {
+    cwd: string;
+    label: string;
+    value?: string;
+}): string | undefined;
+/**
+ * Validate the built-in template composition rule for external layers.
+ *
+ * @param options External layer CLI options after normalization.
+ * @param options.externalLayerId Optional selected layer id.
+ * @param options.externalLayerSource Optional layer source locator or path.
+ * @throws When `externalLayerId` is provided without `externalLayerSource`.
+ */
+export declare function assertExternalLayerCompositionOptions(options: {
+    externalLayerId?: string;
+    externalLayerSource?: string;
+}): void;
+/**
+ * Build the shared error message used when a built-in template receives a
+ * `--variant` override.
+ *
+ * @param options Built-in template context.
+ * @param options.templateId Built-in template id that rejected the variant.
+ * @param options.variant User-supplied variant override.
+ * @returns The canonical user-facing error message.
+ */
+export declare function createBuiltInVariantErrorMessage(options: {
+    templateId: string;
+    variant: string;
+}): string;
+/**
+ * Reject unsupported `--variant` usage for built-in templates.
+ *
+ * @param options Built-in template validation context.
+ * @param options.templateId Built-in template id being scaffolded.
+ * @param options.variant Optional variant override from CLI flags.
+ * @throws When a built-in template receives any explicit `--variant` value.
+ */
+export declare function assertBuiltInTemplateVariantAllowed(options: {
+    templateId: string;
+    variant?: string;
+}): void;

package/dist/runtime/cli/cli-validation.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagnostics.js";
+/**
+ * Normalize one optional CLI string flag by trimming whitespace and collapsing
+ * empty strings to `undefined`.
+ *
+ * @param value Raw CLI value before normalization.
+ * @returns The trimmed string when present, otherwise `undefined`.
+ */
+export function normalizeOptionalCliString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function looksLikeLocalCliPath(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith("./") ||
+        value.startsWith("../") ||
+        value.startsWith(".\\") ||
+        value.startsWith("..\\"));
+}
+/**
+ * Resolve one CLI path flag relative to the caller when it is expressed as a
+ * local filesystem path.
+ *
+ * Non-local values such as npm package specs or `github:` locators pass
+ * through unchanged. Local relative and absolute paths are resolved against the
+ * provided `cwd` and must exist on disk.
+ *
+ * @param options Path resolution inputs for one CLI flag.
+ * @param options.cwd Caller working directory used for relative path
+ * resolution.
+ * @param options.label Human-readable option label used in thrown errors.
+ * @param options.value Raw CLI value before trimming and path resolution.
+ * @returns The normalized string, or `undefined` when the option was omitted.
+ * @throws When a local-looking path resolves to a missing filesystem entry.
+ */
+export function resolveLocalCliPathOption(options) {
+    const normalizedValue = normalizeOptionalCliString(options.value);
+    if (!normalizedValue || !looksLikeLocalCliPath(normalizedValue)) {
+        return normalizedValue;
+    }
+    const resolvedPath = path.resolve(options.cwd, normalizedValue);
+    if (!fs.existsSync(resolvedPath)) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
+    }
+    return resolvedPath;
+}
+/**
+ * Validate the built-in template composition rule for external layers.
+ *
+ * @param options External layer CLI options after normalization.
+ * @param options.externalLayerId Optional selected layer id.
+ * @param options.externalLayerSource Optional layer source locator or path.
+ * @throws When `externalLayerId` is provided without `externalLayerSource`.
+ */
+export function assertExternalLayerCompositionOptions(options) {
+    if (options.externalLayerId && !options.externalLayerSource) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "externalLayerId requires externalLayerSource when composing built-in template layers.");
+    }
+}
+/**
+ * Build the shared error message used when a built-in template receives a
+ * `--variant` override.
+ *
+ * @param options Built-in template context.
+ * @param options.templateId Built-in template id that rejected the variant.
+ * @param options.variant User-supplied variant override.
+ * @returns The canonical user-facing error message.
+ */
+export function createBuiltInVariantErrorMessage(options) {
+    return `--variant is only supported for official external template configs. Received variant "${options.variant}" for built-in template "${options.templateId}".`;
+}
+/**
+ * Reject unsupported `--variant` usage for built-in templates.
+ *
+ * @param options Built-in template validation context.
+ * @param options.templateId Built-in template id being scaffolded.
+ * @param options.variant Optional variant override from CLI flags.
+ * @throws When a built-in template receives any explicit `--variant` value.
+ */
+export function assertBuiltInTemplateVariantAllowed(options) {
+    if (!options.variant) {
+        return;
+    }
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, createBuiltInVariantErrorMessage({
+        templateId: options.templateId,
+        variant: options.variant,
+    }));
+}

package/dist/runtime/cli-add-block-config.d.ts

@@ -1,6 +1 @@
-import type { MigrationBlockConfig } from "./migration-types.js";
-import type { ScaffoldTemplateVariables } from "./scaffold.js";
-import { type AddBlockTemplateId } from "./cli-add-shared.js";
-export declare function buildServerTemplateRoot(persistencePolicy: string | undefined): string;
-export declare function buildConfigEntries(templateId: AddBlockTemplateId, variables: ScaffoldTemplateVariables): string[];
-export declare function buildMigrationBlocks(templateId: AddBlockTemplateId, variables: ScaffoldTemplateVariables): MigrationBlockConfig[];
+export * from "./add/cli-add-block-config.js";

package/dist/runtime/cli-add-block-config.js

@@ -1,144 +1 @@
-import path from "node:path";
-import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
-import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
-import { quoteTsString, } from "./cli-add-shared.js";
-export function buildServerTemplateRoot(persistencePolicy) {
-    return path.join(SHARED_WORKSPACE_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth");
-}
-function buildSingleBlockConfigEntry(variables) {
-    return [
-        "\t{",
-        `\t\tslug: ${quoteTsString(variables.slugKebabCase)},`,
-        `\t\tattributeTypeName: ${quoteTsString(`${variables.pascalCase}Attributes`)},`,
-        `\t\ttypesFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}/types.ts`)},`,
-        "\t},",
-    ].join("\n");
-}
-function buildPersistenceBlockConfigEntry(variables) {
-    return [
-        "\t{",
-        `\t\tapiTypesFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}/api-types.ts`)},`,
-        `\t\tattributeTypeName: ${quoteTsString(`${variables.pascalCase}Attributes`)},`,
-        "\t\trestManifest: defineEndpointManifest( {",
-        "\t\t\tcontracts: {",
-        "\t\t\t\t'bootstrap-query': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapQuery`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'bootstrap-response': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapResponse`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'state-query': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateQuery`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'state-response': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateResponse`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'write-state-request': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}WriteStateRequest`)},`,
-        "\t\t\t\t},",
-        "\t\t\t},",
-        "\t\t\tendpoints: [",
-        "\t\t\t\t{",
-        "\t\t\t\t\tauth: 'public',",
-        "\t\t\t\t\tmethod: 'GET',",
-        `\t\t\t\t\toperationId: ${quoteTsString(`get${variables.pascalCase}State`)},`,
-        `\t\t\t\t\tpath: ${quoteTsString(`/${variables.namespace}/v1/${variables.slugKebabCase}/state`)},`,
-        "\t\t\t\t\tqueryContract: 'state-query',",
-        "\t\t\t\t\tresponseContract: 'state-response',",
-        `\t\t\t\t\tsummary: 'Read the current persisted state.',`,
-        `\t\t\t\t\ttags: [ ${quoteTsString(variables.title)} ],`,
-        "\t\t\t\t},",
-        "\t\t\t\t{",
-        `\t\t\t\t\tauth: ${quoteTsString(variables.restWriteAuthIntent)},`,
-        "\t\t\t\t\tbodyContract: 'write-state-request',",
-        "\t\t\t\t\tmethod: 'POST',",
-        `\t\t\t\t\toperationId: ${quoteTsString(`write${variables.pascalCase}State`)},`,
-        `\t\t\t\t\tpath: ${quoteTsString(`/${variables.namespace}/v1/${variables.slugKebabCase}/state`)},`,
-        "\t\t\t\t\tresponseContract: 'state-response',",
-        `\t\t\t\t\tsummary: 'Write the current persisted state.',`,
-        `\t\t\t\t\ttags: [ ${quoteTsString(variables.title)} ],`,
-        "\t\t\t\t\twordpressAuth: {",
-        `\t\t\t\t\t\tmechanism: ${quoteTsString(variables.restWriteAuthMechanism)},`,
-        "\t\t\t\t\t},",
-        "\t\t\t\t},",
-        "\t\t\t\t{",
-        "\t\t\t\t\tauth: 'public',",
-        "\t\t\t\t\tmethod: 'GET',",
-        `\t\t\t\t\toperationId: ${quoteTsString(`get${variables.pascalCase}Bootstrap`)},`,
-        `\t\t\t\t\tpath: ${quoteTsString(`/${variables.namespace}/v1/${variables.slugKebabCase}/bootstrap`)},`,
-        "\t\t\t\t\tqueryContract: 'bootstrap-query',",
-        "\t\t\t\t\tresponseContract: 'bootstrap-response',",
-        `\t\t\t\t\tsummary: 'Read fresh session bootstrap state for the current viewer.',`,
-        `\t\t\t\t\ttags: [ ${quoteTsString(variables.title)} ],`,
-        "\t\t\t\t},",
-        "\t\t\t],",
-        "\t\t\tinfo: {",
-        `\t\t\t\ttitle: ${quoteTsString(`${variables.title} REST API`)},`,
-        "\t\t\t\tversion: '1.0.0',",
-        "\t\t\t},",
-        "\t\t} ),",
-        `\t\topenApiFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}/api.openapi.json`)},`,
-        `\t\tslug: ${quoteTsString(variables.slugKebabCase)},`,
-        `\t\ttypesFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}/types.ts`)},`,
-        "\t},",
-    ].join("\n");
-}
-function buildCompoundChildConfigEntry(variables) {
-    return [
-        "\t{",
-        `\t\tslug: ${quoteTsString(`${variables.slugKebabCase}-item`)},`,
-        `\t\tattributeTypeName: ${quoteTsString(`${variables.pascalCase}ItemAttributes`)},`,
-        `\t\ttypesFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}-item/types.ts`)},`,
-        "\t},",
-    ].join("\n");
-}
-export function buildConfigEntries(templateId, variables) {
-    if (templateId === "basic" || templateId === "interactivity") {
-        return [buildSingleBlockConfigEntry(variables)];
-    }
-    if (templateId === "persistence") {
-        return [buildPersistenceBlockConfigEntry(variables)];
-    }
-    if (isCompoundPersistenceEnabled(variables)) {
-        return [
-            buildPersistenceBlockConfigEntry(variables),
-            buildCompoundChildConfigEntry(variables),
-        ];
-    }
-    return [
-        buildSingleBlockConfigEntry(variables),
-        buildCompoundChildConfigEntry(variables),
-    ];
-}
-export function buildMigrationBlocks(templateId, variables) {
-    if (templateId === "compound") {
-        return [
-            {
-                blockJsonFile: `src/blocks/${variables.slugKebabCase}/block.json`,
-                blockName: `${variables.namespace}/${variables.slugKebabCase}`,
-                key: variables.slugKebabCase,
-                manifestFile: `src/blocks/${variables.slugKebabCase}/typia.manifest.json`,
-                saveFile: `src/blocks/${variables.slugKebabCase}/save.tsx`,
-                typesFile: `src/blocks/${variables.slugKebabCase}/types.ts`,
-            },
-            {
-                blockJsonFile: `src/blocks/${variables.slugKebabCase}-item/block.json`,
-                blockName: `${variables.namespace}/${variables.slugKebabCase}-item`,
-                key: `${variables.slugKebabCase}-item`,
-                manifestFile: `src/blocks/${variables.slugKebabCase}-item/typia.manifest.json`,
-                saveFile: `src/blocks/${variables.slugKebabCase}-item/save.tsx`,
-                typesFile: `src/blocks/${variables.slugKebabCase}-item/types.ts`,
-            },
-        ];
-    }
-    return [
-        {
-            blockJsonFile: `src/blocks/${variables.slugKebabCase}/block.json`,
-            blockName: `${variables.namespace}/${variables.slugKebabCase}`,
-            key: variables.slugKebabCase,
-            manifestFile: `src/blocks/${variables.slugKebabCase}/typia.manifest.json`,
-            saveFile: `src/blocks/${variables.slugKebabCase}/save.tsx`,
-            typesFile: `src/blocks/${variables.slugKebabCase}/types.ts`,
-        },
-    ];
-}
+export * from "./add/cli-add-block-config.js";

package/dist/runtime/cli-add-block-json.d.ts

@@ -1,31 +1 @@
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-/**
- * Resolve an existing workspace block inventory entry by slug.
- *
- * @param inventory Parsed workspace inventory that owns available blocks.
- * @param blockSlug Workspace block slug to locate.
- * @returns The matching workspace block inventory entry.
- * @throws {Error} When the block slug is not present in the inventory.
- */
-export declare function resolveWorkspaceBlock(inventory: WorkspaceInventory, blockSlug: string): WorkspaceInventory["blocks"][number];
-/**
- * Read and validate a workspace block's `block.json` metadata from disk.
- *
- * @param projectDir Absolute workspace root directory.
- * @param blockSlug Workspace block slug whose metadata should be read.
- * @returns Parsed block metadata and the absolute `block.json` path.
- * @throws {Error} When the file is missing or cannot be parsed as scaffold metadata.
- */
-export declare function readWorkspaceBlockJson(projectDir: string, blockSlug: string): Promise<{
-    blockJson: Record<string, unknown>;
-    blockJsonPath: string;
-}>;
-/**
- * Return a mutable `blockHooks` object for a parsed block metadata document.
- *
- * @param blockJson Parsed block metadata object that may be mutated.
- * @param blockJsonRelativePath Relative path used in validation error messages.
- * @returns The existing or newly created mutable `blockHooks` map.
- * @throws {Error} When `blockHooks` exists but is not an object.
- */
-export declare function getMutableBlockHooks(blockJson: Record<string, unknown>, blockJsonRelativePath: string): Record<string, string>;
+export * from "./add/cli-add-block-json.js";

package/dist/runtime/cli-add-block-json.js

@@ -1,70 +1 @@
-import path from "node:path";
-import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import { readOptionalUtf8File } from "./fs-async.js";
-import { safeJsonParse } from "./json-utils.js";
-/**
- * Resolve an existing workspace block inventory entry by slug.
- *
- * @param inventory Parsed workspace inventory that owns available blocks.
- * @param blockSlug Workspace block slug to locate.
- * @returns The matching workspace block inventory entry.
- * @throws {Error} When the block slug is not present in the inventory.
- */
-export function resolveWorkspaceBlock(inventory, blockSlug) {
-    const block = inventory.blocks.find((entry) => entry.slug === blockSlug);
-    if (!block) {
-        throw new Error(`Unknown workspace block "${blockSlug}". Choose one of: ${inventory.blocks.map((entry) => entry.slug).join(", ")}`);
-    }
-    return block;
-}
-/**
- * Read and validate a workspace block's `block.json` metadata from disk.
- *
- * @param projectDir Absolute workspace root directory.
- * @param blockSlug Workspace block slug whose metadata should be read.
- * @returns Parsed block metadata and the absolute `block.json` path.
- * @throws {Error} When the file is missing or cannot be parsed as scaffold metadata.
- */
-export async function readWorkspaceBlockJson(projectDir, blockSlug) {
-    const blockJsonPath = path.join(projectDir, "src", "blocks", blockSlug, "block.json");
-    const source = await readOptionalUtf8File(blockJsonPath);
-    if (source === null) {
-        throw new Error(`Missing ${path.relative(projectDir, blockJsonPath)} for workspace block "${blockSlug}".`);
-    }
-    let blockJson;
-    try {
-        blockJson = parseScaffoldBlockMetadata(safeJsonParse(source, {
-            context: "workspace block metadata",
-            filePath: blockJsonPath,
-        }));
-    }
-    catch (error) {
-        throw new Error(error instanceof Error
-            ? `Failed to parse ${path.relative(projectDir, blockJsonPath)}: ${error.message}`
-            : `Failed to parse ${path.relative(projectDir, blockJsonPath)}.`);
-    }
-    return {
-        blockJson,
-        blockJsonPath,
-    };
-}
-/**
- * Return a mutable `blockHooks` object for a parsed block metadata document.
- *
- * @param blockJson Parsed block metadata object that may be mutated.
- * @param blockJsonRelativePath Relative path used in validation error messages.
- * @returns The existing or newly created mutable `blockHooks` map.
- * @throws {Error} When `blockHooks` exists but is not an object.
- */
-export function getMutableBlockHooks(blockJson, blockJsonRelativePath) {
-    const blockHooks = blockJson.blockHooks;
-    if (blockHooks === undefined) {
-        const nextHooks = {};
-        blockJson.blockHooks = nextHooks;
-        return nextHooks;
-    }
-    if (!blockHooks || typeof blockHooks !== "object" || Array.isArray(blockHooks)) {
-        throw new Error(`${blockJsonRelativePath} must define blockHooks as an object when present.`);
-    }
-    return blockHooks;
-}
+export * from "./add/cli-add-block-json.js";

package/dist/runtime/cli-add-block-legacy-validator.d.ts

@@ -1,4 +1 @@
-export declare const COMPOUND_SHARED_SUPPORT_FILES: readonly ["hooks.ts", "validator-toolkit.ts"];
-export declare function ensureBlockConfigCanAddRestManifests(source: string): string;
-export declare function collectLegacyCompoundValidatorPaths(projectDir: string): Promise<string[]>;
-export declare function ensureCompoundWorkspaceSupportFiles(projectDir: string, tempProjectDir: string, legacyValidatorPaths: readonly string[]): Promise<void>;
+export * from "./add/cli-add-block-legacy-validator.js";