@ykdz/template 0.0.1 → 0.0.3

package/dist/src/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

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

@@ -2,14 +2,12 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { initHonoApiProject } from "./hono-api.js";
-import { initRustBinProject } from "./rust-bin.js";
-import { initTsLibProject } from "./ts-lib.js";
-import { initVueHonoAppProject } from "./vue-hono-app.js";
-import { initVueAppProject } from "./vue-app.js";
+import { findBuiltInPresetProjection, projectPresetThroughRegistry, } from "../templates/registry.js";
+import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
+import { assembleGenerationContext, } from "./generation-context.js";
 import { addPackage } from "./package-addition.js";
-import { planPostCommands, runPostCommands } from "./post-commands.js";
-import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint } from "./declarations.js";
+import { planNextStepInstructionsForProjection, } from "./preset-projection.js";
+import { resolveToolchainVersions, } from "./toolchain-resolution.js";
 function usage() {
     return [
         "Usage:",
@@ -26,9 +24,8 @@ function usage() {
         "  --name <name>    Package name to add",
         "  --scope <name>   Package scope for workspace package names",
         "  --yes            Accept defaults for non-interactive generation",
-        "  --ready          Run template-maintained Post Commands after writing files",
         "  --dry-run        Print the planned generation without writing files",
-        "  --json           Print machine-readable output"
+        "  --json           Print machine-readable output",
     ].join("\n");
 }
 function printJson(value) {
@@ -49,12 +46,14 @@ async function readJsonDeclaration(filePath) {
     }
 }
 function formatValidationIssues(issues) {
-    return issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n");
+    return issues
+        .map((issue) => `  - ${issue.path}: ${issue.message}`)
+        .join("\n");
 }
 function formatPresetCatalog() {
     return [
         "Built-in presets",
-        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`)
+        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`),
     ].join("\n");
 }
 function parseInitOptions(args) {
@@ -63,7 +62,6 @@ function parseInitOptions(args) {
     let yes = false;
     let dryRun = false;
     let json = false;
-    let ready = false;
     let scope;
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
@@ -75,10 +73,6 @@ function parseInitOptions(args) {
             dryRun = true;
             continue;
         }
-        if (arg === "--ready") {
-            ready = true;
-            continue;
-        }
         if (arg === "--json") {
             json = true;
             continue;
@@ -106,7 +100,7 @@ function parseInitOptions(args) {
     if (!dir) {
         throw new Error("init requires a target directory");
     }
-    return { dir, preset, yes, dryRun, json, ready, scope };
+    return { dir, preset, yes, dryRun, json, scope };
 }
 function normalizeNpmScope(value) {
     if (value !== value.trim() || /\s/.test(value)) {
@@ -121,35 +115,40 @@ function normalizeNpmScope(value) {
 function supportedPreset(name) {
     const preset = builtInPresets.find((candidate) => candidate.name === name && candidate.generation === "supported");
     if (!preset) {
-        throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+        throw new Error(formatSupportedPresetError());
     }
     return preset;
 }
-function projectNameFromDir(targetDir) {
-    return path.basename(path.resolve(targetDir));
+function formatSupportedPresetError() {
+    const supportedPresetNames = builtInPresets
+        .filter((preset) => preset.generation === "supported")
+        .map((preset) => preset.name);
+    return `Only the ${formatList(supportedPresetNames)} presets are supported in this version`;
 }
-function scopeFromOptions(projectName, scope) {
-    return scope ?? projectName;
+function formatList(values) {
+    if (values.length <= 1) {
+        return values[0] ?? "";
+    }
+    return `${values.slice(0, -1).join(", ")}, and ${values.at(-1)}`;
 }
 function blueprintForInit(options) {
     const preset = supportedPreset(options.preset);
-    const projectName = projectNameFromDir(options.dir);
-    const packageScope = scopeFromOptions(projectName, options.scope);
+    const projection = findBuiltInPresetProjection(preset.name);
+    if (projection) {
+        return projection.blueprint({
+            targetDir: options.dir,
+            scope: options.scope,
+        });
+    }
     const blueprint = {
         schemaVersion: 1,
         preset: preset.name,
         projectKind: preset.supportedProjectKinds[0],
-        features: [...preset.features]
+        features: [...preset.features],
     };
     if (preset.supportedPackageManagers[0]) {
         blueprint.packageManager = preset.supportedPackageManagers[0];
     }
-    if (preset.name === "vue-hono-app") {
-        blueprint.packages = [
-            { name: `@${packageScope}/web`, path: "apps/web" },
-            { name: `@${packageScope}/api`, path: "apps/api" }
-        ];
-    }
     return blueprint;
 }
 function formatBlueprintSummary(targetDir, blueprint) {
@@ -157,7 +156,7 @@ function formatBlueprintSummary(targetDir, blueprint) {
         "Project Blueprint",
         `  Target: ${targetDir}`,
         `  Preset: ${blueprint.preset}`,
-        `  Project kind: ${blueprint.projectKind}`
+        `  Project kind: ${blueprint.projectKind}`,
     ];
     if (blueprint.packageManager) {
         lines.push(`  Package manager: ${blueprint.packageManager}`);
@@ -171,103 +170,95 @@ function formatBlueprintSummary(targetDir, blueprint) {
     lines.push(`  Features: ${blueprint.features.join(", ")}`);
     return lines.join("\n");
 }
-function formatPostCommand(command) {
-    return [command.command, ...command.args].join(" ");
-}
-function formatPostCommandPlan(commands) {
-    if (commands.length === 0) {
-        return ["Post Commands:", "  (none)"].join("\n");
-    }
+function formatProjectionNextSteps(targetDir, projectionPlan) {
+    const steps = planNextStepInstructionsForProjection({
+        targetDir,
+        plan: projectionPlan,
+    });
     return [
-        "Post Commands:",
-        ...commands.map((command) => `  ${command.label}: ${formatPostCommand(command)}`)
+        "Next Step Instructions:",
+        ...steps.map((step) => `  ${step.label}: ${step.display}`),
     ].join("\n");
 }
-function nextStepsForPreset(preset) {
-    if (preset === "rust-bin") {
-        return ["cd <target>", "./scripts/check"];
-    }
-    return ["cd <target>", "pnpm install", "pnpm run check"];
+function toolchainReport(toolchain) {
+    return {
+        nodeLtsMajor: toolchain.nodeLtsMajor.value,
+        packageManagerPin: toolchain.packageManagerPin.value,
+        source: toolchain.source,
+        diagnostics: [...toolchain.diagnostics],
+    };
 }
-function formatNextSteps(targetDir, preset) {
+function formatToolchainReport(toolchain) {
     return [
-        "Next steps:",
-        ...nextStepsForPreset(preset).map((step) => `  ${step.replace("<target>", targetDir)}`)
+        "Toolchain Resolution:",
+        `  Source: ${toolchain.source}`,
+        `  Node LTS major: ${toolchain.nodeLtsMajor.value}`,
+        `  Package Manager Pin: ${toolchain.packageManagerPin.value}`,
+        ...toolchain.diagnostics.map((diagnostic) => `  ${diagnostic}`),
     ].join("\n");
 }
-function postCommandReport(planned, executions, skipped) {
-    return {
-        planned: planned.map((command) => ({
-            id: command.id,
-            label: command.label,
-            command: command.command,
-            args: [...command.args],
-            cwd: command.cwd
-        })),
-        run: executions
-            .filter((execution) => execution.status === "run")
-            .map((execution) => ({
-            id: execution.command.id,
-            exitCode: execution.exitCode
-        })),
-        failed: executions
-            .filter((execution) => execution.status === "failed")
-            .map((execution) => ({
-            id: execution.command.id,
-            exitCode: execution.exitCode,
-            error: execution.error
-        })),
-        skipped
-    };
-}
-function failedPostCommand(executions) {
-    return executions.find((execution) => execution.status === "failed");
+function toolchainResolutionSourceFromEnv() {
+    if (process.env.TEMPLATE_TOOLCHAIN_RESOLUTION === "online" ||
+        process.env.TEMPLATE_TOOLCHAIN_RESOLUTION === "bundled-fallback") {
+        return process.env.TEMPLATE_TOOLCHAIN_RESOLUTION;
+    }
+    return undefined;
 }
-function skippedPostCommands(commands, reason) {
-    return commands.map((command) => ({ id: command.id, reason }));
+async function generationContextForInit(options, blueprint) {
+    if (!findBuiltInPresetProjection(options.preset)) {
+        return undefined;
+    }
+    return assembleGenerationContext({
+        targetDir: options.dir,
+        blueprint,
+        toolchain: await resolveToolchainVersions({
+            source: toolchainResolutionSourceFromEnv(),
+            nodeReleaseIndexUrl: process.env.TEMPLATE_TOOLCHAIN_NODE_RELEASE_INDEX_URL,
+            pnpmRegistryUrl: process.env.TEMPLATE_TOOLCHAIN_PNPM_REGISTRY_URL,
+        }),
+    });
 }
-async function generateInitProject(options) {
-    if (options.preset === "ts-lib") {
-        await initTsLibProject(options.dir);
-        return;
-    }
-    if (options.preset === "hono-api") {
-        await initHonoApiProject(options.dir);
-        return;
-    }
-    if (options.preset === "vue-app") {
-        await initVueAppProject(options.dir);
-        return;
-    }
-    if (options.preset === "vue-hono-app") {
-        await initVueHonoAppProject(options.dir, { scope: options.scope });
-        return;
-    }
-    if (options.preset === "rust-bin") {
-        await initRustBinProject(options.dir);
+async function generateInitProject(options, generationContext) {
+    const projection = findBuiltInPresetProjection(options.preset);
+    if (projection) {
+        if (!generationContext) {
+            throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
+        }
+        const plan = projection.project(generationContext);
+        await projection.render({ targetDir: options.dir, plan });
         return;
     }
-    throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+    throw new Error(formatSupportedPresetError());
 }
-function printInitComplete(options, blueprint, report) {
-    const preset = blueprint.preset;
+function printInitComplete(options, blueprint, generationContext) {
+    const projectionPlan = generationContext
+        ? projectPresetThroughRegistry(generationContext)
+        : undefined;
+    if (!projectionPlan) {
+        throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
+    }
+    const nextSteps = planNextStepInstructionsForProjection({
+        targetDir: options.dir,
+        plan: projectionPlan,
+    });
     if (options.json) {
         printJson({
             command: "init",
             dryRun: false,
-            ready: options.ready,
             targetDir: options.dir,
             blueprint,
-            postCommands: report,
-            nextSteps: nextStepsForPreset(preset).map((step) => step.replace("<target>", options.dir))
+            toolchain: generationContext
+                ? toolchainReport(generationContext.toolchain)
+                : undefined,
+            nextSteps,
         });
         return;
     }
     console.log(`Initialized ${options.preset} project in ${options.dir}`);
-    if (options.ready) {
-        console.log(formatPostCommandPlan(report.planned));
+    if (generationContext) {
+        console.log(formatToolchainReport(generationContext.toolchain));
     }
-    console.log(formatNextSteps(options.dir, preset));
+    console.log(formatProjectionNextSteps(options.dir, projectionPlan));
 }
 function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -276,11 +267,12 @@ async function confirmInit(targetDir, blueprint) {
     console.log(formatBlueprintSummary(targetDir, blueprint));
     const readline = createInterface({
         input: process.stdin,
-        output: process.stdout
+        output: process.stdout,
     });
     try {
         const answer = await readline.question("Generate this project? [y/N] ");
-        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+        return (answer.trim().toLowerCase() === "y" ||
+            answer.trim().toLowerCase() === "yes");
     }
     finally {
         readline.close();
@@ -365,23 +357,35 @@ async function main(args) {
         const options = parseInitOptions(args);
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
-            const postCommandPlan = planPostCommands({
-                preset: blueprint.preset,
-                targetDir: options.dir
+            const generationContext = await generationContextForInit(options, blueprint);
+            const projectionPlan = generationContext
+                ? projectPresetThroughRegistry(generationContext)
+                : undefined;
+            if (!projectionPlan) {
+                throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
+            }
+            const nextSteps = planNextStepInstructionsForProjection({
+                targetDir: options.dir,
+                plan: projectionPlan,
             });
             if (options.json) {
                 printJson({
                     command: "init",
                     dryRun: true,
-                    ready: options.ready,
                     targetDir: options.dir,
                     blueprint,
-                    postCommands: postCommandReport(postCommandPlan.commands, [], skippedPostCommands(postCommandPlan.commands, "dry-run"))
+                    toolchain: generationContext
+                        ? toolchainReport(generationContext.toolchain)
+                        : undefined,
+                    nextSteps,
                 });
                 return;
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
-            console.log(formatPostCommandPlan(postCommandPlan.commands));
+            if (generationContext) {
+                console.log(formatToolchainReport(generationContext.toolchain));
+            }
+            console.log(formatProjectionNextSteps(options.dir, projectionPlan));
             return;
         }
         if (!options.yes && (options.json || !isInteractiveTerminal())) {
@@ -390,24 +394,18 @@ async function main(args) {
         if (!options.yes && !(await confirmInit(options.dir, blueprint))) {
             throw new Error("Init cancelled");
         }
-        const postCommandPlan = planPostCommands({
-            preset: blueprint.preset,
-            targetDir: options.dir
-        });
-        await generateInitProject(options);
-        const executions = options.ready ? await runPostCommands({ plan: postCommandPlan }) : [];
-        const failedExecution = failedPostCommand(executions);
-        printInitComplete(options, blueprint, postCommandReport(postCommandPlan.commands, executions, options.ready
-            ? []
-            : skippedPostCommands(postCommandPlan.commands, "ready-mode-not-requested")));
-        if (failedExecution) {
-            throw new Error(failedExecution.error);
-        }
+        const generationContext = await generationContextForInit(options, blueprint);
+        await generateInitProject(options, generationContext);
+        printInitComplete(options, blueprint, generationContext);
         return;
     }
     if (command === "add" && args[1] === "package") {
         const options = parseAddPackageOptions(args);
-        await addPackage({ cwd: process.cwd(), preset: options.preset, name: options.name });
+        await addPackage({
+            cwd: process.cwd(),
+            preset: options.preset,
+            name: options.name,
+        });
         console.log(`Added ${options.preset} package ${options.name}`);
         return;
     }

package/dist/{declarations.d.ts → src/declarations.d.ts}

@@ -1,7 +1,6 @@
 import * as v from "valibot";
-export type PresetName = "ts-lib" | "hono-api" | "vue-app" | "vue-hono-app" | "rust-bin" | "ts-app" | "node-cli";
 export type BuiltInPreset = {
-    name: PresetName;
+    name: string;
     title: string;
     description: string;
     generation: "supported" | "future";

package/dist/src/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,WAAW,GAAG,QAAQ,CAAC;IACnC,wBAAwB,EAAE,SAAS,cAAc,EAAE,CAAC;IACpD,qBAAqB,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,WAAW,GACnB,cAAc,GACd,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,GACZ,aAAa,GACb,cAAc,GACd,gBAAgB,GAChB,YAAY,GACZ,gBAAgB,GAChB,YAAY,GACZ,uBAAuB,CAAC;AAE5B,MAAM,MAAM,UAAU,GAAG;IACvB,aAAa,EAAE,CAAC,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,wBAAwB,EAAE,cAAc,EAAE,CAAC;IAC3C,qBAAqB,EAAE,WAAW,EAAE,CAAC;IACrC,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,aAAa,EAA0B,CAAC;AAgB9E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCvB,CAAC;AAEX,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BtB,CAAC;AAOX,eAAO,MAAM,gBAAgB;;;;;;;;aAQ3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;aAcjC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAC1B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAgD7C,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAAC,UAAU,CAAC,CA2B/E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEzE;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,gBAAgB,CAAC,gBAAgB,CAAC,CAqFpC"}

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

@@ -1,113 +1,6 @@
 import * as v from "valibot";
-export const builtInPresets = [
-    {
-        name: "ts-lib",
-        title: "TypeScript library",
-        description: "Strict TypeScript package with pnpm catalog tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "hono-api",
-        title: "Hono API",
-        description: "Single-package Hono Node API with strict TypeScript tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "vue-app",
-        title: "Vue app",
-        description: "Single-package Vue app with Vite, Tailwind, Pinia, and test tooling.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "vue-hono-app",
-        title: "Vue Hono app",
-        description: "Full-stack Vue and Hono workspace with Hono RPC typing.",
-        generation: "supported",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["multi-package"],
-        features: [
-            "pnpm-catalog",
-            "oxc-format-lint",
-            "strict-typescript",
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot"
-        ]
-    },
-    {
-        name: "rust-bin",
-        title: "Rust binary",
-        description: "Single-package Rust native binary with rustfmt, clippy, and cargo tests.",
-        generation: "supported",
-        supportedPackageManagers: [],
-        supportedProjectKinds: ["single-package"],
-        features: [
-            "root-check",
-            "fix-command",
-            "devcontainer",
-            "github-actions",
-            "dependabot",
-            "rustfmt-clippy",
-            "cargo-test"
-        ]
-    },
-    {
-        name: "ts-app",
-        title: "TypeScript application",
-        description: "Future application preset metadata.",
-        generation: "future",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: []
-    },
-    {
-        name: "node-cli",
-        title: "Node.js CLI",
-        description: "Future command-line preset metadata.",
-        generation: "future",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
-        features: []
-    }
-];
+import { builtInPresetMetadata } from "../templates/registry.js";
+export const builtInPresets = builtInPresetMetadata;
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",

package/dist/src/dependency-catalog.d.ts

@@ -0,0 +1,10 @@
+export type TemplateDependencyCatalog = Record<string, string>;
+export type GeneratedDependencyCatalogOptions = {
+    readonly dependencies: readonly string[];
+    readonly packages?: readonly string[];
+    readonly allowBuilds?: Record<string, boolean>;
+};
+export declare function loadTemplateDependencyCatalog(): TemplateDependencyCatalog;
+export declare function selectTemplateDependencyCatalogEntries(dependencies: readonly string[], catalog?: TemplateDependencyCatalog): TemplateDependencyCatalog;
+export declare function renderGeneratedPnpmWorkspaceYaml(options: GeneratedDependencyCatalogOptions): string;
+//# sourceMappingURL=dependency-catalog.d.ts.map

package/dist/src/dependency-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-catalog.d.ts","sourceRoot":"","sources":["../../src/dependency-catalog.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE/D,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD,CAAC;AA2CF,wBAAgB,6BAA6B,IAAI,yBAAyB,CAOzE;AAED,wBAAgB,sCAAsC,CACpD,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,OAAO,GAAE,yBAA2D,GACnE,yBAAyB,CAe3B;AAMD,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,MAAM,CA4BR"}

package/dist/src/dependency-catalog.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function templateRepositoryRoot() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(moduleDir, ".."),
+        path.resolve(moduleDir, "..", ".."),
+    ];
+    return (candidates.find((candidate) => existsSync(path.join(candidate, "pnpm-workspace.yaml"))) ?? candidates[0]);
+}
+function parseTemplateDependencyCatalog(workspaceYaml) {
+    const catalog = {};
+    const lines = workspaceYaml.split(/\r?\n/);
+    const catalogStart = lines.findIndex((line) => line === "catalog:");
+    if (catalogStart === -1) {
+        return catalog;
+    }
+    for (const line of lines.slice(catalogStart + 1)) {
+        if (line.length > 0 && !line.startsWith("  ")) {
+            break;
+        }
+        const match = /^  (?:"([^"]+)"|([^:]+)): (.+)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        catalog[match[1] ?? match[2]] = match[3];
+    }
+    return catalog;
+}
+export function loadTemplateDependencyCatalog() {
+    return parseTemplateDependencyCatalog(readFileSync(path.join(templateRepositoryRoot(), "pnpm-workspace.yaml"), "utf8"));
+}
+export function selectTemplateDependencyCatalogEntries(dependencies, catalog = loadTemplateDependencyCatalog()) {
+    const selected = {};
+    for (const dependency of [...dependencies].sort()) {
+        const version = catalog[dependency];
+        if (version === undefined) {
+            throw new Error(`Template Dependency Catalog is missing dependency: ${dependency}`);
+        }
+        selected[dependency] = version;
+    }
+    return selected;
+}
+function renderCatalogKey(key) {
+    return key.startsWith("@") ? JSON.stringify(key) : key;
+}
+export function renderGeneratedPnpmWorkspaceYaml(options) {
+    const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
+    const packages = options.packages ?? ["."];
+    const lines = [
+        "packages:",
+        ...packages.map((workspacePackage) => `  - ${workspacePackage}`),
+        "",
+    ];
+    if (options.allowBuilds) {
+        lines.push("allowBuilds:", ...Object.entries(options.allowBuilds)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([dependency, allowed]) => `  ${dependency}: ${allowed}`), "");
+    }
+    lines.push("catalog:", ...Object.entries(catalog).map(([dependency, version]) => `  ${renderCatalogKey(dependency)}: ${version}`), "");
+    return lines.join("\n");
+}

package/dist/src/devcontainer.d.ts

@@ -0,0 +1,18 @@
+export type DevcontainerNodeFeatureOptions = {
+    readonly nodeVersion: string;
+    readonly packageManagerPin: string;
+};
+export type DevcontainerNodeFeature = {
+    readonly version: string;
+    readonly pnpmVersion: string;
+};
+export declare function pnpmVersionFromPackageManagerPin(packageManagerPin: string): string;
+export declare function devcontainerNodeFeature(options: DevcontainerNodeFeatureOptions): Record<"ghcr.io/devcontainers/features/node:1", DevcontainerNodeFeature>;
+export declare function nodePnpmDevcontainer(options: {
+    readonly name: string;
+    readonly nodeVersion: string;
+    readonly packageManagerPin: string;
+    readonly extensions: readonly string[];
+    readonly settings?: Record<string, unknown>;
+}): Record<string, unknown>;
+//# sourceMappingURL=devcontainer.d.ts.map

package/dist/src/devcontainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devcontainer.d.ts","sourceRoot":"","sources":["../../src/devcontainer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,wBAAgB,gCAAgC,CAC9C,iBAAiB,EAAE,MAAM,GACxB,MAAM,CAER;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,GACtC,MAAM,CAAC,uCAAuC,EAAE,uBAAuB,CAAC,CAO1E;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAY1B"}

package/dist/src/devcontainer.js

@@ -0,0 +1,24 @@
+export function pnpmVersionFromPackageManagerPin(packageManagerPin) {
+    return packageManagerPin.replace(/^pnpm@/, "");
+}
+export function devcontainerNodeFeature(options) {
+    return {
+        "ghcr.io/devcontainers/features/node:1": {
+            version: options.nodeVersion,
+            pnpmVersion: pnpmVersionFromPackageManagerPin(options.packageManagerPin),
+        },
+    };
+}
+export function nodePnpmDevcontainer(options) {
+    return {
+        name: options.name,
+        image: `mcr.microsoft.com/devcontainers/typescript-node:${options.nodeVersion}`,
+        features: devcontainerNodeFeature(options),
+        customizations: {
+            vscode: {
+                extensions: options.extensions,
+                ...(options.settings ? { settings: options.settings } : {}),
+            },
+        },
+    };
+}