@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/templates/cli-scaffold.js

@@ -0,0 +1,194 @@
+import path from "node:path";
+import { collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, resolveCreateProfileId, isPersistencePolicy, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+import { parseCompoundInnerBlocksPreset } from "../add/compound-inner-blocks.js";
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
+import { buildScaffoldDryRunPlan, emitScaffoldProject, } from "./cli-scaffold-emission.js";
+import { readGeneratedPackageScripts } from "./cli-scaffold-files.js";
+import { getNextSteps, getOptionalOnboarding, } from "./cli-scaffold-output.js";
+import { collectProjectDirectoryWarnings, collectTemplateCapabilityWarnings, resolveOptionalBooleanFlag, resolveOptionalSelection, templateUsesPersistenceSettings, validateCreateFlagContract, validateCreateProjectInput, } from "./cli-scaffold-validation.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./template-registry.js";
+import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
+import { resolveLocalCliPathOption, normalizeOptionalCliString, } from "../cli/cli-validation.js";
+export { getNextSteps, getOptionalOnboarding } from "./cli-scaffold-output.js";
+/**
+ * Resolve scaffold options, prompts, and follow-up steps for one CLI run.
+ *
+ * @param options CLI/runtime inputs used to collect answers and scaffold a
+ * project.
+ * @returns The scaffold result together with next-step guidance.
+ */
+export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, alternateRenderTargets, dataStorageMode, dryRun = false, externalLayerId, externalLayerSource, innerBlocksPreset, persistencePolicy, packageManager, namespace, profile, textDomain, phpPrefix, queryPostType, yes = false, noInstall = false, onProgress, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
+    const normalizedExternalLayerId = normalizeOptionalCliString(externalLayerId);
+    const normalizedExternalLayerSource = resolveLocalCliPathOption({
+        cwd,
+        label: "--external-layer-source",
+        value: externalLayerSource,
+    });
+    validateCreateProjectInput(projectInput);
+    const resolvedTemplateId = await resolveTemplateId({
+        templateId,
+        yes,
+        isInteractive,
+        selectTemplate,
+    });
+    const resolvedProfile = resolveCreateProfileId(profile);
+    validateCreateFlagContract({
+        alternateRenderTargets,
+        dataStorageMode,
+        innerBlocksPreset,
+        persistencePolicy,
+        templateId: resolvedTemplateId,
+        variant,
+    });
+    const resolvedInnerBlocksPreset = parseCompoundInnerBlocksPreset(innerBlocksPreset);
+    const resolvedExternalLayerSelection = isBuiltInTemplateId(resolvedTemplateId) && isInteractive
+        ? await resolveOptionalInteractiveExternalLayerId({
+            callerCwd: cwd,
+            externalLayerId: normalizedExternalLayerId,
+            externalLayerSource: normalizedExternalLayerSource,
+            selectExternalLayerId,
+        })
+        : {
+            externalLayerId: normalizedExternalLayerId,
+            externalLayerSource: normalizedExternalLayerSource,
+        };
+    try {
+        const shouldResolvePersistence = templateUsesPersistenceSettings(resolvedTemplateId, {
+            dataStorageMode,
+            persistencePolicy,
+        });
+        const resolvedDataStorage = await resolveOptionalSelection({
+            allowedValues: DATA_STORAGE_MODES,
+            defaultValue: "custom-table",
+            explicitValue: dataStorageMode,
+            isInteractive,
+            isValue: isDataStorageMode,
+            label: "data storage mode",
+            select: selectDataStorage,
+            shouldResolve: shouldResolvePersistence,
+            yes,
+        });
+        const resolvedPersistencePolicy = await resolveOptionalSelection({
+            allowedValues: PERSISTENCE_POLICIES,
+            defaultValue: "authenticated",
+            explicitValue: persistencePolicy,
+            isInteractive,
+            isValue: isPersistencePolicy,
+            label: "persistence policy",
+            select: selectPersistencePolicy,
+            shouldResolve: shouldResolvePersistence,
+            yes,
+        });
+        const resolvedPackageManager = await resolvePackageManagerId({
+            packageManager,
+            yes,
+            isInteractive,
+            selectPackageManager,
+        });
+        const resolvedWithWpEnv = resolvedProfile === "plugin-qa"
+            ? true
+            : await resolveOptionalBooleanFlag({
+                explicitValue: withWpEnv,
+                isInteractive,
+                select: selectWithWpEnv,
+                yes,
+            });
+        const resolvedWithTestPreset = await resolveOptionalBooleanFlag({
+            explicitValue: withTestPreset,
+            isInteractive,
+            select: selectWithTestPreset,
+            yes,
+        });
+        const resolvedWithMigrationUi = await resolveOptionalBooleanFlag({
+            disabled: !isBuiltInTemplateId(resolvedTemplateId) &&
+                resolvedTemplateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
+            explicitValue: withMigrationUi,
+            isInteractive,
+            select: selectWithMigrationUi,
+            yes,
+        });
+        const projectDir = path.resolve(cwd, projectInput);
+        const projectName = path.basename(projectDir);
+        const answers = await collectScaffoldAnswers({
+            dataStorageMode: resolvedDataStorage,
+            namespace,
+            persistencePolicy: resolvedPersistencePolicy,
+            phpPrefix,
+            projectName,
+            queryPostType,
+            templateId: resolvedTemplateId,
+            textDomain,
+            yes,
+            promptText,
+        });
+        if (resolvedTemplateId === "compound" && resolvedInnerBlocksPreset) {
+            answers.compoundInnerBlocksPreset = resolvedInnerBlocksPreset;
+        }
+        const emissionOptions = {
+            allowExistingDir,
+            alternateRenderTargets,
+            answers,
+            cwd,
+            dataStorageMode: resolvedDataStorage,
+            externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+            externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+            externalLayerSourceLabel: normalizedExternalLayerSource,
+            installDependencies,
+            noInstall,
+            onProgress,
+            packageManager: resolvedPackageManager,
+            persistencePolicy: resolvedPersistencePolicy,
+            profile: resolvedProfile,
+            projectDir,
+            templateId: resolvedTemplateId,
+            variant,
+            withMigrationUi: resolvedWithMigrationUi,
+            withTestPreset: resolvedWithTestPreset,
+            withWpEnv: resolvedWithWpEnv,
+        };
+        const resolvedResult = dryRun
+            ? await buildScaffoldDryRunPlan(emissionOptions)
+            : {
+                plan: undefined,
+                result: await emitScaffoldProject(emissionOptions),
+            };
+        const availableScripts = dryRun
+            ? undefined
+            : await readGeneratedPackageScripts(projectDir);
+        return {
+            dryRun,
+            optionalOnboarding: getOptionalOnboarding({
+                availableScripts,
+                packageManager: resolvedPackageManager,
+                templateId: resolvedTemplateId,
+                compoundPersistenceEnabled: isCompoundPersistenceEnabled(resolvedResult.result.variables),
+            }),
+            plan: resolvedResult.plan,
+            projectDir,
+            projectInput,
+            packageManager: resolvedPackageManager,
+            nextSteps: getNextSteps({
+                projectInput,
+                projectDir,
+                packageManager: resolvedPackageManager,
+                noInstall,
+                templateId: resolvedTemplateId,
+            }),
+            result: {
+                ...resolvedResult.result,
+                warnings: [
+                    ...resolvedResult.result.warnings,
+                    ...collectTemplateCapabilityWarnings({
+                        queryPostType,
+                        templateId: resolvedTemplateId,
+                        withMigrationUi,
+                    }),
+                    ...collectProjectDirectoryWarnings(projectDir),
+                ],
+            },
+        };
+    }
+    finally {
+        await resolvedExternalLayerSelection.cleanup?.();
+    }
+}

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

@@ -0,0 +1,30 @@
+import { getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates } from "./template-registry.js";
+import type { TemplateDefinition } from "./template-registry.js";
+/**
+ * Format one line of template list output for a built-in template.
+ *
+ * @param template Template metadata including `id` and `description`.
+ * @returns One-line summary text for `templates list`.
+ */
+export declare function formatTemplateSummary(template: TemplateDefinition): string;
+/**
+ * Format the feature and capability hint lines shown under a template summary.
+ *
+ * @param template Template metadata including the `features` list.
+ * @returns Indented feature and capability text for CLI list output.
+ */
+export declare function formatTemplateFeatures(template: TemplateDefinition): string;
+/**
+ * Format the detailed template description for `templates inspect`.
+ *
+ * This expands special layer combinations for the `persistence` and `compound`
+ * templates and returns a multi-line block centered on human-facing identity,
+ * capabilities, and logical layer composition.
+ *
+ * @param template Template metadata including `id`, `defaultCategory`,
+ * `templateDir`, and `features`.
+ * @returns Multi-line template details text for CLI output.
+ */
+export declare function formatTemplateDetails(template: TemplateDefinition): string;
+export { getTemplateById, getTemplateSelectOptions, listTemplates };
+export { isBuiltInTemplateId };

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

@@ -0,0 +1,166 @@
+import { OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, getUserFacingTemplateId, getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates, } from "./template-registry.js";
+/**
+ * Format one line of template list output for a built-in template.
+ *
+ * @param template Template metadata including `id` and `description`.
+ * @returns One-line summary text for `templates list`.
+ */
+export function formatTemplateSummary(template) {
+    return `${getUserFacingTemplateId(template.id).padEnd(14)} ${template.description}`;
+}
+/**
+ * Format the feature and capability hint lines shown under a template summary.
+ *
+ * @param template Template metadata including the `features` list.
+ * @returns Indented feature and capability text for CLI list output.
+ */
+export function formatTemplateFeatures(template) {
+    const lines = [`  Features: ${template.features.join(" • ")}`];
+    const bestForHint = getTemplateBestForHint(template);
+    if (bestForHint) {
+        lines.push(`  Best for: ${bestForHint}`);
+    }
+    const capabilityHints = getTemplateCapabilityHints(template);
+    if (capabilityHints.length > 0) {
+        lines.push(`  Supports: ${capabilityHints.join(" • ")}`);
+    }
+    const specialNotes = getTemplateSpecialNotes(template);
+    if (specialNotes.length > 0) {
+        lines.push(`  Notes: ${specialNotes.join(" • ")}`);
+    }
+    if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        lines.push(`  Alias: ${OFFICIAL_WORKSPACE_TEMPLATE_ALIAS} (\`--template ${OFFICIAL_WORKSPACE_TEMPLATE_ALIAS}\`)`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format the detailed template description for `templates inspect`.
+ *
+ * This expands special layer combinations for the `persistence` and `compound`
+ * templates and returns a multi-line block centered on human-facing identity,
+ * capabilities, and logical layer composition.
+ *
+ * @param template Template metadata including `id`, `defaultCategory`,
+ * `templateDir`, and `features`.
+ * @returns Multi-line template details text for CLI output.
+ */
+export function formatTemplateDetails(template) {
+    const detailLines = [
+        getUserFacingTemplateId(template.id),
+        `Summary: ${template.description}`,
+        `Best for: ${getTemplateBestForHint(template)}`,
+        ...getTemplateIdentityLines(template),
+        `Category: ${template.defaultCategory}`,
+    ];
+    const capabilityHints = getTemplateCapabilityHints(template);
+    if (capabilityHints.length > 0) {
+        detailLines.push("Capabilities:");
+        for (const capabilityHint of capabilityHints) {
+            detailLines.push(`  - ${capabilityHint}`);
+        }
+    }
+    const specialNotes = getTemplateSpecialNotes(template);
+    if (specialNotes.length > 0) {
+        detailLines.push("Notes:");
+        for (const specialNote of specialNotes) {
+            detailLines.push(`  - ${specialNote}`);
+        }
+    }
+    detailLines.push("Logical layers:");
+    for (const logicalLayer of getTemplateLogicalLayerSummaries(template)) {
+        detailLines.push(`  - ${logicalLayer}`);
+    }
+    detailLines.push(`Features: ${template.features.join(", ")}`);
+    return detailLines.join("\n");
+}
+function getTemplateBestForHint(template) {
+    if (template.id === "basic") {
+        return "minimal static-first block scaffolds with Typia validation and the lightest default surface";
+    }
+    if (template.id === "interactivity") {
+        return "interactive single-block experiences that keep client-side state and actions inside one scaffold";
+    }
+    if (template.id === "persistence") {
+        return "typed REST-backed blocks that need persistence-aware reads, writes, and schema refresh workflows";
+    }
+    if (template.id === "compound") {
+        return "parent-and-child block families that own nested authoring conventions and optional persistence wiring";
+    }
+    if (template.id === "query-loop") {
+        return "create-time `core/query` variations with connected starter patterns instead of `add block` families";
+    }
+    return "official multi-block workspaces that extend through `wp-typia add ...` and workspace doctor flows";
+}
+function getTemplateCapabilityHints(template) {
+    if (template.id === "persistence" || template.id === "compound") {
+        return [
+            "--alternate-render-targets",
+            "--data-storage",
+            "--persistence-policy",
+            "external layers",
+        ];
+    }
+    if (template.id === "query-loop") {
+        return ["--query-post-type", "external layers"];
+    }
+    if (isBuiltInTemplateId(template.id)) {
+        return ["external layers"];
+    }
+    return [];
+}
+function getTemplateSpecialNotes(template) {
+    if (template.id === "query-loop") {
+        return [
+            "Create-time variation scaffold only; use `wp-typia create <project-dir> --template query-loop` instead of `wp-typia add block`.",
+            "Owns a `core/query` variation, so it does not generate `src/types.ts`, `block.json`, or Typia manifests.",
+        ];
+    }
+    return [];
+}
+function getTemplateIdentityLines(template) {
+    if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        return [
+            "Identity:",
+            `  - User-facing alias: ${OFFICIAL_WORKSPACE_TEMPLATE_ALIAS} (\`--template ${OFFICIAL_WORKSPACE_TEMPLATE_ALIAS}\`)`,
+            `  - Official package: ${OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE}`,
+            "Type: official workspace scaffold",
+        ];
+    }
+    if (template.id === "query-loop") {
+        return [
+            "Identity:",
+            "  - Built-in template id: query-loop",
+            "Type: create-time core/query variation scaffold",
+            "Output model: variation-only scaffold; does not generate block.json or Typia manifests",
+        ];
+    }
+    return [
+        "Identity:",
+        `  - Built-in template id: ${template.id}`,
+        "Type: built-in block scaffold",
+    ];
+}
+function getTemplateLogicalLayerSummaries(template) {
+    if (!isBuiltInTemplateId(template.id)) {
+        return ["workspace package scaffold"];
+    }
+    if (template.id === "persistence") {
+        return [
+            "authenticated write policy: shared/base -> rest helpers (shared) -> persistence core -> authenticated write policy -> persistence overlay",
+            "public write policy: shared/base -> rest helpers (shared) -> persistence core -> public write policy -> persistence overlay",
+        ];
+    }
+    if (template.id === "compound") {
+        return [
+            "pure block family: shared/base -> compound core -> compound overlay",
+            "authenticated persistence: shared/base -> compound core -> rest helpers (shared) -> compound persistence core -> authenticated write policy -> compound overlay",
+            "public persistence: shared/base -> compound core -> rest helpers (shared) -> compound persistence core -> public write policy -> compound overlay",
+        ];
+    }
+    const overlayName = template.id === "query-loop" ? "query-loop overlay" : `${template.id} overlay`;
+    return [
+        `shared/base -> ${overlayName}`,
+    ];
+}
+export { getTemplateById, getTemplateSelectOptions, listTemplates };
+export { isBuiltInTemplateId };

package/dist/runtime/templates/create-template-validation.d.ts

@@ -0,0 +1,10 @@
+export declare const CREATE_TEMPLATE_SELECTION_HINT: string;
+/**
+ * Validate an explicitly supplied create template id before entering the full
+ * scaffold flow.
+ *
+ * Built-in template ids and the workspace alias resolve immediately, common
+ * built-in typos keep suggestion diagnostics, and explicit external template
+ * locators remain deferred to the external template resolver.
+ */
+export declare function validateExplicitCreateTemplateId(templateId: string): string;

package/dist/runtime/templates/create-template-validation.js

@@ -0,0 +1,95 @@
+import path from "node:path";
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "../cli/cli-diagnostics.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, TEMPLATE_IDS, getTemplateById, isBuiltInTemplateId, } from "./template-registry.js";
+import { getRemovedBuiltInTemplateMessage, isRemovedBuiltInTemplateId, } from "./template-defaults.js";
+import { parseNpmTemplateLocator } from "./template-source-locators.js";
+import { suggestCloseId } from "../shared/id-suggestions.js";
+export const CREATE_TEMPLATE_SELECTION_HINT = `--template <${[
+    ...TEMPLATE_IDS,
+    OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
+].join("|")}|./path|github:owner/repo/path[#ref]|npm-package>`;
+const TEMPLATE_SUGGESTION_IDS = [
+    ...TEMPLATE_IDS,
+    OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
+];
+const USER_FACING_TEMPLATE_IDS = [
+    ...TEMPLATE_IDS,
+    OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
+];
+function normalizeCreateTemplateSelection(templateId) {
+    return templateId === OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+        ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
+        : templateId;
+}
+function looksLikeWindowsAbsoluteTemplatePath(templateId) {
+    return /^[a-z]:[\\/]/iu.test(templateId) || /^\\\\[^\\]+\\[^\\]+/u.test(templateId);
+}
+function looksLikeExplicitNonNpmExternalTemplateLocator(templateId) {
+    return (path.isAbsolute(templateId) ||
+        looksLikeWindowsAbsoluteTemplatePath(templateId) ||
+        templateId.startsWith("./") ||
+        templateId.startsWith(".\\") ||
+        templateId.startsWith("../") ||
+        templateId.startsWith("..\\") ||
+        templateId.startsWith("@") ||
+        templateId.startsWith("github:") ||
+        templateId.includes("/") ||
+        templateId.includes("\\"));
+}
+function looksLikeExplicitCreateExternalTemplateLocator(templateId) {
+    return (looksLikeExplicitNonNpmExternalTemplateLocator(templateId) ||
+        parseNpmTemplateLocator(templateId) !== null);
+}
+function findMistypedBuiltInTemplateSuggestion(templateId) {
+    const normalizedTemplateId = templateId.trim().toLowerCase();
+    if (normalizedTemplateId.length === 0 ||
+        looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
+        return null;
+    }
+    return suggestCloseId(normalizedTemplateId, TEMPLATE_SUGGESTION_IDS);
+}
+function getMistypedBuiltInTemplateMessage(templateId) {
+    const suggestion = findMistypedBuiltInTemplateSuggestion(templateId);
+    if (!suggestion) {
+        return null;
+    }
+    const suggestionDescription = suggestion === OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+        ? "official workspace scaffold"
+        : "built-in scaffold";
+    return `Unknown template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\` for the ${suggestionDescription}, or pass a local path, \`github:owner/repo/path[#ref]\`, or an npm package spec for an external template.`;
+}
+function getUnknownTemplateMessage(templateId) {
+    return [
+        `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(", ")}.`,
+        "Run `wp-typia templates list` to inspect available templates.",
+        "Pass an explicit external template locator such as `./path`, `github:owner/repo/path[#ref]`, or `@scope/template` for custom templates.",
+    ].join(" ");
+}
+/**
+ * Validate an explicitly supplied create template id before entering the full
+ * scaffold flow.
+ *
+ * Built-in template ids and the workspace alias resolve immediately, common
+ * built-in typos keep suggestion diagnostics, and explicit external template
+ * locators remain deferred to the external template resolver.
+ */
+export function validateExplicitCreateTemplateId(templateId) {
+    const normalizedTemplateId = normalizeCreateTemplateSelection(templateId);
+    if (isRemovedBuiltInTemplateId(templateId)) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getRemovedBuiltInTemplateMessage(templateId));
+    }
+    if (normalizedTemplateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        return normalizedTemplateId;
+    }
+    if (isBuiltInTemplateId(normalizedTemplateId)) {
+        return getTemplateById(normalizedTemplateId).id;
+    }
+    const mistypedBuiltInTemplateMessage = getMistypedBuiltInTemplateMessage(templateId);
+    if (mistypedBuiltInTemplateMessage) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedBuiltInTemplateMessage);
+    }
+    if (!looksLikeExplicitCreateExternalTemplateLocator(normalizedTemplateId)) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownTemplateMessage(templateId));
+    }
+    return normalizedTemplateId;
+}

package/dist/runtime/templates/external-layer-selection.d.ts

@@ -0,0 +1,20 @@
+import { resolveTemplateSeed } from "./template-source.js";
+import { listSelectableExternalTemplateLayers, type SelectableExternalTemplateLayer } from "./template-layers.js";
+export interface ExternalLayerSelectionOption extends SelectableExternalTemplateLayer {
+}
+export interface ResolvedExternalLayerSelection {
+    cleanup?: () => Promise<void>;
+    externalLayerId?: string;
+    externalLayerSource?: string;
+}
+type ResolveExternalTemplateSeed = typeof resolveTemplateSeed;
+type ListExternalTemplateLayers = typeof listSelectableExternalTemplateLayers;
+export declare function resolveOptionalInteractiveExternalLayerId({ callerCwd, externalLayerId, externalLayerSource, listExternalTemplateLayers, resolveExternalTemplateSeed, selectExternalLayerId, }: {
+    callerCwd: string;
+    externalLayerId?: string;
+    externalLayerSource?: string;
+    listExternalTemplateLayers?: ListExternalTemplateLayers;
+    resolveExternalTemplateSeed?: ResolveExternalTemplateSeed;
+    selectExternalLayerId?: (options: ExternalLayerSelectionOption[]) => Promise<string>;
+}): Promise<ResolvedExternalLayerSelection>;
+export {};

package/dist/runtime/templates/external-layer-selection.js

@@ -0,0 +1,34 @@
+import { parseTemplateLocator, resolveTemplateSeed, } from "./template-source.js";
+import { listSelectableExternalTemplateLayers, } from "./template-layers.js";
+export async function resolveOptionalInteractiveExternalLayerId({ callerCwd, externalLayerId, externalLayerSource, listExternalTemplateLayers = listSelectableExternalTemplateLayers, resolveExternalTemplateSeed = resolveTemplateSeed, selectExternalLayerId, }) {
+    if (!externalLayerSource || externalLayerId || !selectExternalLayerId) {
+        return {
+            externalLayerId,
+            externalLayerSource,
+        };
+    }
+    const layerSeed = await resolveExternalTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
+    try {
+        const selectableLayers = await listExternalTemplateLayers(layerSeed.rootDir);
+        if (selectableLayers.length <= 1) {
+            await layerSeed.cleanup?.();
+            return {
+                externalLayerId,
+                externalLayerSource,
+            };
+        }
+        const selectedLayerId = await selectExternalLayerId(selectableLayers);
+        if (selectableLayers.some((layer) => layer.id === selectedLayerId)) {
+            return {
+                cleanup: layerSeed.cleanup,
+                externalLayerId: selectedLayerId,
+                externalLayerSource: layerSeed.rootDir,
+            };
+        }
+        throw new Error(`Unknown external layer "${selectedLayerId}". Expected one of: ${selectableLayers.map((layer) => layer.id).join(", ")}`);
+    }
+    catch (error) {
+        await layerSeed.cleanup?.();
+        throw error;
+    }
+}

package/dist/runtime/templates/external-template-guards.d.ts

@@ -0,0 +1,31 @@
+export declare const TEMPLATE_SOURCE_TIMEOUT_CODE: "template-source-timeout";
+export declare const TEMPLATE_SOURCE_TOO_LARGE_CODE: "template-source-too-large";
+export declare function getExternalTemplateTimeoutMs(): number;
+export declare function getExternalTemplateConfigMaxBytes(): number;
+export declare function getExternalTemplatePackageJsonMaxBytes(): number;
+export declare function getExternalTemplateMetadataMaxBytes(): number;
+export declare function getExternalTemplateTarballMaxBytes(): number;
+export declare function createExternalTemplateTimeoutError(label: string, timeoutMs: number): Error & {
+    code: typeof TEMPLATE_SOURCE_TIMEOUT_CODE;
+};
+export declare function createExternalTemplateTooLargeError(label: string, maxBytes: number): Error & {
+    code: typeof TEMPLATE_SOURCE_TOO_LARGE_CODE;
+};
+export declare function assertExternalTemplateFileSize(filePath: string, options: {
+    label: string;
+    maxBytes: number;
+}): void;
+export declare function withExternalTemplateTimeout<T>(label: string, task: Promise<T> | (() => Promise<T>), timeoutMs?: number): Promise<T>;
+export declare function fetchWithExternalTemplateTimeout(input: string, options: {
+    init?: RequestInit;
+    label: string;
+    timeoutMs?: number;
+}): Promise<Response>;
+export declare function readJsonResponseWithLimit(response: Response, options: {
+    label: string;
+    maxBytes: number;
+}): Promise<Record<string, unknown>>;
+export declare function readBufferResponseWithLimit(response: Response, options: {
+    label: string;
+    maxBytes: number;
+}): Promise<Buffer>;