@ykdz/template 0.0.3 → 0.0.4

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>]",
         "  template presets",
         "  template schema preset",
         "  template schema blueprint",
@@ -22,6 +22,7 @@ function usage() {
         "Options:",
         "  --preset <name>  Project preset to generate",
         "  --name <name>    Package name to add",
+        "  --path <path>    Two-segment Package Path to add",
         "  --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 +282,7 @@ async function confirmInit(targetDir, blueprint) {
 function parseAddPackageOptions(args) {
     let preset = "";
     let name = "";
+    let packagePath;
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--preset") {
@@ -301,6 +303,15 @@ 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;
+        }
         throw new Error(`Unknown option: ${arg}`);
     }
     if (!preset) {
@@ -309,7 +320,7 @@ function parseAddPackageOptions(args) {
     if (!name) {
         throw new Error("add package requires --name");
     }
-    return { preset, name };
+    return { preset, name, path: packagePath };
 }
 async function main(args) {
     const command = args[0];
@@ -405,6 +416,7 @@ async function main(args) {
             cwd: process.cwd(),
             preset: options.preset,
             name: options.name,
+            path: options.path,
         });
         console.log(`Added ${options.preset} package ${options.name}`);
         return;

package/dist/src/declarations.d.ts

@@ -67,7 +67,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 +99,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";
@@ -162,4 +162,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,15 +77,18 @@ export const blueprintJsonSchema = {
                 required: ["name", "path"],
                 properties: {
                     name: { type: "string", minLength: 1 },
-                    path: { type: "string", minLength: 1 }
-                }
-            }
-        }
-    }
+                    path: { 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);
 export const presetFileSchema = v.strictObject({
     schemaVersion: v.literal(1),
@@ -94,7 +97,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 +107,8 @@ export const projectBlueprintSchema = v.strictObject({
     features: v.array(featureNameSchema),
     packages: v.optional(v.array(v.strictObject({
         name: nonEmptyString,
-        path: nonEmptyString
-    })))
+        path: nonEmptyString,
+    }))),
 });
 function formatIssuePath(issue) {
     if (!issue.path || issue.path.length === 0) {
@@ -116,7 +119,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 +133,7 @@ function duplicateIssues(values, path) {
     }
     return [...duplicates].map((value) => ({
         path,
-        message: `Duplicate value: ${value}`
+        message: `Duplicate value: ${value}`,
     }));
 }
 function generationSupportIssue(preset, path) {
@@ -139,7 +142,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 +159,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 +187,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 +207,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 +228,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 {};