@ykdz/template 0.0.3 → 0.0.5

package/README.md

@@ -12,7 +12,7 @@ Available commands:
 
 ```sh
 template init <dir> --preset <name> --yes
-template add package --preset <name> --name <name>
+template add package --preset <name> --name <name> [--path <package-path>]
 template presets
 template schema preset
 template schema blueprint

package/dist/src/cli.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.js

@@ -12,7 +12,7 @@ function usage() {
     return [
         "Usage:",
         "  template init <dir> --preset <name> --yes",
-        "  template add package --preset <name> --name <name>",
+        "  template add package --preset <name> --name <name> [--path <package-path>] [--link-from <package-path>]...",
         "  template presets",
         "  template schema preset",
         "  template schema blueprint",
@@ -22,6 +22,8 @@ function usage() {
         "Options:",
         "  --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",
@@ -281,6 +283,8 @@ async function confirmInit(targetDir, blueprint) {
 function parseAddPackageOptions(args) {
     let preset = "";
     let name = "";
+    let packagePath;
+    const linkFrom = [];
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--preset") {
@@ -301,6 +305,24 @@ function parseAddPackageOptions(args) {
             index += 1;
             continue;
         }
+        if (arg === "--path") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--path requires a value");
+            }
+            packagePath = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--link-from") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--link-from requires a value");
+            }
+            linkFrom.push(value);
+            index += 1;
+            continue;
+        }
         throw new Error(`Unknown option: ${arg}`);
     }
     if (!preset) {
@@ -309,7 +331,7 @@ function parseAddPackageOptions(args) {
     if (!name) {
         throw new Error("add package requires --name");
     }
-    return { preset, name };
+    return { preset, name, path: packagePath, linkFrom };
 }
 async function main(args) {
     const command = args[0];
@@ -405,6 +427,8 @@ async function main(args) {
             cwd: process.cwd(),
             preset: options.preset,
             name: options.name,
+            path: options.path,
+            linkFrom: options.linkFrom,
         });
         console.log(`Added ${options.preset} package ${options.name}`);
         return;

package/dist/src/declarations.d.ts

@@ -1,4 +1,6 @@
 import * as v from "valibot";
+import type { PackageAdditionSupport } from "./package-addition-support.js";
+import type { PackageLinkIntent, PackageRole, PackageSourcePreset } from "./package-linking.js";
 export type BuiltInPreset = {
     name: string;
     title: string;
@@ -6,6 +8,7 @@ export type BuiltInPreset = {
     generation: "supported" | "future";
     supportedPackageManagers: readonly PackageManager[];
     supportedProjectKinds: readonly ProjectKind[];
+    packageAdditionSupport: PackageAdditionSupport;
     features: readonly FeatureName[];
 };
 export type PackageManager = "pnpm";
@@ -23,6 +26,8 @@ export type PresetFile = {
 export type ProjectPackage = {
     name: string;
     path: string;
+    role?: PackageRole;
+    sourcePreset?: PackageSourcePreset;
 };
 export type ProjectBlueprint = {
     schemaVersion: 1;
@@ -31,6 +36,7 @@ export type ProjectBlueprint = {
     projectKind: ProjectKind;
     features: FeatureName[];
     packages?: ProjectPackage[];
+    packageLinkIntents?: PackageLinkIntent[];
 };
 export declare const builtInPresets: readonly BuiltInPreset[];
 export declare const presetFileJsonSchema: {
@@ -67,7 +73,7 @@ export declare const presetFileJsonSchema: {
             readonly type: "array";
             readonly minItems: 1;
             readonly items: {
-                readonly enum: readonly ["single-package", "multi-package"];
+                readonly enum: readonly ["multi-package"];
             };
             readonly uniqueItems: true;
         };
@@ -99,7 +105,7 @@ export declare const blueprintJsonSchema: {
             readonly enum: readonly ["pnpm"];
         };
         readonly projectKind: {
-            readonly enum: readonly ["single-package", "multi-package"];
+            readonly enum: readonly ["multi-package"];
         };
         readonly features: {
             readonly type: "array";
@@ -123,6 +129,30 @@ export declare const blueprintJsonSchema: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
+                    readonly role: {
+                        readonly enum: readonly ["runtime-service", "shared-library"];
+                    };
+                    readonly sourcePreset: {
+                        readonly enum: readonly ["hono-api", "ts-lib", "vue-app"];
+                    };
+                };
+            };
+        };
+        readonly packageLinkIntents: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["consumerPackagePath", "providerPackagePath"];
+                readonly properties: {
+                    readonly consumerPackagePath: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly providerPackagePath: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
                 };
             };
         };
@@ -146,6 +176,12 @@ export declare const projectBlueprintSchema: v.StrictObjectSchema<{
     readonly packages: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly role: v.OptionalSchema<v.PicklistSchema<["runtime-service", "shared-library"], undefined>, undefined>;
+        readonly sourcePreset: v.OptionalSchema<v.PicklistSchema<["hono-api", "ts-lib", "vue-app"], undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly consumerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly providerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     }, undefined>, undefined>, undefined>;
 }, undefined>;
 export type ValidationIssue = {
@@ -162,4 +198,3 @@ export type ValidationResult<T> = {
 export declare function validatePresetFile(input: unknown): ValidationResult<PresetFile>;
 export declare function findBuiltInPreset(name: string): BuiltInPreset | undefined;
 export declare function validateProjectBlueprint(input: unknown): ValidationResult<ProjectBlueprint>;
-//# sourceMappingURL=declarations.d.ts.map

package/dist/src/declarations.js

@@ -12,7 +12,7 @@ const featureNames = [
     "dependabot",
     "rustfmt-clippy",
     "cargo-test",
-    "native-binary-release"
+    "native-binary-release",
 ];
 export const presetFileJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -27,7 +27,7 @@ export const presetFileJsonSchema = {
         "description",
         "supportedPackageManagers",
         "supportedProjectKinds",
-        "features"
+        "features",
     ],
     properties: {
         schemaVersion: { const: 1 },
@@ -37,20 +37,20 @@ export const presetFileJsonSchema = {
         supportedPackageManagers: {
             type: "array",
             items: { enum: ["pnpm"] },
-            uniqueItems: true
+            uniqueItems: true,
         },
         supportedProjectKinds: {
             type: "array",
             minItems: 1,
-            items: { enum: ["single-package", "multi-package"] },
-            uniqueItems: true
+            items: { enum: ["multi-package"] },
+            uniqueItems: true,
         },
         features: {
             type: "array",
             items: { enum: featureNames },
-            uniqueItems: true
-        }
-    }
+            uniqueItems: true,
+        },
+    },
 };
 export const blueprintJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -63,11 +63,11 @@ export const blueprintJsonSchema = {
         schemaVersion: { const: 1 },
         preset: { type: "string", minLength: 1 },
         packageManager: { enum: ["pnpm"] },
-        projectKind: { enum: ["single-package", "multi-package"] },
+        projectKind: { enum: ["multi-package"] },
         features: {
             type: "array",
             items: { enum: featureNames },
-            uniqueItems: true
+            uniqueItems: true,
         },
         packages: {
             type: "array",
@@ -77,16 +77,42 @@ export const blueprintJsonSchema = {
                 required: ["name", "path"],
                 properties: {
                     name: { type: "string", minLength: 1 },
-                    path: { type: "string", minLength: 1 }
-                }
-            }
-        }
-    }
+                    path: { type: "string", minLength: 1 },
+                    role: { enum: ["runtime-service", "shared-library"] },
+                    sourcePreset: { enum: ["hono-api", "ts-lib", "vue-app"] },
+                },
+            },
+        },
+        packageLinkIntents: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["consumerPackagePath", "providerPackagePath"],
+                properties: {
+                    consumerPackagePath: { type: "string", minLength: 1 },
+                    providerPackagePath: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    },
 };
 const nonEmptyString = v.pipe(v.string(), v.minLength(1));
 const packageManagerSchema = v.picklist(["pnpm"]);
-const projectKindSchema = v.picklist(["single-package", "multi-package"]);
+const projectKindSchema = v.picklist([
+    "single-package",
+    "multi-package",
+]);
 const featureNameSchema = v.picklist(featureNames);
+const packageRoleSchema = v.picklist([
+    "runtime-service",
+    "shared-library",
+]);
+const packageSourcePresetSchema = v.picklist([
+    "hono-api",
+    "ts-lib",
+    "vue-app",
+]);
 export const presetFileSchema = v.strictObject({
     schemaVersion: v.literal(1),
     name: nonEmptyString,
@@ -94,7 +120,7 @@ export const presetFileSchema = v.strictObject({
     description: nonEmptyString,
     supportedPackageManagers: v.array(packageManagerSchema),
     supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
-    features: v.array(featureNameSchema)
+    features: v.array(featureNameSchema),
 });
 export const projectBlueprintSchema = v.strictObject({
     schemaVersion: v.literal(1),
@@ -104,8 +130,14 @@ export const projectBlueprintSchema = v.strictObject({
     features: v.array(featureNameSchema),
     packages: v.optional(v.array(v.strictObject({
         name: nonEmptyString,
-        path: nonEmptyString
-    })))
+        path: nonEmptyString,
+        role: v.optional(packageRoleSchema),
+        sourcePreset: v.optional(packageSourcePresetSchema),
+    }))),
+    packageLinkIntents: v.optional(v.array(v.strictObject({
+        consumerPackagePath: nonEmptyString,
+        providerPackagePath: nonEmptyString,
+    }))),
 });
 function formatIssuePath(issue) {
     if (!issue.path || issue.path.length === 0) {
@@ -116,7 +148,7 @@ function formatIssuePath(issue) {
 function shapeIssues(issues) {
     return issues.map((issue) => ({
         path: formatIssuePath(issue),
-        message: issue.message
+        message: issue.message,
     }));
 }
 function duplicateIssues(values, path) {
@@ -130,7 +162,7 @@ function duplicateIssues(values, path) {
     }
     return [...duplicates].map((value) => ({
         path,
-        message: `Duplicate value: ${value}`
+        message: `Duplicate value: ${value}`,
     }));
 }
 function generationSupportIssue(preset, path) {
@@ -139,7 +171,13 @@ function generationSupportIssue(preset, path) {
     }
     return {
         path,
-        message: `Preset ${preset.name} is not supported for generation in this version`
+        message: `Preset ${preset.name} is not supported for generation in this version`,
+    };
+}
+function unsupportedSinglePackageProjectShapeIssue(path) {
+    return {
+        path,
+        message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
     };
 }
 export function validatePresetFile(input) {
@@ -150,8 +188,11 @@ export function validatePresetFile(input) {
     const semanticIssues = [
         ...duplicateIssues(result.output.supportedPackageManagers, "$.supportedPackageManagers"),
         ...duplicateIssues(result.output.supportedProjectKinds, "$.supportedProjectKinds"),
-        ...duplicateIssues(result.output.features, "$.features")
+        ...duplicateIssues(result.output.features, "$.features"),
     ];
+    if (result.output.supportedProjectKinds.includes("single-package")) {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.supportedProjectKinds"));
+    }
     const builtInPreset = findBuiltInPreset(result.output.name);
     const unsupportedGeneration = builtInPreset
         ? generationSupportIssue(builtInPreset, "$.name")
@@ -175,12 +216,15 @@ export function validateProjectBlueprint(input) {
     const blueprint = result.output;
     const preset = findBuiltInPreset(blueprint.preset);
     const semanticIssues = [
-        ...duplicateIssues(blueprint.features, "$.features")
+        ...duplicateIssues(blueprint.features, "$.features"),
     ];
+    if (blueprint.projectKind === "single-package") {
+        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.projectKind"));
+    }
     if (!preset) {
         semanticIssues.push({
             path: "$.preset",
-            message: `Unknown built-in preset: ${blueprint.preset}`
+            message: `Unknown built-in preset: ${blueprint.preset}`,
         });
     }
     else {
@@ -192,19 +236,20 @@ export function validateProjectBlueprint(input) {
             !preset.supportedPackageManagers.includes(blueprint.packageManager)) {
             semanticIssues.push({
                 path: "$.packageManager",
-                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`
+                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`,
             });
         }
-        if (!blueprint.packageManager && preset.supportedPackageManagers.length > 0) {
+        if (!blueprint.packageManager &&
+            preset.supportedPackageManagers.length > 0) {
             semanticIssues.push({
                 path: "$.packageManager",
-                message: `packageManager is required by preset ${preset.name}`
+                message: `packageManager is required by preset ${preset.name}`,
             });
         }
         if (!preset.supportedProjectKinds.includes(blueprint.projectKind)) {
             semanticIssues.push({
                 path: "$.projectKind",
-                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`
+                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`,
             });
         }
         const supportedFeatures = new Set(preset.features);
@@ -212,18 +257,12 @@ export function validateProjectBlueprint(input) {
             if (!supportedFeatures.has(feature)) {
                 semanticIssues.push({
                     path: "$.features",
-                    message: `${feature} is not supported by preset ${preset.name}`
+                    message: `${feature} is not supported by preset ${preset.name}`,
                 });
             }
         }
     }
     if (blueprint.packages) {
-        if (blueprint.projectKind === "single-package" && blueprint.packages.length > 1) {
-            semanticIssues.push({
-                path: "$.packages",
-                message: "single-package blueprints support exactly one package"
-            });
-        }
         semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"));
     }
     if (semanticIssues.length > 0) {

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

@@ -4,7 +4,15 @@ export type GeneratedDependencyCatalogOptions = {
     readonly packages?: readonly string[];
     readonly allowBuilds?: Record<string, boolean>;
 };
+export type GeneratedPackageManifestDependencies = {
+    readonly dependencies?: Record<string, string>;
+    readonly devDependencies?: Record<string, string>;
+    readonly optionalDependencies?: Record<string, string>;
+    readonly peerDependencies?: Record<string, string>;
+};
 export declare function loadTemplateDependencyCatalog(): TemplateDependencyCatalog;
 export declare function selectTemplateDependencyCatalogEntries(dependencies: readonly string[], catalog?: TemplateDependencyCatalog): TemplateDependencyCatalog;
+export declare function collectGeneratedManifestCatalogDependencies(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
+export declare function collectGeneratedManifestCatalogReferences(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
+export declare function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml: string, dependencies: readonly string[], templateCatalog?: TemplateDependencyCatalog): string;
 export declare function renderGeneratedPnpmWorkspaceYaml(options: GeneratedDependencyCatalogOptions): string;
-//# sourceMappingURL=dependency-catalog.d.ts.map

package/dist/src/dependency-catalog.js

@@ -42,9 +42,78 @@ export function selectTemplateDependencyCatalogEntries(dependencies, catalog = l
     }
     return selected;
 }
+export function collectGeneratedManifestCatalogDependencies(manifests) {
+    const dependencies = new Set();
+    for (const manifest of manifests) {
+        for (const dependencyMap of [
+            manifest.dependencies,
+            manifest.devDependencies,
+            manifest.optionalDependencies,
+            manifest.peerDependencies,
+        ]) {
+            for (const [dependency, specifier] of Object.entries(dependencyMap ?? {})) {
+                if (specifier !== "catalog:") {
+                    throw new Error(`Generated manifest dependency ${dependency} must use catalog:, got ${specifier}`);
+                }
+                dependencies.add(dependency);
+            }
+        }
+    }
+    return [...dependencies].sort();
+}
+export function collectGeneratedManifestCatalogReferences(manifests) {
+    const dependencies = new Set();
+    for (const manifest of manifests) {
+        for (const dependencyMap of [
+            manifest.dependencies,
+            manifest.devDependencies,
+            manifest.optionalDependencies,
+            manifest.peerDependencies,
+        ]) {
+            for (const [dependency, specifier] of Object.entries(dependencyMap ?? {})) {
+                if (specifier.startsWith("catalog:")) {
+                    dependencies.add(dependency);
+                }
+            }
+        }
+    }
+    return [...dependencies].sort();
+}
 function renderCatalogKey(key) {
     return key.startsWith("@") ? JSON.stringify(key) : key;
 }
+export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependencies, templateCatalog = loadTemplateDependencyCatalog()) {
+    const catalogStart = workspaceYaml
+        .split(/\r?\n/)
+        .findIndex((line) => line === "catalog:");
+    if (catalogStart === -1) {
+        throw new Error("Cannot update pnpm Dependency Catalog: missing catalog section");
+    }
+    const existingCatalog = parseTemplateDependencyCatalog(workspaceYaml);
+    const missingDependencies = dependencies.filter((dependency) => existingCatalog[dependency] === undefined);
+    if (missingDependencies.length === 0) {
+        return workspaceYaml;
+    }
+    const nextCatalog = {
+        ...existingCatalog,
+        ...selectTemplateDependencyCatalogEntries(missingDependencies, templateCatalog),
+    };
+    const lines = workspaceYaml.split(/\r?\n/);
+    const catalogEnd = lines.findIndex((line, index) => index > catalogStart && line.length > 0 && !line.startsWith("  "));
+    const replacementEnd = catalogEnd === -1 ? lines.length : catalogEnd;
+    const catalogLines = [
+        "catalog:",
+        ...Object.entries(nextCatalog)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([dependency, version]) => `  ${renderCatalogKey(dependency)}: ${version}`),
+        "",
+    ];
+    return [
+        ...lines.slice(0, catalogStart),
+        ...catalogLines,
+        ...lines.slice(replacementEnd),
+    ].join("\n");
+}
 export function renderGeneratedPnpmWorkspaceYaml(options) {
     const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
     const packages = options.packages ?? ["."];

package/dist/src/devcontainer.d.ts

@@ -1,18 +1,58 @@
-export type DevcontainerNodeFeatureOptions = {
+import type { WriteTextFromFragmentsOperation } from "./renderer.js";
+export type DevelopmentContainerNodePnpmLayer = {
+    readonly kind: "node-pnpm";
     readonly nodeVersion: string;
     readonly packageManagerPin: string;
 };
-export type DevcontainerNodeFeature = {
-    readonly version: string;
-    readonly pnpmVersion: string;
+export type DevelopmentContainerBrowserTestLayer = {
+    readonly kind: "browser-test";
+    readonly playwrightCliPackage: 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: {
+export type DevelopmentContainerRustLayer = {
+    readonly kind: "rust";
+    readonly toolchain: string;
+};
+type DevelopmentContainerCapabilityLayer = DevelopmentContainerBrowserTestLayer | DevelopmentContainerRustLayer;
+export type DevelopmentContainerPlan = {
+    readonly devcontainer: Record<string, unknown>;
+    readonly dockerfile: string;
+    readonly dockerfileOperation?: WriteTextFromFragmentsOperation;
+};
+export type DevelopmentContainerDockerfileLayer = {
+    readonly kind: "base" | "capability";
     readonly name: string;
+    readonly text: string;
+};
+export declare function composeDevelopmentContainerDockerfile(options: {
+    readonly layers: readonly DevelopmentContainerDockerfileLayer[];
+}): string;
+export declare function nodePnpmToolLayer(options: {
     readonly nodeVersion: string;
     readonly packageManagerPin: string;
+}): DevelopmentContainerNodePnpmLayer;
+export declare function browserTestToolLayer(): DevelopmentContainerBrowserTestLayer;
+export declare function rustToolLayer(options?: {
+    readonly toolchain?: string;
+}): DevelopmentContainerRustLayer;
+export declare function dockerfileFirstNodePnpmDevcontainer(options: {
+    readonly name: string;
+    readonly layer: DevelopmentContainerNodePnpmLayer;
+    readonly extensions: readonly string[];
+    readonly settings?: Record<string, unknown>;
+}): DevelopmentContainerPlan;
+export declare function checkedDockerfileFirstNodePnpmDevcontainer(options: {
+    readonly name: string;
+    readonly layer: DevelopmentContainerNodePnpmLayer;
+    readonly additionalLayers?: readonly DevelopmentContainerCapabilityLayer[];
+    readonly extensions: readonly string[];
+    readonly settings?: Record<string, unknown>;
+    readonly mounts?: readonly string[];
+}): DevelopmentContainerPlan;
+export declare function dockerfileFirstRustPnpmDevcontainer(options: {
+    readonly name: string;
+    readonly nodeLayer: DevelopmentContainerNodePnpmLayer;
+    readonly rustLayer: DevelopmentContainerRustLayer;
     readonly extensions: readonly string[];
     readonly settings?: Record<string, unknown>;
-}): Record<string, unknown>;
-//# sourceMappingURL=devcontainer.d.ts.map
+}): DevelopmentContainerPlan;
+export {};