@ykdz/template 0.0.0

package/dist/renderer.js

@@ -0,0 +1,379 @@
+import { constants } from "node:fs";
+import { chmod, copyFile, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+function expandTemplatePath(templatePath, variables) {
+    return templatePath.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_, name) => {
+        const value = variables[name];
+        if (!value) {
+            throw new Error(`Missing renderer variable: ${name}`);
+        }
+        if (!/^[A-Za-z0-9._-]+$/.test(value)) {
+            throw new Error(`Renderer variable ${name} is not safe for a path segment`);
+        }
+        return value;
+    });
+}
+function resolveContainedPath(root, relativePath) {
+    if (path.isAbsolute(relativePath)) {
+        throw new Error(`Renderer paths must be relative: ${relativePath}`);
+    }
+    const resolvedRoot = path.resolve(root);
+    const resolvedPath = path.resolve(resolvedRoot, relativePath);
+    const insideRoot = resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+    if (!insideRoot) {
+        throw new Error(`Renderer path escapes its root: ${relativePath}`);
+    }
+    return resolvedPath;
+}
+function expandOperationPath(relativePath, options) {
+    return expandTemplatePath(relativePath, options.variables ?? {});
+}
+async function renderCopyFile(operation, options) {
+    const variables = options.variables ?? {};
+    const from = resolveContainedPath(options.sourceRoot, expandTemplatePath(operation.from, variables));
+    const to = resolveContainedPath(options.targetRoot, expandTemplatePath(operation.to, variables));
+    const sourceMode = (await stat(from)).mode;
+    await mkdir(path.dirname(to), { recursive: true });
+    await copyGeneratedFile(from, to);
+    await chmod(to, sourceMode & 0o777);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isScalarJsonValue(value) {
+    return value === null || ["boolean", "number", "string"].includes(typeof value);
+}
+function serializeJsonValue(value, indentation, pathSegments, multilineArrays, rootKeyOrder) {
+    if (Array.isArray(value)) {
+        const compact = `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+        const shouldCompact = value.every(isScalarJsonValue) &&
+            !multilineArrays.has(pathSegments.join(".")) &&
+            indentation + compact.length <= 100;
+        if (shouldCompact) {
+            return compact;
+        }
+        const items = value.map((item, index) => `${" ".repeat(indentation + 2)}${serializeJsonValue(item, indentation + 2, [...pathSegments, String(index)], multilineArrays, rootKeyOrder)}`);
+        return `[\n${items.join(",\n")}\n${" ".repeat(indentation)}]`;
+    }
+    if (!isRecord(value)) {
+        return JSON.stringify(value);
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => compareJsonKeys(left, right, pathSegments, rootKeyOrder));
+    if (entries.length === 0) {
+        return "{}";
+    }
+    return ("{\n" +
+        entries
+            .map(([key, entryValue]) => `${" ".repeat(indentation + 2)}${JSON.stringify(key)}: ${serializeJsonValue(entryValue, indentation + 2, [...pathSegments, key], multilineArrays, rootKeyOrder)}`)
+            .join(",\n") +
+        `\n${" ".repeat(indentation)}}`);
+}
+const packageJsonRootKeyOrder = [
+    "name",
+    "version",
+    "private",
+    "files",
+    "type",
+    "types",
+    "exports",
+    "scripts",
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+    "engines",
+    "packageManager"
+];
+function compareJsonKeys(left, right, pathSegments, rootKeyOrder) {
+    if (pathSegments.length === 0 && rootKeyOrder) {
+        const leftOrder = rootKeyOrder.get(left) ?? Number.POSITIVE_INFINITY;
+        const rightOrder = rootKeyOrder.get(right) ?? Number.POSITIVE_INFINITY;
+        if (leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+    }
+    return left.localeCompare(right);
+}
+function rootKeyOrderForPath(toPath) {
+    if (path.basename(toPath) !== "package.json") {
+        return undefined;
+    }
+    return new Map(packageJsonRootKeyOrder.map((key, index) => [key, index]));
+}
+function serializeJson(value, multilineArrays = [], rootKeyOrder) {
+    return `${serializeJsonValue(value, 0, [], new Set(multilineArrays), rootKeyOrder)}\n`;
+}
+function mergeJsonValue(base, patch) {
+    if (!isRecord(base) || !isRecord(patch)) {
+        return patch;
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        result[key] = key in result ? mergeJsonValue(result[key], value) : value;
+    }
+    return result;
+}
+async function writeJsonFile(targetRoot, toPath, value, multilineArrays, overwrite = false) {
+    const to = resolveContainedPath(targetRoot, toPath);
+    await mkdir(path.dirname(to), { recursive: true });
+    await writeGeneratedFile(to, serializeJson(value, multilineArrays, rootKeyOrderForPath(toPath)), overwrite);
+}
+async function renderWriteJson(operation, options) {
+    await writeJsonFile(options.targetRoot, expandOperationPath(operation.to, options), operation.value, operation.multilineArrays);
+}
+async function renderMergeJson(operation, options) {
+    const toPath = expandOperationPath(operation.to, options);
+    const to = resolveContainedPath(options.targetRoot, toPath);
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(to, "utf8"));
+    }
+    catch (error) {
+        if (!isNodeError(error) || error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    await writeJsonFile(options.targetRoot, toPath, mergeJsonValue(existing, operation.value), undefined, true);
+}
+const foundationTextFiles = new Set([
+    ".dockerignore",
+    ".env.example",
+    ".gitattributes",
+    ".gitignore",
+    ".npmignore",
+    ".npmrc",
+    "README",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+]);
+function assertFoundationTextPath(relativePath) {
+    const normalizedPath = relativePath.split(path.sep).join("/");
+    const isRootLevel = !normalizedPath.includes("/");
+    if (isRootLevel && foundationTextFiles.has(normalizedPath)) {
+        return;
+    }
+    if (isRootLevel && relativePath.endsWith(".md")) {
+        return;
+    }
+    if (isRootLevel && (relativePath.endsWith(".yaml") || relativePath.endsWith(".yml"))) {
+        return;
+    }
+    if (isRootLevel &&
+        ["Cargo.toml", "Cargo.lock", "rustfmt.toml"].includes(normalizedPath)) {
+        return;
+    }
+    if (normalizedPath === "scripts/check") {
+        return;
+    }
+    if (/^\.github\/workflows\/[A-Za-z0-9._-]+\.ya?ml$/.test(normalizedPath)) {
+        return;
+    }
+    if (/^\.github\/dependabot\.ya?ml$/.test(normalizedPath)) {
+        return;
+    }
+    throw new Error(`Text output is limited to foundation files: ${relativePath}`);
+}
+async function renderWriteText(operation, options) {
+    const toPath = expandOperationPath(operation.to, options);
+    assertFoundationTextPath(toPath);
+    const to = resolveContainedPath(options.targetRoot, toPath);
+    await mkdir(path.dirname(to), { recursive: true });
+    await writeGeneratedFile(to, operation.text);
+}
+async function renderSetExecutable(operation, options) {
+    const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
+    const currentMode = (await stat(filePath)).mode;
+    const executeBits = 0o111;
+    const mode = operation.executable
+        ? currentMode | executeBits
+        : currentMode & ~executeBits;
+    await chmod(filePath, mode & 0o777);
+}
+function parseAnchorComment(commentText) {
+    const singleLine = commentText.match(/^\/\/\s*@template-anchor\s+([A-Za-z][A-Za-z0-9_-]*)\s*$/);
+    if (singleLine) {
+        return singleLine[1];
+    }
+    const multiline = commentText.match(/^\/\*\s*@template-anchor\s+([A-Za-z][A-Za-z0-9_-]*)\s*\*\/$/);
+    return multiline?.[1];
+}
+async function findTypeScriptAnchorRanges(sourceText) {
+    const ts = await import("typescript");
+    const sourceFile = ts.createSourceFile("template-anchor.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const anchors = [];
+    const seenRanges = new Set();
+    if ((sourceFile.parseDiagnostics ?? []).length > 0) {
+        throw new Error("Checked Transform Anchor requires valid TypeScript source");
+    }
+    function collectNodeAnchors(node) {
+        if (node.kind === ts.SyntaxKind.EndOfFileToken) {
+            return;
+        }
+        const comments = ts.getLeadingCommentRanges(sourceText, node.getFullStart()) ?? [];
+        for (const comment of comments) {
+            const name = parseAnchorComment(sourceText.slice(comment.pos, comment.end));
+            const rangeKey = `${comment.pos}:${comment.end}`;
+            if (name === undefined || seenRanges.has(rangeKey)) {
+                continue;
+            }
+            seenRanges.add(rangeKey);
+            anchors.push({
+                name,
+                start: comment.pos,
+                end: comment.end
+            });
+        }
+        ts.forEachChild(node, collectNodeAnchors);
+    }
+    ts.forEachChild(sourceFile, collectNodeAnchors);
+    return anchors;
+}
+function replaceRanges(sourceText, ranges, replacements) {
+    let nextText = sourceText;
+    for (const range of [...ranges].sort((a, b) => b.start - a.start)) {
+        const replacement = replacements[range.name];
+        if (replacement === undefined) {
+            continue;
+        }
+        nextText = `${nextText.slice(0, range.start)}${replacement}${nextText.slice(range.end)}`;
+    }
+    return nextText;
+}
+async function renderReplaceAnchors(operation, options) {
+    if (operation.language !== "typescript") {
+        throw new Error("Checked Transform Anchor only supports TypeScript");
+    }
+    const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
+    const sourceText = await readFile(filePath, "utf8");
+    const ranges = await findTypeScriptAnchorRanges(sourceText);
+    for (const anchorName of Object.keys(operation.replacements)) {
+        const matches = ranges.filter((range) => range.name === anchorName);
+        if (matches.length === 0) {
+            throw new Error(`Missing Checked Transform Anchor: ${anchorName}`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`Duplicate Checked Transform Anchor: ${anchorName}`);
+        }
+    }
+    await writeFile(filePath, replaceRanges(sourceText, ranges, operation.replacements), "utf8");
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+async function targetDirectoryStatus(targetRoot) {
+    try {
+        const targetStat = await stat(targetRoot);
+        if (!targetStat.isDirectory()) {
+            throw new Error(`Target path is not a directory: ${targetRoot}`);
+        }
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return "missing";
+        }
+        throw error;
+    }
+    const entries = await readdir(targetRoot);
+    if (entries.length > 0) {
+        throw new Error(`Target directory is not empty: ${targetRoot}`);
+    }
+    return "empty";
+}
+async function copyGeneratedFile(from, to) {
+    try {
+        await copyFile(from, to, constants.COPYFILE_EXCL);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "EEXIST") {
+            throw new Error(`Refusing to overwrite existing file: ${to}`);
+        }
+        throw error;
+    }
+}
+async function writeGeneratedFile(to, text, overwrite = false) {
+    try {
+        await writeFile(to, text, { encoding: "utf8", flag: overwrite ? "w" : "wx" });
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "EEXIST") {
+            throw new Error(`Refusing to overwrite existing file: ${to}`);
+        }
+        throw error;
+    }
+}
+export async function renderProject(options) {
+    for (const operation of options.operations) {
+        if (operation.kind === "copyFile") {
+            await renderCopyFile(operation, options);
+            continue;
+        }
+        if (operation.kind === "writeJson") {
+            await renderWriteJson(operation, options);
+            continue;
+        }
+        if (operation.kind === "mergeJson") {
+            await renderMergeJson(operation, options);
+            continue;
+        }
+        if (operation.kind === "writeText") {
+            await renderWriteText(operation, options);
+            continue;
+        }
+        if (operation.kind === "setExecutable") {
+            await renderSetExecutable(operation, options);
+            continue;
+        }
+        if (operation.kind === "replaceAnchors") {
+            await renderReplaceAnchors(operation, options);
+            continue;
+        }
+        throw new Error(`Unsupported renderer operation: ${operation.kind}`);
+    }
+}
+async function commitStagedProject(stagingRoot, targetRoot) {
+    const targetStatus = await targetDirectoryStatus(targetRoot);
+    if (targetStatus === "empty") {
+        try {
+            await rmdir(targetRoot);
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                // The target disappeared between the emptiness check and commit.
+            }
+            else if (isNodeError(error) && error.code === "ENOTEMPTY") {
+                throw new Error(`Target directory is not empty: ${targetRoot}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    try {
+        await rename(stagingRoot, targetRoot);
+    }
+    catch (error) {
+        if (isNodeError(error) &&
+            ["EEXIST", "ENOTEMPTY", "ENOTDIR", "EISDIR"].includes(error.code ?? "")) {
+            throw new Error(`Refusing to overwrite existing target: ${targetRoot}`);
+        }
+        throw error;
+    }
+}
+export async function renderNewProject(options) {
+    const targetRoot = path.resolve(options.targetRoot);
+    await targetDirectoryStatus(targetRoot);
+    await mkdir(path.dirname(targetRoot), { recursive: true });
+    const stagingRoot = await mkdtemp(path.join(path.dirname(targetRoot), `.${path.basename(targetRoot)}.template-stage-`));
+    let committed = false;
+    try {
+        await renderProject({ ...options, targetRoot: stagingRoot });
+        await commitStagedProject(stagingRoot, targetRoot);
+        committed = true;
+    }
+    finally {
+        if (!committed) {
+            await rm(stagingRoot, { recursive: true, force: true });
+        }
+    }
+}

package/dist/rust-bin.d.ts

@@ -0,0 +1,2 @@
+export declare function initRustBinProject(targetDir: string): Promise<void>;
+//# sourceMappingURL=rust-bin.d.ts.map

package/dist/rust-bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-bin.d.ts","sourceRoot":"","sources":["../src/rust-bin.ts"],"names":[],"mappings":"AAgNA,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMzE"}

package/dist/rust-bin.js

@@ -0,0 +1,206 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderNewProject } from "./renderer.js";
+const features = [
+    "root-check",
+    "fix-command",
+    "devcontainer",
+    "github-actions",
+    "dependabot",
+    "rustfmt-clippy",
+    "cargo-test"
+];
+const generatedBy = {
+    packageName: "@ykdz/template",
+    version: "0.0.0",
+    command: "template init --preset rust-bin"
+};
+function cargoPackageNameFromDir(targetDir) {
+    const directoryName = path.basename(path.resolve(targetDir));
+    const slug = directoryName
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "rust-bin";
+}
+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 operationsForRustBin(projectName) {
+    return [
+        {
+            kind: "writeText",
+            to: "Cargo.toml",
+            text: cargoToml(projectName)
+        },
+        {
+            kind: "writeText",
+            to: "Cargo.lock",
+            text: cargoLock(projectName)
+        },
+        {
+            kind: "writeText",
+            to: "rustfmt.toml",
+            text: ['edition = "2024"', "max_width = 100", ""].join("\n")
+        },
+        {
+            kind: "writeText",
+            to: ".gitignore",
+            text: ["target", ".env", ""].join("\n")
+        },
+        {
+            kind: "copyFile",
+            from: "src/main.rs",
+            to: "src/main.rs"
+        },
+        {
+            kind: "writeText",
+            to: "scripts/check",
+            text: [
+                "#!/usr/bin/env sh",
+                "set -eu",
+                "",
+                "echo cargo fmt --all -- --check",
+                "cargo fmt --all -- --check",
+                "echo cargo clippy --workspace --all-targets -- -D warnings",
+                "cargo clippy --workspace --all-targets -- -D warnings",
+                "echo cargo test --workspace",
+                "cargo test --workspace",
+                ""
+            ].join("\n")
+        },
+        {
+            kind: "setExecutable",
+            path: "scripts/check",
+            executable: true
+        },
+        {
+            kind: "writeJson",
+            to: ".project-kit/blueprint.json",
+            value: {
+                schemaVersion: 1,
+                preset: "rust-bin",
+                projectKind: "single-package",
+                features
+            }
+        },
+        {
+            kind: "writeJson",
+            to: ".project-kit/generated-by.json",
+            value: generatedBy
+        },
+        {
+            kind: "writeJson",
+            to: ".devcontainer/devcontainer.json",
+            value: {
+                name: `${projectName} Rust development`,
+                image: "mcr.microsoft.com/devcontainers/rust:1",
+                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"
+                ],
+                postCreateCommand: "rustup component add rustfmt clippy && cargo fetch",
+                customizations: {
+                    vscode: {
+                        extensions: ["rust-lang.rust-analyzer", "tamasfe.even-better-toml"]
+                    }
+                }
+            }
+        },
+        {
+            kind: "writeText",
+            to: ".github/workflows/check.yml",
+            text: [
+                "name: Check",
+                "",
+                "on:",
+                "  pull_request:",
+                "  push:",
+                "    branches:",
+                "      - main",
+                "",
+                "jobs:",
+                "  check:",
+                "    runs-on: ubuntu-latest",
+                "    steps:",
+                "      - uses: actions/checkout@v4",
+                "      - uses: dtolnay/rust-toolchain@stable",
+                "        with:",
+                "          components: rustfmt, clippy",
+                "      - uses: Swatinem/rust-cache@v2",
+                "      - run: ./scripts/check",
+                ""
+            ].join("\n")
+        },
+        {
+            kind: "writeText",
+            to: ".github/dependabot.yml",
+            text: [
+                "version: 2",
+                "updates:",
+                "  - package-ecosystem: cargo",
+                "    directory: /",
+                "    schedule:",
+                "      interval: weekly",
+                "  - package-ecosystem: github-actions",
+                "    directory: /",
+                "    schedule:",
+                "      interval: weekly",
+                ""
+            ].join("\n")
+        }
+    ];
+}
+function templateSourceRoot() {
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "rust-bin");
+}
+export async function initRustBinProject(targetDir) {
+    await renderNewProject({
+        sourceRoot: templateSourceRoot(),
+        targetRoot: targetDir,
+        operations: operationsForRustBin(cargoPackageNameFromDir(targetDir))
+    });
+}

package/dist/ts-lib.d.ts

@@ -0,0 +1,2 @@
+export declare function initTsLibProject(targetDir: string): Promise<void>;
+//# sourceMappingURL=ts-lib.d.ts.map

package/dist/ts-lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-lib.d.ts","sourceRoot":"","sources":["../src/ts-lib.ts"],"names":[],"mappings":"AA2NA,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMvE"}