@ykdz/template 0.0.2 → 0.0.4

package/dist/templates/rust-bin/projection.d.ts

@@ -0,0 +1,9 @@
+import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
+import { type CheckPlan, type FixPlan } from "../../src/module-graph.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
+export declare const rustBinPresetMetadata: BuiltInPreset;
+export declare function planRustBinChecks(): CheckPlan;
+export declare function planRustBinFixes(): FixPlan;
+export declare function rustBinBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectRustBinPackageScripts(): Record<string, string>;
+export declare const rustBinPresetProjection: PresetProjection;

package/dist/templates/rust-bin/projection.js

@@ -0,0 +1,390 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectGeneratedManifestCatalogDependencies, renderGeneratedPnpmWorkspaceYaml, } from "../../src/dependency-catalog.js";
+import { dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "../../src/devcontainer.js";
+import { editorCustomizationForCapabilities } from "../../src/editor-customization.js";
+import { renderFixCommand, renderRootCheckCommand, } from "../../src/module-graph.js";
+import { renderNewProject } from "../../src/renderer.js";
+const generatedBy = {
+    packageName: "@ykdz/template",
+    version: "0.0.0",
+    command: "template init --preset rust-bin",
+};
+export const rustBinPresetMetadata = {
+    name: "rust-bin",
+    title: "Rust binary",
+    description: "Rust native binary workspace with rustfmt, clippy, and cargo tests.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    features: [
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+        "rustfmt-clippy",
+        "cargo-test",
+    ],
+};
+const rustPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const rustWorkspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "packages/*",
+};
+function cargoPackageNameFromProjectName(projectName) {
+    const slug = projectName
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "rust-bin";
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function rustWorkspacePackageName(projectName) {
+    return `${cargoPackageNameFromProjectName(projectName)}-native`;
+}
+function rustWorkspacePackagePath(projectName) {
+    return `packages/${cargoPackageNameFromProjectName(projectName)}`;
+}
+function rustDependencyMaintenancePolicy(projectName) {
+    return {
+        ecosystems: ["npm", "cargo", "github-actions", "docker", "rust-toolchain"],
+        directories: {
+            cargo: `/${rustWorkspacePackagePath(projectName)}`,
+        },
+        interval: "weekly",
+    };
+}
+export function planRustBinChecks() {
+    return {
+        components: [
+            { kind: "rustfmt-check", owner: rustPackageBoundary },
+            { kind: "cargo-clippy", owner: rustPackageBoundary },
+            { kind: "cargo-test", owner: rustPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planRustBinRootChecks() {
+    return {
+        components: [
+            { kind: "turbo-package-check", owner: rustWorkspacePackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+export function planRustBinFixes() {
+    return {
+        components: [{ kind: "rustfmt-write", owner: rustPackageBoundary }],
+    };
+}
+function planRustBinRootFixes() {
+    return {
+        components: [
+            { kind: "turbo-package-fix", owner: rustWorkspacePackageBoundary },
+        ],
+    };
+}
+export function rustBinBlueprint(options = { targetDir: process.cwd() }) {
+    const projectName = projectNameFromDir(options.targetDir);
+    return {
+        schemaVersion: 1,
+        preset: "rust-bin",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...rustBinPresetMetadata.features],
+        packages: [
+            {
+                name: rustWorkspacePackageName(projectName),
+                path: rustWorkspacePackagePath(projectName),
+            },
+        ],
+    };
+}
+export function projectRustBinPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planRustBinChecks()),
+        fix: renderFixCommand(planRustBinFixes()),
+    };
+}
+function projectRustBinRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planRustBinRootChecks()),
+        fix: renderFixCommand(planRustBinRootFixes()),
+    };
+}
+function cargoToml(projectName) {
+    return [
+        "[package]",
+        `name = "${projectName}"`,
+        'version = "0.1.0"',
+        'edition = "2024"',
+        "",
+        "[dependencies]",
+        "",
+        "[lints]",
+        "workspace = true",
+        "",
+        "[workspace]",
+        'members = ["."]',
+        'resolver = "3"',
+        "",
+        "[workspace.lints.rust]",
+        'unsafe_code = "forbid"',
+        "",
+        "[workspace.lints.clippy]",
+        'all = "deny"',
+        'pedantic = "deny"',
+        'nursery = "deny"',
+        "",
+        "[profile.release]",
+        'strip = "symbols"',
+        'lto = "thin"',
+        "codegen-units = 1",
+        "",
+    ].join("\n");
+}
+function cargoLock(projectName) {
+    return [
+        "# This file is automatically @generated by Cargo.",
+        "# It is not intended for manual editing.",
+        "version = 4",
+        "",
+        "[[package]]",
+        `name = "${projectName}"`,
+        'version = "0.1.0"',
+        "",
+    ].join("\n");
+}
+function packageJson(context, projectName, packageScripts) {
+    return {
+        name: projectName,
+        version: "0.0.0",
+        private: true,
+        scripts: packageScripts,
+        devDependencies: {
+            turbo: "catalog:",
+        },
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
+function rustWorkspacePackageJson(context, projectName) {
+    return {
+        name: rustWorkspacePackageName(projectName),
+        version: "0.0.0",
+        private: true,
+        scripts: projectRustBinPackageScripts(),
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+    };
+}
+function generationRecord(context) {
+    return {
+        ...generatedBy,
+        toolchain: {
+            nodeLtsMajor: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+            source: context.toolchain.source,
+        },
+    };
+}
+function operationsForRustBin(context, devcontainerName, projectName, packageScripts, checkPlan) {
+    const editorCustomization = editorCustomizationForCapabilities([
+        "rust-tooling",
+    ]);
+    const rustLayer = rustToolLayer();
+    const developmentContainer = dockerfileFirstRustPnpmDevcontainer({
+        name: devcontainerName,
+        nodeLayer: nodePnpmToolLayer({
+            nodeVersion: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+        }),
+        rustLayer,
+        extensions: editorCustomization.extensions,
+        settings: editorCustomization.settings,
+    });
+    const dockerfileOperation = developmentContainer.dockerfileOperation;
+    if (dockerfileOperation === undefined) {
+        throw new Error("Rust Development Container Dockerfile must use fragments.");
+    }
+    const workspacePackagePath = rustWorkspacePackagePath(projectName);
+    const rootManifest = packageJson(context, projectName, packageScripts);
+    const packageManifest = rustWorkspacePackageJson(context, projectName);
+    const dependencyMaintenancePolicy = rustDependencyMaintenancePolicy(projectName);
+    return [
+        {
+            kind: "writeJson",
+            to: "package.json",
+            value: rootManifest,
+        },
+        {
+            kind: "writeText",
+            to: "pnpm-workspace.yaml",
+            text: renderGeneratedPnpmWorkspaceYaml({
+                packages: ["packages/*"],
+                dependencies: collectGeneratedManifestCatalogDependencies([
+                    rootManifest,
+                    packageManifest,
+                ]),
+            }),
+        },
+        {
+            kind: "writeJson",
+            to: "turbo.json",
+            value: {
+                tasks: {
+                    check: {},
+                    fix: {
+                        cache: false,
+                    },
+                },
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${workspacePackagePath}/package.json`,
+            value: packageManifest,
+        },
+        {
+            kind: "writeText",
+            to: `${workspacePackagePath}/Cargo.toml`,
+            text: cargoToml(projectName),
+        },
+        {
+            kind: "writeText",
+            to: `${workspacePackagePath}/Cargo.lock`,
+            text: cargoLock(projectName),
+        },
+        {
+            kind: "copyFile",
+            from: "rustfmt.toml",
+            to: `${workspacePackagePath}/rustfmt.toml`,
+        },
+        {
+            kind: "writeTextTemplate",
+            from: "rust-toolchain.toml",
+            to: "rust-toolchain.toml",
+            replacements: {
+                RUST_TOOLCHAIN: rustLayer.toolchain,
+            },
+        },
+        {
+            kind: "writeText",
+            to: ".gitignore",
+            text: ["target", ".env", ".template/", ".pnpm-store/", ""].join("\n"),
+        },
+        {
+            kind: "copyFile",
+            from: "src/main.rs",
+            to: `${workspacePackagePath}/src/main.rs`,
+        },
+        {
+            kind: "writeJson",
+            to: ".template/blueprint.json",
+            value: context.blueprint,
+        },
+        {
+            kind: "writeJson",
+            to: ".template/generated-by.json",
+            value: generationRecord(context),
+        },
+        {
+            kind: "writeJson",
+            to: ".devcontainer/devcontainer.json",
+            value: developmentContainer.devcontainer,
+        },
+        {
+            ...dockerfileOperation,
+        },
+        {
+            kind: "writeJson",
+            to: ".vscode/extensions.json",
+            value: {
+                recommendations: editorCustomization.extensions,
+            },
+        },
+        {
+            kind: "writeJson",
+            to: ".vscode/settings.json",
+            value: editorCustomization.settings,
+        },
+        {
+            kind: "copyFile",
+            from: ".github/workflows/check.yml",
+            to: ".github/workflows/check.yml",
+        },
+        {
+            kind: "writeTextTemplate",
+            from: ".github/dependabot.yml",
+            to: ".github/dependabot.yml",
+            replacements: {
+                CARGO_PACKAGE_DIRECTORY: dependencyMaintenancePolicy.directories?.cargo ??
+                    `/${workspacePackagePath}`,
+            },
+        },
+    ];
+}
+function templateSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedTemplateRoot = path.join(projectionDir, "..", "..", "..", "templates", "rust-bin");
+    return existsSync(path.join(publishedTemplateRoot, "src", "main.rs"))
+        ? publishedTemplateRoot
+        : projectionDir;
+}
+function sharedDevcontainerSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedSharedRoot = path.join(projectionDir, "..", "..", "..", "templates", "shared", "devcontainer");
+    return existsSync(path.join(publishedSharedRoot, "node-pnpm.Dockerfile"))
+        ? publishedSharedRoot
+        : path.join(projectionDir, "..", "shared", "devcontainer");
+}
+export const rustBinPresetProjection = {
+    metadata: rustBinPresetMetadata,
+    blueprint: rustBinBlueprint,
+    project(context) {
+        const checkPlan = planRustBinRootChecks();
+        const fixPlan = planRustBinRootFixes();
+        const packageScripts = projectRustBinRootPackageScripts();
+        const projectName = cargoPackageNameFromProjectName(context.projectName.value);
+        const devcontainerName = context.projectName.value;
+        const dependencyMaintenancePolicy = rustDependencyMaintenancePolicy(projectName);
+        return {
+            sourceRoot: templateSourceRoot(),
+            sourceRoots: {
+                sharedDevcontainer: sharedDevcontainerSourceRoot(),
+            },
+            operations: operationsForRustBin(context, devcontainerName, projectName, packageScripts, checkPlan),
+            checkPlan,
+            fixPlan,
+            dependencyMaintenancePolicy,
+            packageScripts,
+            capabilities: {
+                rootCheck: true,
+                fixCommand: true,
+                githubActions: true,
+                dependabot: true,
+                devcontainer: true,
+            },
+        };
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/dist/templates/ts-lib/projection.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
+export declare const tsLibPresetMetadata: BuiltInPreset;
+export declare function tsLibBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectTsLibPackageScripts(): Record<string, string>;
+export declare const tsLibPresetProjection: PresetProjection;