@ykdz/template 0.0.6 → 0.0.8

package/dist/{src/cli.js → cli.js}

@@ -2,17 +2,23 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
-import { assembleGenerationContext, } from "./generation-context.js";
-import { addPackage } from "./package-addition.js";
-import { planNextStepInstructionsForProjection, } from "./preset-projection.js";
-import { findBuiltInPresetSourceManifestPreset, presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, } from "./preset-source.js";
-import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
-import { renderNewProject } from "./renderer.js";
-import { resolveToolchainVersions, } from "./toolchain-resolution.js";
+import { builtInPresetProjectionSourceRoots, builtInPresets, findBuiltInPresetSourceManifestPreset, loadBuiltInPresetSourceManifest, projectBuiltInPresetSourcePreset, } from "@ykdz/template-builtin-source";
+import { blueprintJsonSchema, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "@ykdz/template-core/declarations";
+import { assembleGenerationContext, } from "@ykdz/template-core/generation-context";
+import { addPackage } from "@ykdz/template-core/package-addition";
+import { planNextStepInstructionsForProjection, } from "@ykdz/template-core/preset-projection";
+import { presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, } from "@ykdz/template-core/preset-source";
+import { blueprintForPresetSourcePreset } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject } from "@ykdz/template-core/renderer";
+import { resolveToolchainVersions, } from "@ykdz/template-core/toolchain-resolution";
 function usage() {
     return [
+        "Project Kit template CLI",
+        "",
         "Usage:",
+        "  template <command> [options]",
+        "",
+        "Commands:",
         "  template init <dir> --preset <name> --yes",
         "  template add package --preset <name> --name <name> [--path <package-path>] [--link-from <package-path>]...",
         "  template presets",
@@ -24,14 +30,14 @@ function usage() {
         "  template blueprint validate <path>",
         "",
         "Options:",
-        "  --preset <name>  Project preset to generate",
-        "  --name <name>    Package name to add",
-        "  --path <path>    Two-segment Package Path to add",
+        "  --preset <name>     Project preset to generate",
+        "  --name <name>       Package name to add",
+        "  --path <path>       Two-segment Package Path to add",
         "  --link-from <path>  Existing consumer Package Path to link from; repeatable",
-        "  --scope <name>   Package scope for workspace package names",
-        "  --yes            Accept defaults for non-interactive generation",
-        "  --dry-run        Print the planned generation without writing files",
-        "  --json           Print machine-readable output",
+        "  --scope <name>      Package scope for workspace package names",
+        "  --yes               Accept defaults for non-interactive generation",
+        "  --dry-run           Print the planned generation without writing files",
+        "  --json              Print machine-readable output",
     ].join("\n");
 }
 function printJson(value) {
@@ -46,7 +52,9 @@ async function readJsonDeclaration(filePath) {
     }
     catch (error) {
         if (error instanceof SyntaxError) {
-            throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+            throw new Error(`Invalid JSON in ${filePath}: ${error.message}`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -56,10 +64,18 @@ function formatValidationIssues(issues) {
         .map((issue) => `  - ${issue.path}: ${issue.message}`)
         .join("\n");
 }
+function formatFieldRows(rows) {
+    const width = Math.max(...rows.map(([label]) => `${label}:`.length));
+    return rows.map(([label, value]) => `  ${`${label}:`.padEnd(width)} ${value}`);
+}
 function formatPresetCatalog() {
     return [
         "Built-in presets",
-        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`),
+        "",
+        ...formatFieldRows(builtInPresets.map((preset) => [
+            preset.name,
+            `${preset.title} (${preset.generation}) - ${preset.description}`,
+        ])),
     ].join("\n");
 }
 function parseInitOptions(args) {
@@ -145,23 +161,29 @@ function blueprintForInit(options) {
     });
 }
 function formatBlueprintSummary(targetDir, blueprint) {
-    const lines = [
-        "Project Blueprint",
-        `  Target: ${targetDir}`,
-        `  Preset: ${blueprint.preset}`,
-        `  Project kind: ${blueprint.projectKind}`,
+    const rows = [
+        ["Target", targetDir],
+        ["Preset", blueprint.preset],
+        ["Project kind", blueprint.projectKind],
     ];
     if (blueprint.packageManager) {
-        lines.push(`  Package manager: ${blueprint.packageManager}`);
-    }
-    if (blueprint.packages) {
-        lines.push("  Packages:");
-        for (const pkg of blueprint.packages) {
-            lines.push(`    - ${pkg.name} (${pkg.path})`);
-        }
+        rows.push(["Package manager", blueprint.packageManager]);
     }
-    lines.push(`  Features: ${blueprint.features.join(", ")}`);
-    return lines.join("\n");
+    return [
+        "Project Blueprint",
+        "",
+        ...formatFieldRows(rows),
+        ...(blueprint.packages
+            ? [
+                "",
+                "  Packages:",
+                ...blueprint.packages.map((pkg) => `    - ${pkg.name} (${pkg.path})`),
+            ]
+            : []),
+        "",
+        "  Features:",
+        ...blueprint.features.map((feature) => `    - ${feature}`),
+    ].join("\n");
 }
 function formatProjectionNextSteps(targetDir, projectionPlan) {
     const steps = planNextStepInstructionsForProjection({
@@ -170,7 +192,11 @@ function formatProjectionNextSteps(targetDir, projectionPlan) {
     });
     return [
         "Next Step Instructions:",
-        ...steps.map((step) => `  ${step.label}: ${step.display}`),
+        "",
+        ...steps.flatMap((step, index) => [
+            `  ${index + 1}. ${step.label}`,
+            `     ${step.display}`,
+        ]),
     ].join("\n");
 }
 function toolchainReport(toolchain) {
@@ -184,9 +210,12 @@ function toolchainReport(toolchain) {
 function formatToolchainReport(toolchain) {
     return [
         "Toolchain Resolution:",
-        `  Source: ${toolchain.source}`,
-        `  Node LTS major: ${toolchain.nodeLtsMajor.value}`,
-        `  Package Manager Pin: ${toolchain.packageManagerPin.value}`,
+        "",
+        ...formatFieldRows([
+            ["Source", toolchain.source],
+            ["Node LTS major", toolchain.nodeLtsMajor.value],
+            ["Package Manager Pin", toolchain.packageManagerPin.value],
+        ]),
         ...toolchain.diagnostics.map((diagnostic) => `  ${diagnostic}`),
     ].join("\n");
 }
@@ -220,7 +249,7 @@ async function generateInitProject(options, generationContext) {
     if (!generationContext) {
         throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
     }
-    const plan = projectPresetSourcePreset({
+    const plan = projectBuiltInPresetSourcePreset({
         preset,
         context: generationContext,
     });
@@ -234,7 +263,7 @@ async function generateInitProject(options, generationContext) {
 function printInitComplete(options, blueprint, generationContext) {
     const preset = findBuiltInPresetSourceManifestPreset(blueprint.preset);
     const projectionPlan = generationContext && preset?.projection
-        ? projectPresetSourcePreset({ preset, context: generationContext })
+        ? projectBuiltInPresetSourcePreset({ preset, context: generationContext })
         : undefined;
     if (!projectionPlan) {
         throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
@@ -256,10 +285,19 @@ function printInitComplete(options, blueprint, generationContext) {
         });
         return;
     }
-    console.log(`Initialized ${options.preset} project in ${options.dir}`);
+    console.log([
+        "Initialized project",
+        "",
+        ...formatFieldRows([
+            ["Preset", options.preset],
+            ["Target", options.dir],
+        ]),
+    ].join("\n"));
     if (generationContext) {
+        console.log("");
         console.log(formatToolchainReport(generationContext.toolchain));
     }
+    console.log("");
     console.log(formatProjectionNextSteps(options.dir, projectionPlan));
 }
 function isInteractiveTerminal() {
@@ -360,7 +398,9 @@ async function main(args) {
         if (!filePath) {
             throw new Error("preset validate requires a path");
         }
-        const result = validatePresetFile(await readJsonDeclaration(filePath));
+        const result = validatePresetFile(await readJsonDeclaration(filePath), {
+            presets: builtInPresets,
+        });
         if (!result.ok) {
             throw new Error(`Preset file is invalid:\n${formatValidationIssues(result.issues)}`);
         }
@@ -398,7 +438,9 @@ async function main(args) {
         if (!filePath) {
             throw new Error("blueprint validate requires a path");
         }
-        const result = validateProjectBlueprint(await readJsonDeclaration(filePath));
+        const result = validateProjectBlueprint(await readJsonDeclaration(filePath), {
+            presets: builtInPresets,
+        });
         if (!result.ok) {
             throw new Error(`Blueprint is invalid:\n${formatValidationIssues(result.issues)}`);
         }
@@ -413,7 +455,10 @@ async function main(args) {
             const preset = findBuiltInPresetSourceManifestPreset(options.preset);
             const projectionPlan = generationContext
                 ? preset?.projection
-                    ? projectPresetSourcePreset({ preset, context: generationContext })
+                    ? projectBuiltInPresetSourcePreset({
+                        preset,
+                        context: generationContext,
+                    })
                     : undefined
                 : undefined;
             if (!projectionPlan) {
@@ -438,8 +483,10 @@ async function main(args) {
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
             if (generationContext) {
+                console.log("");
                 console.log(formatToolchainReport(generationContext.toolchain));
             }
+            console.log("");
             console.log(formatProjectionNextSteps(options.dir, projectionPlan));
             return;
         }
@@ -462,8 +509,18 @@ async function main(args) {
             name: options.name,
             path: options.path,
             linkFrom: options.linkFrom,
+            presetSourceManifest: loadBuiltInPresetSourceManifest(),
+            projectionSourceRoots: builtInPresetProjectionSourceRoots(),
         });
-        console.log(`Added ${options.preset} package ${options.name}`);
+        console.log([
+            "Added package",
+            "",
+            ...formatFieldRows([
+                ["Preset", options.preset],
+                ["Name", options.name],
+                ...(options.path ? [["Path", options.path]] : []),
+            ]),
+        ].join("\n"));
         return;
     }
     if (command === "--help" || command === "-h") {
@@ -474,8 +531,8 @@ async function main(args) {
 }
 main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(message);
+    console.error(`Error: ${message}`);
     console.error("");
-    console.error(usage());
+    console.error("Run `template --help` for usage.");
     process.exitCode = 1;
 });

package/node_modules/@ykdz/template-builtin-source/dist/src/index.d.ts

@@ -0,0 +1,22 @@
+import type { BuiltInPreset } from "@ykdz/template-core/declarations";
+import type { GenerationContext } from "@ykdz/template-core/generation-context";
+import type { PresetPackageAdditionOptions } from "@ykdz/template-core/preset-projection";
+import { type PresetSourceManifest, type PresetSourceManifestPreset } from "@ykdz/template-core/preset-source";
+import { type PresetProjectionSourceRoots, type PresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+export { findPresetSourceManifestPreset, loadPresetSourceManifestFile, manifestReferencedSourceFiles, presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, type PresetSourceManifest, type PresetSourceManifestPreset, } from "@ykdz/template-core/preset-source";
+export declare function builtInPresetSourceRoot(...segments: string[]): string;
+export declare function builtInPresetProjectionSourceRoots(): PresetProjectionSourceRoots;
+export declare function loadBuiltInPresetSourceManifest(): PresetSourceManifest;
+export declare const builtInPresets: readonly BuiltInPreset[];
+export declare function findBuiltInPreset(name: string): BuiltInPreset | undefined;
+export declare function findBuiltInPresetSourceManifestPreset(presetName: string): PresetSourceManifestPreset | undefined;
+export declare function loadBuiltInPresetProjectionDeclaration(presetName: string): PresetProjectionDeclaration;
+export declare function projectBuiltInPresetSourcePreset(options: {
+    readonly preset: PresetSourceManifestPreset;
+    readonly context: GenerationContext;
+}): import("@ykdz/template-core/preset-projection").PresetProjectionPlan;
+export declare function defaultPackagePathForBuiltInPackageAddition(preset: PresetSourceManifestPreset, packageLeafName: string): string;
+export declare function planBuiltInPackageAddition(options: {
+    readonly preset: PresetSourceManifestPreset;
+    readonly addition: PresetPackageAdditionOptions;
+}): Promise<import("@ykdz/template-core/preset-projection").PresetPackageAdditionPlan>;

package/node_modules/@ykdz/template-builtin-source/dist/src/index.js

@@ -0,0 +1,92 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findPresetSourceManifestPreset, validateBuiltInPresetSourceManifest, } from "@ykdz/template-core/preset-source";
+import { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, projectPresetSourcePreset, validateProjectionCapabilities, } from "@ykdz/template-core/projection-capabilities";
+export { findPresetSourceManifestPreset, loadPresetSourceManifestFile, manifestReferencedSourceFiles, presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, } from "@ykdz/template-core/preset-source";
+export function builtInPresetSourceRoot(...segments) {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(moduleDir, "..", "..", "templates", ...segments),
+        path.join(moduleDir, "..", "templates", ...segments),
+        path.join(moduleDir, "..", "..", "..", "template-builtin-source", "templates", ...segments),
+    ];
+    return (candidates.find((candidate) => readPathExists(candidate)) ?? candidates[0]);
+}
+function readPathExists(filePath) {
+    try {
+        readFileSync(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "EISDIR") {
+            return true;
+        }
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return false;
+        }
+        return false;
+    }
+}
+export function builtInPresetProjectionSourceRoots() {
+    return {
+        preset(sourcePreset) {
+            return builtInPresetSourceRoot(sourcePreset);
+        },
+        sharedOxc() {
+            return builtInPresetSourceRoot("shared", "oxc");
+        },
+        sharedDevcontainer() {
+            return builtInPresetSourceRoot("shared", "devcontainer");
+        },
+    };
+}
+export function loadBuiltInPresetSourceManifest() {
+    const filePath = builtInPresetSourceRoot("preset-source.json");
+    const result = validateBuiltInPresetSourceManifest(JSON.parse(readFileSync(filePath, "utf8")), { sourceRoot: path.dirname(filePath) });
+    if (!result.ok) {
+        throw new Error(`Built-in Preset Source Manifest is invalid:\n${result.issues
+            .map((issue) => `  - ${issue.path}: ${issue.message}`)
+            .join("\n")}`);
+    }
+    return result.value;
+}
+export const builtInPresets = loadBuiltInPresetSourceManifest().presets;
+export function findBuiltInPreset(name) {
+    return builtInPresets.find((preset) => preset.name === name);
+}
+export function findBuiltInPresetSourceManifestPreset(presetName) {
+    return findPresetSourceManifestPreset(loadBuiltInPresetSourceManifest(), presetName);
+}
+export function loadBuiltInPresetProjectionDeclaration(presetName) {
+    const preset = findBuiltInPresetSourceManifestPreset(presetName);
+    if (!preset?.projection) {
+        throw new Error(`Built-in Preset ${presetName} must declare a Projection Declaration`);
+    }
+    const result = validateProjectionCapabilities(preset.projection);
+    if (!result.ok) {
+        throw new Error(`Built-in Preset ${presetName} Projection Declaration is invalid:\n${result.issues
+            .map((issue) => `  - ${issue.path}: ${issue.message}`)
+            .join("\n")}`);
+    }
+    return result.value;
+}
+export function projectBuiltInPresetSourcePreset(options) {
+    return projectPresetSourcePreset({
+        ...options,
+        sourceRoots: builtInPresetProjectionSourceRoots(),
+    });
+}
+export function defaultPackagePathForBuiltInPackageAddition(preset, packageLeafName) {
+    return defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName, builtInPresetProjectionSourceRoots());
+}
+export function planBuiltInPackageAddition(options) {
+    return planPresetSourcePackageAddition({
+        ...options,
+        sourceRoots: builtInPresetProjectionSourceRoots(),
+    });
+}

package/node_modules/@ykdz/template-builtin-source/dist/templates/hono-api/projection.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltInPreset, ProjectBlueprint } from "@ykdz/template-core/declarations";
+import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare const honoApiPresetMetadata: BuiltInPreset;
+export declare function honoApiBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectHonoApiPackageScripts(): Record<string, string>;
+export declare const honoApiPresetProjection: PresetProjection;

package/node_modules/@ykdz/template-builtin-source/dist/templates/hono-api/projection.js

@@ -0,0 +1,230 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { packageManifestExposureFields, planPackageLinks, } from "@ykdz/template-core/package-linking";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject, } from "@ykdz/template-core/renderer";
+export const honoApiPresetMetadata = {
+    name: "hono-api",
+    title: "Hono API",
+    description: "Hono Node API workspace with strict TypeScript tooling.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Supported,
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const apiPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+function planHonoApiPackageChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: apiPackageBoundary },
+            { kind: "oxc-lint", owner: apiPackageBoundary },
+            { kind: "typescript-typecheck", owner: apiPackageBoundary },
+            { kind: "build", owner: apiPackageBoundary },
+            { kind: "unit-test", owner: apiPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planHonoApiPackageFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: apiPackageBoundary },
+            { kind: "oxc-lint-fix", owner: apiPackageBoundary },
+        ],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function scopedPackageName(packageScope) {
+    return `@${packageScope}/api`;
+}
+export function honoApiBlueprint(options = { targetDir: process.cwd() }) {
+    const packageScope = packageScopeFromOptions(options);
+    return {
+        schemaVersion: 1,
+        preset: "hono-api",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...honoApiPresetMetadata.features],
+        packages: [{ name: scopedPackageName(packageScope), path: "apps/api" }],
+    };
+}
+export function projectHonoApiPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+        check: renderRootCheckCommand(planHonoApiPackageChecks()),
+        fix: renderFixCommand(planHonoApiPackageFixes()),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
+        start: "node dist/server.js",
+        test: "vitest run",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
+function packageAdditionOperations(packagePath, packageNameValue, nodeVersion) {
+    const packageExposure = planPackageLinks([
+        {
+            name: packageNameValue,
+            path: packagePath,
+            role: "runtime-service",
+            sourcePreset: "hono-api",
+        },
+    ]).exposuresByPackagePath.get(packagePath);
+    if (packageExposure === undefined) {
+        throw new Error(`Missing Package Exposure for ${packagePath}`);
+    }
+    const exposureFields = packageManifestExposureFields(packageExposure);
+    return [
+        {
+            kind: "writeJson",
+            to: `${packagePath}/package.json`,
+            value: {
+                name: packageNameValue,
+                version: "0.0.0",
+                private: true,
+                type: "module",
+                types: exposureFields.types,
+                exports: exposureFields.exports,
+                imports: exposureFields.imports,
+                scripts: projectHonoApiPackageScripts(),
+                dependencies: {
+                    "@hono/node-server": "catalog:",
+                    hono: "catalog:",
+                },
+                devDependencies: {
+                    "@types/node": "catalog:",
+                    oxfmt: "catalog:",
+                    oxlint: "catalog:",
+                    "tsc-alias": "catalog:",
+                    typescript: "catalog:",
+                    vitest: "catalog:",
+                },
+                engines: {
+                    node: nodeVersion,
+                },
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.json`,
+            value: {
+                compilerOptions: {
+                    composite: true,
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    noEmitOnError: true,
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "ES2022",
+                    types: ["node", "vitest/globals"],
+                },
+                include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.build.json`,
+            value: {
+                extends: "./tsconfig.json",
+                compilerOptions: {
+                    outDir: "dist",
+                    rootDir: "src",
+                    types: ["node"],
+                },
+                include: ["src/**/*.ts"],
+            },
+        },
+        { kind: "copyFile", from: "src/app.ts", to: `${packagePath}/src/app.ts` },
+        {
+            kind: "copyFile",
+            from: "src/server.ts",
+            to: `${packagePath}/src/server.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "test/app.test.ts",
+            to: `${packagePath}/test/app.test.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "vitest.config.ts",
+            to: `${packagePath}/vitest.config.ts`,
+        },
+    ];
+}
+function packageAdditionPlan(packageNameValue, packagePath, nodeVersion) {
+    const [workspaceCollection] = packagePath.split("/");
+    return {
+        packagePath,
+        workspacePackageGlob: `${workspaceCollection}/*`,
+        packageRole: "runtime-service",
+        packageSourcePreset: "hono-api",
+        sourceRoot: templateSourceRoot(),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+        operations: packageAdditionOperations(packagePath, packageNameValue, nodeVersion),
+    };
+}
+function templateSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedTemplateRoot = path.join(projectionDir, "..", "..", "..", "templates", "hono-api");
+    return existsSync(path.join(publishedTemplateRoot, "src", "app.ts"))
+        ? publishedTemplateRoot
+        : projectionDir;
+}
+function sharedOxcSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedSharedRoot = path.join(projectionDir, "..", "..", "..", "templates", "shared", "oxc");
+    return existsSync(path.join(publishedSharedRoot, "oxfmt.config.ts"))
+        ? publishedSharedRoot
+        : path.join(projectionDir, "..", "shared", "oxc");
+}
+export const honoApiPresetProjection = {
+    metadata: honoApiPresetMetadata,
+    capabilities: {
+        packageAddition: {
+            planPackageAddition({ packageName, packagePath, nodeVersion, }) {
+                return packageAdditionPlan(packageName, packagePath, nodeVersion);
+            },
+        },
+    },
+    blueprint: honoApiBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: honoApiPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("hono-api"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/dist/templates/projection-plans.d.ts

@@ -0,0 +1,7 @@
+import type { CheckComponent, CheckPlan, FixComponent, FixPlan } from "@ykdz/template-core/module-graph";
+export type NodeCheckPlanTarget = "hono-api" | "vue-app" | "vue-hono-root" | "vue-hono-api" | "vue-hono-web";
+export type NodeFixPlanTarget = "hono-api" | "vue-app" | "vue-hono-root" | "vue-hono-api" | "vue-hono-web";
+export declare function selectNodeCheckComponents(target: NodeCheckPlanTarget): CheckComponent[];
+export declare function selectNodeFixComponents(target: NodeFixPlanTarget): FixComponent[];
+export declare function planNodeChecks(target: NodeCheckPlanTarget): CheckPlan;
+export declare function planNodeFixes(target: NodeFixPlanTarget): FixPlan;