@ykdz/template 0.0.2 → 0.0.4

package/dist/src/dependency-catalog.js

@@ -0,0 +1,132 @@
+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;
+}
+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 ?? ["."];
+    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,58 @@
+import type { WriteTextFromFragmentsOperation } from "./renderer.js";
+export type DevelopmentContainerNodePnpmLayer = {
+    readonly kind: "node-pnpm";
+    readonly nodeVersion: string;
+    readonly packageManagerPin: string;
+};
+export type DevelopmentContainerBrowserTestLayer = {
+    readonly kind: "browser-test";
+    readonly playwrightCliPackage: string;
+};
+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>;
+}): DevelopmentContainerPlan;
+export {};

package/dist/src/devcontainer.js

@@ -0,0 +1,202 @@
+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 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 {
+        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 checkedDockerfileFirstNodePnpmDevcontainer(options) {
+    return {
+        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

@@ -0,0 +1,12 @@
+export type EditorCustomizationCapability = "oxc-format-lint" | "rust-tooling" | "tailwind" | "vue" | "vitest";
+export type EditorCustomization = {
+    readonly extensions: readonly string[];
+    readonly settings: Record<string, unknown>;
+};
+export type EditorCustomizationOptions = {
+    readonly oxcConfigPaths?: "nested" | {
+        readonly lint?: string;
+        readonly formatter?: string;
+    };
+};
+export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], options?: EditorCustomizationOptions): EditorCustomization;

package/dist/src/editor-customization.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const capabilityOrder = [
+    "oxc-format-lint",
+    "vue",
+    "tailwind",
+    "rust-tooling",
+    "vitest",
+];
+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 {};
+    }
+    const paths = {
+        ...defaultOxcConfigPaths,
+        ...configPaths,
+    };
+    return {
+        "oxc.configPath": paths.lint,
+        "oxc.fmt.configPath": paths.formatter,
+    };
+}
+function oxcProjection(options) {
+    const baseProjection = declarations.capabilities["oxc-format-lint"];
+    return {
+        extensions: baseProjection.extensions,
+        settings: {
+            ...baseProjection.settings,
+            ...oxcConfigPathSettings(options?.oxcConfigPaths),
+        },
+    };
+}
+function mergeSettings(base, patch) {
+    return { ...base, ...patch };
+}
+export function editorCustomizationForCapabilities(capabilities, options) {
+    const selected = new Set(capabilities);
+    const extensions = new Set();
+    let settings = {};
+    for (const capability of capabilityOrder) {
+        if (!selected.has(capability)) {
+            continue;
+        }
+        const projection = capability === "oxc-format-lint"
+            ? oxcProjection(options)
+            : declarations.capabilities[capability];
+        for (const extension of projection.extensions) {
+            extensions.add(extension);
+        }
+        settings = mergeSettings(settings, projection.settings);
+    }
+    return {
+        extensions: [...extensions],
+        settings,
+    };
+}

package/dist/{generation-context.d.ts → src/generation-context.d.ts}

@@ -1,4 +1,4 @@
-import type { PackageManager, PresetName, ProjectBlueprint } from "./declarations.js";
+import type { PackageManager, ProjectBlueprint } from "./declarations.js";
 import type { ResolvedToolchainVersions } from "./toolchain-resolution.js";
 export type ProjectName = {
     readonly kind: "ProjectName";
@@ -10,7 +10,7 @@ export type GenerationPackageManager = {
 };
 export type GenerationContext = {
     readonly projectName: ProjectName;
-    readonly preset: PresetName;
+    readonly preset: string;
     readonly packageManager?: GenerationPackageManager;
     readonly blueprint: ProjectBlueprint;
     readonly toolchain: ResolvedToolchainVersions;
@@ -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/{generation-context.js → 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

@@ -0,0 +1,34 @@
+export type PackageBoundaryOwner = {
+    readonly kind: "package-boundary";
+    readonly path: string;
+};
+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";
+    readonly owner: ComponentOwner;
+};
+export type CheckComponent = {
+    readonly kind: CheckComponentKind;
+    readonly owner: ComponentOwner;
+};
+export type FixComponent = {
+    readonly kind: FixComponentKind;
+    readonly owner: ComponentOwner;
+};
+export type CheckPlan = {
+    readonly components: CheckComponent[];
+    readonly environmentNeeds: CheckEnvironmentNeed[];
+};
+export type FixPlan = {
+    readonly components: FixComponent[];
+};
+export declare function renderRootCheckCommand(plan: CheckPlan): string;
+export declare function renderFixCommand(plan: FixPlan): string;
+export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed): string;

package/dist/src/module-graph.js

@@ -0,0 +1,58 @@
+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":
+            return "pnpm run typecheck";
+        case "oxc-lint":
+            return "pnpm run lint";
+        case "oxc-format-check":
+            return "pnpm run format:check";
+        case "build":
+            return "pnpm run build";
+        case "unit-test":
+            return "pnpm run test";
+        case "e2e-test":
+            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":
+            return "cargo clippy --workspace --all-targets -- -D warnings";
+        case "cargo-test":
+            return "cargo test --workspace";
+    }
+}
+function renderFixComponentCommand(component) {
+    switch (component.kind) {
+        case "oxc-format-write":
+            return "pnpm run format:write";
+        case "oxc-lint-fix":
+            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";
+    }
+}
+export function renderRootCheckCommand(plan) {
+    return plan.components.map(renderCheckComponentCommand).join(" && ");
+}
+export function renderFixCommand(plan) {
+    return plan.components.map(renderFixComponentCommand).join(" && ");
+}
+export function renderPlaywrightBrowserInstallCommand(need) {
+    if (need.owner.path === "apps/web") {
+        return `pnpm --filter ./apps/web exec playwright install ${need.browser}`;
+    }
+    return `pnpm exec playwright install ${need.browser}`;
+}

package/dist/{next-step-instructions.d.ts → src/next-step-instructions.d.ts}

@@ -1,4 +1,4 @@
-import type { PresetName } from "./declarations.js";
+import type { PresetProjectionPlan } from "./preset-projection.js";
 export type NextStepInstruction = {
     readonly id: string;
     readonly label: string;
@@ -10,13 +10,11 @@ export type NextStepInstruction = {
     readonly machineVerifiable: boolean;
 };
 export type NextStepInstructionPlan = {
-    readonly preset: PresetName;
     readonly targetDir: string;
     readonly steps: readonly NextStepInstruction[];
 };
 export type PlanNextStepInstructionsOptions = {
-    readonly preset: PresetName;
     readonly targetDir: string;
+    readonly projectionPlan: PresetProjectionPlan;
 };
 export declare function planNextStepInstructions(options: PlanNextStepInstructionsOptions): NextStepInstructionPlan;
-//# sourceMappingURL=next-step-instructions.d.ts.map