@ykdz/template 0.0.3 → 0.0.4

package/dist/src/devcontainer.js

@@ -1,24 +1,202 @@
-export function pnpmVersionFromPackageManagerPin(packageManagerPin) {
-    return packageManagerPin.replace(/^pnpm@/, "");
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadTemplateDependencyCatalog } from "./dependency-catalog.js";
+import { packageTemplateRoot } from "./runtime-paths.js";
+const runtimeDockerfileInstructions = new Set([
+    "CMD",
+    "ENTRYPOINT",
+    "EXPOSE",
+    "HEALTHCHECK",
+    "STOPSIGNAL",
+    "VOLUME",
+]);
+function dockerfileInstructions(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"))
+        .map((line) => line.match(/^([A-Za-z]+)/)?.[1]?.toUpperCase())
+        .filter((instruction) => instruction !== undefined);
 }
-export function devcontainerNodeFeature(options) {
+export function composeDevelopmentContainerDockerfile(options) {
+    const baseImageInstructionCount = options.layers.reduce((count, layer) => count +
+        dockerfileInstructions(layer.text).filter((instruction) => instruction === "FROM").length, 0);
+    if (baseImageInstructionCount !== 1) {
+        throw new Error(`Development Container Dockerfile must have exactly one base layer with a FROM instruction; found ${baseImageInstructionCount}.`);
+    }
+    for (const layer of options.layers) {
+        const instructions = dockerfileInstructions(layer.text);
+        if (layer.kind === "capability" && instructions.includes("FROM")) {
+            throw new Error(`${layer.name} capability layer must not supply a Dockerfile FROM instruction.`);
+        }
+        if (layer.kind !== "capability") {
+            continue;
+        }
+        for (const instruction of instructions) {
+            if (runtimeDockerfileInstructions.has(instruction)) {
+                throw new Error(`${layer.name} must not use runtime Dockerfile instruction ${instruction}.`);
+            }
+        }
+    }
+    return options.layers.map((layer) => layer.text.trimEnd()).join("\n\n");
+}
+export function nodePnpmToolLayer(options) {
+    return {
+        kind: "node-pnpm",
+        nodeVersion: options.nodeVersion,
+        packageManagerPin: options.packageManagerPin,
+    };
+}
+export function browserTestToolLayer() {
+    const playwrightTestVersion = loadTemplateDependencyCatalog()["@playwright/test"];
+    if (playwrightTestVersion === undefined) {
+        throw new Error("Template Dependency Catalog is missing dependency: @playwright/test");
+    }
     return {
-        "ghcr.io/devcontainers/features/node:1": {
-            version: options.nodeVersion,
-            pnpmVersion: pnpmVersionFromPackageManagerPin(options.packageManagerPin),
+        kind: "browser-test",
+        playwrightCliPackage: `@playwright/test@${playwrightTestVersion}`,
+    };
+}
+export function rustToolLayer(options = {}) {
+    return { kind: "rust", toolchain: options.toolchain ?? "stable" };
+}
+function sharedDevcontainerSourceRoot() {
+    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "devcontainer");
+}
+function checkedDockerfileFragment(name) {
+    return readFileSync(path.join(sharedDevcontainerSourceRoot(), name), "utf8");
+}
+function checkedNodePnpmDockerfile(options = {}) {
+    return composeDevelopmentContainerDockerfile({
+        layers: [
+            {
+                kind: "base",
+                name: "node-pnpm",
+                text: checkedDockerfileFragment("node-pnpm.Dockerfile"),
+            },
+            ...(options.additionalLayers ?? []).map((layer) => {
+                switch (layer.kind) {
+                    case "browser-test":
+                        return {
+                            kind: "capability",
+                            name: "browser-test",
+                            text: checkedDockerfileFragment("browser-test.Dockerfile"),
+                        };
+                    case "rust":
+                        return {
+                            kind: "capability",
+                            name: "rust",
+                            text: checkedDockerfileFragment("rust.Dockerfile"),
+                        };
+                }
+            }),
+        ],
+    });
+}
+function checkedNodePnpmDockerfileFragments(options = {}) {
+    return [
+        {
+            sourceRoot: "sharedDevcontainer",
+            from: "node-pnpm.Dockerfile",
         },
+        ...(options.additionalLayers ?? []).map((layer) => {
+            switch (layer.kind) {
+                case "browser-test":
+                    return {
+                        sourceRoot: "sharedDevcontainer",
+                        from: "browser-test.Dockerfile",
+                    };
+                case "rust":
+                    return {
+                        sourceRoot: "sharedDevcontainer",
+                        from: "rust.Dockerfile",
+                    };
+            }
+        }),
+    ];
+}
+function browserTestBuildArgs(layers = []) {
+    const browserTestLayer = layers.find((layer) => layer.kind === "browser-test");
+    return browserTestLayer === undefined
+        ? {}
+        : { PLAYWRIGHT_CLI_PACKAGE: browserTestLayer.playwrightCliPackage };
+}
+function rustBuildArgs(layers = []) {
+    const rustLayer = layers.find((layer) => layer.kind === "rust");
+    return rustLayer === undefined ? {} : { RUST_TOOLCHAIN: rustLayer.toolchain };
+}
+export function dockerfileFirstNodePnpmDevcontainer(options) {
+    return {
+        devcontainer: {
+            name: options.name,
+            build: {
+                dockerfile: "Dockerfile",
+                args: {
+                    NODE_VERSION: options.layer.nodeVersion,
+                    PACKAGE_MANAGER_PIN: options.layer.packageManagerPin,
+                },
+            },
+            customizations: {
+                vscode: {
+                    extensions: options.extensions,
+                    ...(options.settings ? { settings: options.settings } : {}),
+                },
+            },
+        },
+        dockerfile: [
+            `FROM mcr.microsoft.com/devcontainers/typescript-node:${options.layer.nodeVersion}`,
+            "",
+            'SHELL ["/bin/bash", "-o", "pipefail", "-c"]',
+            `RUN corepack enable && corepack prepare ${options.layer.packageManagerPin} --activate`,
+            "",
+        ].join("\n"),
     };
 }
-export function nodePnpmDevcontainer(options) {
+export function checkedDockerfileFirstNodePnpmDevcontainer(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 } : {}),
+        devcontainer: {
+            name: options.name,
+            build: {
+                dockerfile: "Dockerfile",
+                args: {
+                    NODE_VERSION: options.layer.nodeVersion,
+                    PACKAGE_MANAGER_PIN: options.layer.packageManagerPin,
+                    ...browserTestBuildArgs(options.additionalLayers),
+                    ...rustBuildArgs(options.additionalLayers),
+                },
+            },
+            customizations: {
+                vscode: {
+                    extensions: options.extensions,
+                    ...(options.settings ? { settings: options.settings } : {}),
+                },
             },
+            ...(options.mounts ? { mounts: options.mounts } : {}),
+        },
+        dockerfile: checkedNodePnpmDockerfile({
+            additionalLayers: options.additionalLayers,
+        }),
+        dockerfileOperation: {
+            kind: "writeTextFromFragments",
+            to: ".devcontainer/Dockerfile",
+            fragments: checkedNodePnpmDockerfileFragments({
+                additionalLayers: options.additionalLayers,
+            }),
         },
     };
 }
+export function dockerfileFirstRustPnpmDevcontainer(options) {
+    return checkedDockerfileFirstNodePnpmDevcontainer({
+        name: options.name,
+        layer: options.nodeLayer,
+        additionalLayers: [options.rustLayer],
+        extensions: options.extensions,
+        settings: options.settings,
+        mounts: [
+            "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
+            "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
+            "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume",
+        ],
+    });
+}

package/dist/src/editor-customization.d.ts

@@ -10,4 +10,3 @@ export type EditorCustomizationOptions = {
     };
 };
 export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], options?: EditorCustomizationOptions): EditorCustomization;
-//# sourceMappingURL=editor-customization.d.ts.map

package/dist/src/editor-customization.js

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 const capabilityOrder = [
     "oxc-format-lint",
     "vue",
@@ -5,13 +8,57 @@ const capabilityOrder = [
     "rust-tooling",
     "vitest",
 ];
-const oxcFormatterSettings = {
-    "editor.defaultFormatter": "oxc.oxc-vscode",
-};
 const defaultOxcConfigPaths = {
     formatter: "./oxfmt.config.ts",
     lint: "./oxlint.config.ts",
 };
+const declarations = loadEditorCustomizationDeclarations();
+function editorCustomizationDeclarationPath() {
+    const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+    const relativeDeclarationPath = "templates/shared/editor-customization/capabilities.json";
+    const candidates = [
+        path.resolve(moduleDirectory, "..", relativeDeclarationPath),
+        path.resolve(moduleDirectory, "..", "..", relativeDeclarationPath),
+    ];
+    const declarationPath = candidates.find((candidate) => existsSync(candidate));
+    if (!declarationPath) {
+        throw new Error(`Unable to find editor customization declarations at ${relativeDeclarationPath}`);
+    }
+    return declarationPath;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertCapabilityProjection(capability, value) {
+    if (!isRecord(value)) {
+        throw new Error(`Editor customization ${capability} must be an object`);
+    }
+    const extensions = value.extensions;
+    const settings = value.settings;
+    if (!Array.isArray(extensions) ||
+        extensions.some((extension) => typeof extension !== "string")) {
+        throw new Error(`Editor customization ${capability} must declare string extensions`);
+    }
+    if (!isRecord(settings)) {
+        throw new Error(`Editor customization ${capability} must declare object settings`);
+    }
+}
+function loadEditorCustomizationDeclarations() {
+    const source = JSON.parse(readFileSync(editorCustomizationDeclarationPath(), "utf8"));
+    if (!isRecord(source) || !isRecord(source.capabilities)) {
+        throw new Error("Editor customization declarations must contain capabilities");
+    }
+    const capabilities = source.capabilities;
+    for (const capability of capabilityOrder) {
+        assertCapabilityProjection(capability, capabilities[capability]);
+    }
+    return {
+        capabilities: Object.fromEntries(capabilityOrder.map((capability) => [
+            capability,
+            capabilities[capability],
+        ])),
+    };
+}
 function oxcConfigPathSettings(configPaths) {
     if (configPaths === "nested") {
         return {};
@@ -26,55 +73,15 @@ function oxcConfigPathSettings(configPaths) {
     };
 }
 function oxcProjection(options) {
+    const baseProjection = declarations.capabilities["oxc-format-lint"];
     return {
-        extensions: ["oxc.oxc-vscode"],
+        extensions: baseProjection.extensions,
         settings: {
-            "editor.codeActionsOnSave": {
-                "source.format.oxc": "always",
-                "source.fixAll.oxc": "always",
-            },
-            ...oxcFormatterSettings,
-            "editor.formatOnPaste": true,
-            "editor.formatOnSave": true,
-            "editor.formatOnSaveMode": "file",
-            "oxc.enable": true,
+            ...baseProjection.settings,
             ...oxcConfigPathSettings(options?.oxcConfigPaths),
-            "[javascript]": oxcFormatterSettings,
-            "[json]": oxcFormatterSettings,
-            "[markdown]": oxcFormatterSettings,
-            "[typescript]": oxcFormatterSettings,
         },
     };
 }
-const capabilityProjections = {
-    "oxc-format-lint": oxcProjection(),
-    "rust-tooling": {
-        extensions: ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"],
-        settings: {
-            "rust-analyzer.cargo.features": "all",
-            "rust-analyzer.check.command": "clippy",
-            "rust-analyzer.procMacro.enable": true,
-            "[rust]": {
-                "editor.defaultFormatter": "rust-lang.rust-analyzer",
-            },
-            "[toml]": {
-                "editor.defaultFormatter": "tamasfe.even-better-toml",
-            },
-        },
-    },
-    tailwind: {
-        extensions: ["bradlc.vscode-tailwindcss"],
-        settings: {},
-    },
-    vue: {
-        extensions: ["Vue.volar"],
-        settings: {},
-    },
-    vitest: {
-        extensions: ["vitest.explorer"],
-        settings: {},
-    },
-};
 function mergeSettings(base, patch) {
     return { ...base, ...patch };
 }
@@ -88,7 +95,7 @@ export function editorCustomizationForCapabilities(capabilities, options) {
         }
         const projection = capability === "oxc-format-lint"
             ? oxcProjection(options)
-            : capabilityProjections[capability];
+            : declarations.capabilities[capability];
         for (const extension of projection.extensions) {
             extensions.add(extension);
         }

package/dist/src/generation-context.d.ts

@@ -21,4 +21,3 @@ export type AssembleGenerationContextOptions = {
     readonly toolchain: ResolvedToolchainVersions;
 };
 export declare function assembleGenerationContext(options: AssembleGenerationContextOptions): GenerationContext;
-//# sourceMappingURL=generation-context.d.ts.map

package/dist/src/generation-context.js

@@ -1,7 +1,10 @@
 import path from "node:path";
 export function assembleGenerationContext(options) {
     return {
-        projectName: { kind: "ProjectName", value: path.basename(path.resolve(options.targetDir)) },
+        projectName: {
+            kind: "ProjectName",
+            value: path.basename(path.resolve(options.targetDir)),
+        },
         preset: options.blueprint.preset,
         packageManager: options.blueprint.packageManager
             ? { kind: "PackageManager", value: options.blueprint.packageManager }

package/dist/src/module-graph.d.ts

@@ -1,10 +1,14 @@
 export type PackageBoundaryOwner = {
     readonly kind: "package-boundary";
-    readonly path: "." | "apps/api" | "apps/web";
+    readonly path: string;
 };
-export type ComponentOwner = PackageBoundaryOwner;
-export type CheckComponentKind = "typescript-typecheck" | "oxc-lint" | "oxc-format-check" | "build" | "unit-test" | "e2e-test" | "turbo-check" | "rustfmt-check" | "cargo-clippy" | "cargo-test";
-export type FixComponentKind = "oxc-format-write" | "oxc-lint-fix" | "turbo-fix" | "rustfmt-write";
+export type WorkspaceOrchestrationOwner = {
+    readonly kind: "workspace-orchestration";
+    readonly path: ".";
+};
+export type ComponentOwner = PackageBoundaryOwner | WorkspaceOrchestrationOwner;
+export type CheckComponentKind = "typescript-typecheck" | "oxc-lint" | "oxc-format-check" | "build" | "unit-test" | "e2e-test" | "turbo-check" | "turbo-package-check" | "rustfmt-check" | "cargo-clippy" | "cargo-test";
+export type FixComponentKind = "oxc-format-write" | "oxc-lint-fix" | "turbo-fix" | "turbo-package-fix" | "rustfmt-write";
 export type CheckEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";
     readonly browser: "chromium";
@@ -28,4 +32,3 @@ export type FixPlan = {
 export declare function renderRootCheckCommand(plan: CheckPlan): string;
 export declare function renderFixCommand(plan: FixPlan): string;
 export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed): string;
-//# sourceMappingURL=module-graph.d.ts.map

package/dist/src/module-graph.js

@@ -1,3 +1,9 @@
+function renderTurboPackageFilter(owner) {
+    if (owner.kind !== "package-boundary") {
+        throw new Error("Turbo package tasks require a Package Boundary owner.");
+    }
+    return `--filter './${owner.path}'`;
+}
 function renderCheckComponentCommand(component) {
     switch (component.kind) {
         case "typescript-typecheck":
@@ -14,6 +20,8 @@ function renderCheckComponentCommand(component) {
             return "pnpm run test:e2e";
         case "turbo-check":
             return "turbo run check";
+        case "turbo-package-check":
+            return `turbo run check ${renderTurboPackageFilter(component.owner)}`;
         case "rustfmt-check":
             return "cargo fmt --all -- --check";
         case "cargo-clippy":
@@ -30,6 +38,8 @@ function renderFixComponentCommand(component) {
             return "pnpm run lint:fix";
         case "turbo-fix":
             return "turbo run fix";
+        case "turbo-package-fix":
+            return `turbo run fix ${renderTurboPackageFilter(component.owner)}`;
         case "rustfmt-write":
             return "cargo fmt --all";
     }

package/dist/src/next-step-instructions.d.ts

@@ -18,4 +18,3 @@ export type PlanNextStepInstructionsOptions = {
     readonly projectionPlan: PresetProjectionPlan;
 };
 export declare function planNextStepInstructions(options: PlanNextStepInstructionsOptions): NextStepInstructionPlan;
-//# sourceMappingURL=next-step-instructions.d.ts.map

package/dist/src/next-step-instructions.js

@@ -11,6 +11,40 @@ function rootCheckInstruction() {
         machineVerifiable: true,
     };
 }
+function optionalGitInstructions() {
+    return [
+        {
+            id: "optional-git-init",
+            label: "Optional: initialize git",
+            kind: "command",
+            command: "git",
+            args: ["init"],
+            cwd: "",
+            display: "git init",
+            machineVerifiable: false,
+        },
+        {
+            id: "optional-git-add",
+            label: "Optional: stage files",
+            kind: "command",
+            command: "git",
+            args: ["add", "."],
+            cwd: "",
+            display: "git add .",
+            machineVerifiable: false,
+        },
+        {
+            id: "optional-git-commit",
+            label: "Optional: create your first commit",
+            kind: "command",
+            command: "git",
+            args: ["commit", "-m", "Initial commit"],
+            cwd: "",
+            display: 'git commit -m "Initial commit"',
+            machineVerifiable: false,
+        },
+    ];
+}
 function installDependenciesInstruction() {
     return {
         id: "install-dependencies",
@@ -64,6 +98,7 @@ function projectionInstructions(plan) {
     if (plan.capabilities.rootCheck) {
         steps.push(rootCheckInstruction());
     }
+    steps.push(...optionalGitInstructions());
     return steps;
 }
 export function planNextStepInstructions(options) {

package/dist/src/package-addition.d.ts

@@ -2,6 +2,6 @@ export type AddPackageOptions = {
     cwd: string;
     preset: string;
     name: string;
+    path?: string;
 };
 export declare function addPackage(options: AddPackageOptions): Promise<void>;
-//# sourceMappingURL=package-addition.d.ts.map