@wp-typia/project-tools 0.24.4 → 0.24.5

package/dist/runtime/post-meta-binding-fields.js

@@ -1,135 +1 @@
-import path from "node:path";
-import { readJsonFile, readJsonFileSync } from "./json-utils.js";
-const SUPPORTED_SCHEMA_TYPES = new Set([
-    "array",
-    "boolean",
-    "integer",
-    "number",
-    "object",
-    "string",
-]);
-function isJsonRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function resolveSchemaType(schema) {
-    const type = schema.type;
-    if (typeof type === "string" && SUPPORTED_SCHEMA_TYPES.has(type)) {
-        return type;
-    }
-    if (Array.isArray(type) &&
-        type.every((entry) => typeof entry === "string")) {
-        const nonNullType = type.find((entry) => entry !== "null" && SUPPORTED_SCHEMA_TYPES.has(entry));
-        if (nonNullType) {
-            return nonNullType;
-        }
-    }
-    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
-        return "string";
-    }
-    return "unknown";
-}
-function resolveFallbackValue(name, schema, schemaType) {
-    const enumValue = Array.isArray(schema.enum)
-        ? schema.enum.find((entry) => typeof entry === "string")
-        : undefined;
-    if (typeof enumValue === "string") {
-        return enumValue;
-    }
-    switch (schemaType) {
-        case "array":
-            return "[]";
-        case "boolean":
-            return "false";
-        case "integer":
-        case "number":
-            return "0";
-        case "object":
-            return "{}";
-        default:
-            return `${name} preview`;
-    }
-}
-function resolveFieldLabel(name) {
-    return name
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .replace(/[_-]+/g, " ")
-        .replace(/\s+/g, " ")
-        .trim()
-        .replace(/\b\w/g, (match) => match.toUpperCase());
-}
-function extractPostMetaBindingFields(schema, context) {
-    if (!isJsonRecord(schema) || !isJsonRecord(schema.properties)) {
-        throw new Error(`${context} must expose an object schema with top-level properties before it can back a binding source.`);
-    }
-    const required = Array.isArray(schema.required)
-        ? new Set(schema.required.filter((entry) => typeof entry === "string"))
-        : new Set();
-    const fields = Object.entries(schema.properties).map(([name, propertySchema]) => {
-        const property = isJsonRecord(propertySchema) ? propertySchema : {};
-        const schemaType = resolveSchemaType(property);
-        return {
-            fallbackValue: resolveFallbackValue(name, property, schemaType),
-            label: resolveFieldLabel(name),
-            name,
-            required: required.has(name),
-            schemaType,
-        };
-    });
-    if (fields.length === 0) {
-        throw new Error(`${context} does not expose any top-level properties that can back binding fields.`);
-    }
-    return fields;
-}
-/**
- * Load and extract binding fields from a post-meta JSON Schema artifact.
- *
- * @param projectDir Workspace root directory.
- * @param postMeta Post-meta inventory entry that points to the schema file.
- * @returns Promise resolving to the extracted top-level binding fields.
- * @throws If the schema cannot be read or does not expose object properties.
- */
-export async function loadPostMetaBindingFields(projectDir, postMeta) {
-    const schemaPath = path.join(projectDir, postMeta.schemaFile);
-    const schema = await readJsonFile(schemaPath, {
-        context: `post meta schema for ${postMeta.slug}`,
-    });
-    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
-}
-/**
- * Synchronously load and extract binding fields from a post-meta JSON Schema artifact.
- *
- * @param projectDir Workspace root directory.
- * @param postMeta Post-meta inventory entry that points to the schema file.
- * @returns Extracted top-level binding fields.
- * @throws If the schema cannot be read or does not expose object properties.
- */
-export function loadPostMetaBindingFieldsSync(projectDir, postMeta) {
-    const schemaPath = path.join(projectDir, postMeta.schemaFile);
-    const schema = readJsonFileSync(schemaPath, {
-        context: `post meta schema for ${postMeta.slug}`,
-    });
-    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
-}
-/**
- * Validate and resolve a top-level post-meta binding path.
- *
- * @param fields Binding fields extracted from the post-meta schema.
- * @param postMetaSlug Post-meta contract slug used in diagnostics.
- * @param metaPath User-provided field path to validate.
- * @returns The matching binding field.
- * @throws If the path is empty, nested, or missing from the schema fields.
- */
-export function assertPostMetaBindingPath(fields, postMetaSlug, metaPath) {
-    const trimmed = metaPath.trim();
-    if (!trimmed) {
-        throw new Error("Post meta binding path must include a value.");
-    }
-    if (trimmed.includes(".")) {
-        throw new Error(`Nested post meta path "${trimmed}" for "${postMetaSlug}" is not supported yet. Use one of the top-level fields: ${fields.map((field) => field.name).join(", ")}.`);
-    }
-    const field = fields.find((candidate) => candidate.name === trimmed);
-    if (!field) {
-        throw new Error(`Post meta path "${trimmed}" does not exist in the "${postMetaSlug}" schema. Expected one of: ${fields.map((candidate) => candidate.name).join(", ")}.`);
-    }
-    return field;
-}
+export * from "./add/post-meta-binding-fields.js";

package/dist/runtime/rest-resource-artifacts.d.ts

@@ -1,91 +1 @@
-import type { ManualRestContractAuthId, ManualRestContractHttpMethodId, RestResourceMethodId } from "./cli-add-shared.js";
-interface RestResourceTemplateVariablesLike {
-    namespace: string;
-    pascalCase: string;
-    routePattern?: string;
-    slugKebabCase: string;
-    title: string;
-}
-interface SyncRestResourceArtifactsOptions {
-    clientFile: string;
-    methods: RestResourceMethodId[];
-    outputDir: string;
-    projectDir: string;
-    typesFile: string;
-    validatorsFile: string;
-    variables: RestResourceTemplateVariablesLike;
-}
-interface ManualRestContractTemplateVariablesLike {
-    auth: ManualRestContractAuthId;
-    bodyTypeName?: string;
-    method: ManualRestContractHttpMethodId;
-    namespace: string;
-    pascalCase: string;
-    pathPattern: string;
-    queryTypeName: string;
-    responseTypeName: string;
-    slugKebabCase: string;
-    title: string;
-}
-interface SyncManualRestContractArtifactsOptions {
-    clientFile: string;
-    outputDir: string;
-    projectDir: string;
-    typesFile: string;
-    validatorsFile: string;
-    variables: ManualRestContractTemplateVariablesLike;
-}
-/**
- * Build the endpoint manifest for a workspace-level REST resource scaffold.
- *
- * @param variables Template naming data used for contract names, routes, and OpenAPI info.
- * @param methods Enabled REST methods for the generated resource.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export declare function buildRestResourceEndpointManifest(variables: RestResourceTemplateVariablesLike, methods: RestResourceMethodId[]): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
-    sourceTypeName: string;
-}>, import("@wp-typia/block-runtime/schema-core").EndpointOpenApiEndpointDefinition[]>;
-/**
- * Build the endpoint manifest for a type-only manual REST contract. Manual
- * contracts describe routes owned by another integration without generating PHP
- * route glue in the workspace.
- *
- * @param variables Template naming data used for contract names, route path,
- * and OpenAPI info.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export declare function buildManualRestContractEndpointManifest(variables: ManualRestContractTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
-    sourceTypeName: string;
-}>, readonly [{
-    readonly wordpressAuth?: {
-        mechanism: "rest-nonce";
-    } | {
-        mechanism: "public-signed-token";
-    } | undefined;
-    readonly method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
-    readonly operationId: `call${string}ManualRestContract`;
-    readonly path: `/${string}${string}`;
-    readonly queryContract: "query";
-    readonly responseContract: "response";
-    readonly summary: `Call external ${string} REST route.`;
-    readonly tags: readonly [string];
-    readonly bodyContract?: string | undefined;
-    readonly auth: "authenticated" | "public" | "public-write-protected";
-}]>;
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for
- * a workspace-level REST resource scaffold.
- *
- * @param options Resource file paths, enabled methods, and naming variables.
- * @returns A promise that resolves after every generated REST artifact has been refreshed.
- */
-export declare function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncRestResourceArtifactsOptions): Promise<void>;
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
- * type-only manual REST contract.
- *
- * @param options Contract file paths and naming variables.
- * @returns A promise that resolves after every generated artifact has refreshed.
- */
-export declare function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncManualRestContractArtifactsOptions): Promise<void>;
-export {};
+export * from "./add/rest-resource-artifacts.js";

package/dist/runtime/rest-resource-artifacts.js

@@ -1,254 +1 @@
-import path from "node:path";
-import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
-function resolveManualRestContractWordPressAuth(auth) {
-    if (auth === "authenticated") {
-        return {
-            mechanism: "rest-nonce",
-        };
-    }
-    if (auth === "public-write-protected") {
-        return {
-            mechanism: "public-signed-token",
-        };
-    }
-    return undefined;
-}
-/**
- * Build the endpoint manifest for a workspace-level REST resource scaffold.
- *
- * @param variables Template naming data used for contract names, routes, and OpenAPI info.
- * @param methods Enabled REST methods for the generated resource.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export function buildRestResourceEndpointManifest(variables, methods) {
-    const basePath = `/${variables.namespace}/${variables.slugKebabCase}`;
-    const routePattern = variables.routePattern == null
-        ? `/${variables.slugKebabCase}/item`
-        : variables.routePattern.startsWith("/")
-            ? variables.routePattern
-            : `/${variables.routePattern}`;
-    const itemPath = `/${variables.namespace}${routePattern}`;
-    const contracts = {};
-    const endpoints = [];
-    if (methods.includes("list")) {
-        contracts["list-query"] = {
-            sourceTypeName: `${variables.pascalCase}ListQuery`,
-        };
-        contracts["list-response"] = {
-            sourceTypeName: `${variables.pascalCase}ListResponse`,
-        };
-        endpoints.push({
-            auth: "public",
-            method: "GET",
-            operationId: `list${variables.pascalCase}Resources`,
-            path: basePath,
-            queryContract: "list-query",
-            responseContract: "list-response",
-            summary: `List ${variables.title} resources.`,
-            tags: [variables.title],
-        });
-    }
-    if (methods.includes("read")) {
-        contracts["read-query"] = {
-            sourceTypeName: `${variables.pascalCase}ReadQuery`,
-        };
-        contracts["read-response"] = {
-            sourceTypeName: `${variables.pascalCase}ReadResponse`,
-        };
-        endpoints.push({
-            auth: "public",
-            method: "GET",
-            operationId: `read${variables.pascalCase}Resource`,
-            path: itemPath,
-            queryContract: "read-query",
-            responseContract: "read-response",
-            summary: `Read one ${variables.title} resource.`,
-            tags: [variables.title],
-        });
-    }
-    if (methods.includes("create")) {
-        contracts["create-request"] = {
-            sourceTypeName: `${variables.pascalCase}CreateRequest`,
-        };
-        contracts["create-response"] = {
-            sourceTypeName: `${variables.pascalCase}CreateResponse`,
-        };
-        endpoints.push({
-            auth: "authenticated",
-            bodyContract: "create-request",
-            method: "POST",
-            operationId: `create${variables.pascalCase}Resource`,
-            path: basePath,
-            responseContract: "create-response",
-            summary: `Create one ${variables.title} resource.`,
-            tags: [variables.title],
-            wordpressAuth: {
-                mechanism: "rest-nonce",
-            },
-        });
-    }
-    if (methods.includes("update")) {
-        contracts["update-query"] = {
-            sourceTypeName: `${variables.pascalCase}UpdateQuery`,
-        };
-        contracts["update-request"] = {
-            sourceTypeName: `${variables.pascalCase}UpdateRequest`,
-        };
-        contracts["update-response"] = {
-            sourceTypeName: `${variables.pascalCase}UpdateResponse`,
-        };
-        endpoints.push({
-            auth: "authenticated",
-            bodyContract: "update-request",
-            method: "POST",
-            operationId: `update${variables.pascalCase}Resource`,
-            path: itemPath,
-            queryContract: "update-query",
-            responseContract: "update-response",
-            summary: `Update one ${variables.title} resource.`,
-            tags: [variables.title],
-            wordpressAuth: {
-                mechanism: "rest-nonce",
-            },
-        });
-    }
-    if (methods.includes("delete")) {
-        contracts["delete-query"] = {
-            sourceTypeName: `${variables.pascalCase}DeleteQuery`,
-        };
-        contracts["delete-response"] = {
-            sourceTypeName: `${variables.pascalCase}DeleteResponse`,
-        };
-        endpoints.push({
-            auth: "authenticated",
-            method: "DELETE",
-            operationId: `delete${variables.pascalCase}Resource`,
-            path: itemPath,
-            queryContract: "delete-query",
-            responseContract: "delete-response",
-            summary: `Delete one ${variables.title} resource.`,
-            tags: [variables.title],
-            wordpressAuth: {
-                mechanism: "rest-nonce",
-            },
-        });
-    }
-    return defineEndpointManifest({
-        contracts,
-        endpoints,
-        info: {
-            title: `${variables.title} REST API`,
-            version: "1.0.0",
-        },
-    });
-}
-/**
- * Build the endpoint manifest for a type-only manual REST contract. Manual
- * contracts describe routes owned by another integration without generating PHP
- * route glue in the workspace.
- *
- * @param variables Template naming data used for contract names, route path,
- * and OpenAPI info.
- * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
- */
-export function buildManualRestContractEndpointManifest(variables) {
-    const contracts = {
-        query: {
-            sourceTypeName: variables.queryTypeName,
-        },
-        response: {
-            sourceTypeName: variables.responseTypeName,
-        },
-    };
-    if (variables.bodyTypeName) {
-        contracts.request = {
-            sourceTypeName: variables.bodyTypeName,
-        };
-    }
-    const wordpressAuth = resolveManualRestContractWordPressAuth(variables.auth);
-    return defineEndpointManifest({
-        contracts,
-        endpoints: [
-            {
-                auth: variables.auth,
-                ...(variables.bodyTypeName ? { bodyContract: "request" } : {}),
-                method: variables.method,
-                operationId: `call${variables.pascalCase}ManualRestContract`,
-                path: `/${variables.namespace}${variables.pathPattern}`,
-                queryContract: "query",
-                responseContract: "response",
-                summary: `Call external ${variables.title} REST route.`,
-                tags: [variables.title],
-                ...(wordpressAuth ? { wordpressAuth } : {}),
-            },
-        ],
-        info: {
-            title: `${variables.title} Manual REST Contract`,
-            version: "1.0.0",
-        },
-    });
-}
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for
- * a workspace-level REST resource scaffold.
- *
- * @param options Resource file paths, enabled methods, and naming variables.
- * @returns A promise that resolves after every generated REST artifact has been refreshed.
- */
-export async function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
-    const manifest = buildRestResourceEndpointManifest(variables, methods);
-    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
-        await syncTypeSchemas({
-            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
-            projectRoot: projectDir,
-            sourceTypeName: contract.sourceTypeName,
-            typesFile,
-        });
-    }
-    await syncRestOpenApi({
-        manifest,
-        openApiFile: path.join(outputDir, "api.openapi.json"),
-        projectRoot: projectDir,
-        typesFile,
-    });
-    await syncEndpointClient({
-        clientFile,
-        manifest,
-        projectRoot: projectDir,
-        typesFile,
-        validatorsFile,
-    });
-}
-/**
- * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
- * type-only manual REST contract.
- *
- * @param options Contract file paths and naming variables.
- * @returns A promise that resolves after every generated artifact has refreshed.
- */
-export async function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
-    const manifest = buildManualRestContractEndpointManifest(variables);
-    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
-        await syncTypeSchemas({
-            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
-            projectRoot: projectDir,
-            sourceTypeName: contract.sourceTypeName,
-            typesFile,
-        });
-    }
-    await syncRestOpenApi({
-        manifest,
-        openApiFile: path.join(outputDir, "api.openapi.json"),
-        projectRoot: projectDir,
-        typesFile,
-    });
-    await syncEndpointClient({
-        clientFile,
-        manifest,
-        projectRoot: projectDir,
-        typesFile,
-        validatorsFile,
-    });
-}
+export * from "./add/rest-resource-artifacts.js";

package/dist/runtime/scaffold-answer-resolution.d.ts

@@ -1,37 +1 @@
-import type { PackageManagerId } from './package-managers.js';
-import type { CollectScaffoldAnswersOptions, ResolvePackageManagerOptions, ResolveTemplateOptions, ScaffoldAnswers } from './scaffold.js';
-/**
- * Detect the current author name from local Git config.
- *
- * @returns The configured Git author name, or `"Your Name"` when unavailable.
- */
-export declare function detectAuthor(): string;
-/**
- * Compute the default scaffold answers for one project and template pair.
- *
- * @param projectName User-supplied project directory or block name seed.
- * @param templateId Selected scaffold template identifier.
- * @returns Normalized default answers for scaffold prompts and non-interactive flows.
- */
-export declare function getDefaultAnswers(projectName: string, templateId: string): ScaffoldAnswers;
-/**
- * Resolve the scaffold template id from flags, defaults, and interactive selection.
- *
- * @param options Template resolution options for interactive and non-interactive flows.
- * @returns The normalized template identifier to scaffold.
- */
-export declare function resolveTemplateId({ templateId, yes, isInteractive, selectTemplate, }: ResolveTemplateOptions): Promise<string>;
-/**
- * Resolve the package manager id from flags, defaults, and interactive selection.
- *
- * @param options Package manager resolution options for interactive and non-interactive flows.
- * @returns The normalized package manager id.
- */
-export declare function resolvePackageManagerId({ packageManager, yes, isInteractive, selectPackageManager, }: ResolvePackageManagerOptions): Promise<PackageManagerId>;
-/**
- * Collect scaffold answers from defaults, CLI overrides, and optional prompts.
- *
- * @param options Answer collection inputs including prompt callbacks and explicit overrides.
- * @returns The normalized scaffold answers used for rendering and file generation.
- */
-export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;
+export * from "./templates/scaffold-answer-resolution.js";

package/dist/runtime/scaffold-answer-resolution.js

@@ -1,155 +1 @@
-import { execSync } from 'node:child_process';
-import { PACKAGE_MANAGER_IDS, getPackageManager, } from './package-managers.js';
-import { normalizeBlockSlug, resolveScaffoldIdentifiers, validateBlockSlug, validateNamespace, } from './scaffold-identifiers.js';
-import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
-import { getTemplateById, isBuiltInTemplateId, } from './template-registry.js';
-import { CREATE_TEMPLATE_SELECTION_HINT, validateExplicitCreateTemplateId, } from './create-template-validation.js';
-import { toSnakeCase, toTitleCase, } from './string-case.js';
-const QUERY_POST_TYPE_RULE = 'Use lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".';
-/**
- * Detect the current author name from local Git config.
- *
- * @returns The configured Git author name, or `"Your Name"` when unavailable.
- */
-export function detectAuthor() {
-    try {
-        return (execSync('git config user.name', {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim() || 'Your Name');
-    }
-    catch {
-        return 'Your Name';
-    }
-}
-/**
- * Compute the default scaffold answers for one project and template pair.
- *
- * @param projectName User-supplied project directory or block name seed.
- * @param templateId Selected scaffold template identifier.
- * @returns Normalized default answers for scaffold prompts and non-interactive flows.
- */
-export function getDefaultAnswers(projectName, templateId) {
-    const template = isBuiltInTemplateId(templateId) ? getTemplateById(templateId) : null;
-    const slugDefault = normalizeBlockSlug(projectName) || 'my-wp-typia-block';
-    return {
-        author: detectAuthor(),
-        dataStorageMode: templateId === 'persistence' ? 'custom-table' : undefined,
-        description: template?.description ?? 'A WordPress block scaffolded from a remote template',
-        namespace: slugDefault,
-        persistencePolicy: templateId === 'persistence' ? 'authenticated' : undefined,
-        phpPrefix: toSnakeCase(slugDefault),
-        queryPostType: templateId === 'query-loop' ? 'post' : undefined,
-        slug: slugDefault,
-        textDomain: slugDefault,
-        title: toTitleCase(slugDefault),
-    };
-}
-function validateQueryPostType(value) {
-    const rawValue = value.trim();
-    const normalizedValue = rawValue.toLowerCase();
-    if (normalizedValue.length === 0) {
-        return 'Query post type is required.';
-    }
-    if (!/^[a-z0-9_-]{1,20}$/u.test(normalizedValue)) {
-        return rawValue === normalizedValue
-            ? `Query post type "${rawValue}" is invalid. ${QUERY_POST_TYPE_RULE}`
-            : `Query post type "${rawValue}" normalizes to "${normalizedValue}", which is invalid. ${QUERY_POST_TYPE_RULE}`;
-    }
-    return true;
-}
-function normalizeQueryPostType(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const validationResult = validateQueryPostType(value);
-    if (validationResult !== true) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, validationResult);
-    }
-    return value.trim().toLowerCase();
-}
-/**
- * Resolve the scaffold template id from flags, defaults, and interactive selection.
- *
- * @param options Template resolution options for interactive and non-interactive flows.
- * @returns The normalized template identifier to scaffold.
- */
-export async function resolveTemplateId({ templateId, yes = false, isInteractive = false, selectTemplate, }) {
-    if (templateId) {
-        return validateExplicitCreateTemplateId(templateId);
-    }
-    if (yes) {
-        return 'basic';
-    }
-    if (!isInteractive || !selectTemplate) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Template is required in non-interactive mode. Use ${CREATE_TEMPLATE_SELECTION_HINT}.`);
-    }
-    return validateExplicitCreateTemplateId(await selectTemplate());
-}
-/**
- * Resolve the package manager id from flags, defaults, and interactive selection.
- *
- * @param options Package manager resolution options for interactive and non-interactive flows.
- * @returns The normalized package manager id.
- */
-export async function resolvePackageManagerId({ packageManager, yes = false, isInteractive = false, selectPackageManager, }) {
-    if (packageManager) {
-        return getPackageManager(packageManager).id;
-    }
-    if (yes) {
-        return 'npm';
-    }
-    if (!isInteractive || !selectPackageManager) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join('|')}>.`);
-    }
-    return selectPackageManager();
-}
-/**
- * Collect scaffold answers from defaults, CLI overrides, and optional prompts.
- *
- * @param options Answer collection inputs including prompt callbacks and explicit overrides.
- * @returns The normalized scaffold answers used for rendering and file generation.
- */
-export async function collectScaffoldAnswers({ projectName, templateId, yes = false, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }) {
-    const defaults = getDefaultAnswers(projectName, templateId);
-    if (yes || (!isBuiltInTemplateId(templateId) && !promptText)) {
-        const identifiers = resolveScaffoldIdentifiers({
-            namespace: namespace ?? defaults.namespace,
-            phpPrefix,
-            slug: defaults.slug,
-            textDomain,
-        });
-        return {
-            ...defaults,
-            dataStorageMode: dataStorageMode ?? defaults.dataStorageMode,
-            namespace: identifiers.namespace,
-            persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
-            phpPrefix: identifiers.phpPrefix,
-            queryPostType: normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
-            textDomain: identifiers.textDomain,
-        };
-    }
-    if (!promptText) {
-        throw new Error('Interactive answers require a promptText callback.');
-    }
-    const identifiers = resolveScaffoldIdentifiers({
-        namespace: namespace ?? (await promptText('Namespace', defaults.namespace, validateNamespace)),
-        phpPrefix,
-        slug: await promptText('Block slug', defaults.slug, validateBlockSlug),
-        textDomain,
-    });
-    return {
-        author: await promptText('Author', defaults.author),
-        dataStorageMode: dataStorageMode ?? defaults.dataStorageMode,
-        description: await promptText('Description', defaults.description),
-        namespace: identifiers.namespace,
-        persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
-        phpPrefix: identifiers.phpPrefix,
-        queryPostType: templateId === 'query-loop'
-            ? normalizeQueryPostType(await promptText('Query post type', queryPostType ?? defaults.queryPostType ?? 'post', validateQueryPostType))
-            : normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
-        slug: identifiers.slug,
-        textDomain: identifiers.textDomain,
-        title: await promptText('Block title', toTitleCase(identifiers.slug)),
-    };
-}
+export * from "./templates/scaffold-answer-resolution.js";