@ykdz/template 0.0.1 → 0.0.3

package/dist/src/project-github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-github.d.ts","sourceRoot":"","sources":["../../src/project-github.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9E,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,OAAO,GAAG,gBAAgB,CAAC;AAErE,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;CACpC,CAAC;AAaF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,MAAM,CAmDR;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,2BAA2B,GAClC,MAAM,CAYR"}

package/dist/src/project-github.js

@@ -0,0 +1,63 @@
+const defaultCiCapability = {
+    workflowName: "Check",
+    jobName: "check",
+    runner: "ubuntu-latest",
+};
+const pnpmTaskLayer = {
+    installCommand: "pnpm install",
+    checkCommand: "pnpm run check",
+};
+export function projectCheckWorkflow(options) {
+    const capability = options.capability ?? defaultCiCapability;
+    const environmentPreparation = {
+        nodeFromPackageMetadata: true,
+        rustToolchain: false,
+        ...options.environmentPreparation,
+    };
+    const taskLayer = options.taskLayer ?? pnpmTaskLayer;
+    const lines = [
+        `name: ${capability.workflowName}`,
+        "",
+        "on:",
+        "  pull_request:",
+        "  push:",
+        "    branches:",
+        "      - main",
+        "",
+        "jobs:",
+        `  ${capability.jobName}:`,
+        `    runs-on: ${capability.runner}`,
+        "    steps:",
+        "      - uses: actions/checkout@v6",
+    ];
+    if (environmentPreparation.nodeFromPackageMetadata) {
+        lines.push("      - uses: actions/setup-node@v6", "        with:", "          node-version-file: package.json", "      - run: corepack enable");
+    }
+    if (environmentPreparation.rustToolchain) {
+        lines.push("      - uses: dtolnay/rust-toolchain@stable", "        with:", "          components: rustfmt, clippy", "      - uses: Swatinem/rust-cache@v2");
+    }
+    lines.push(`      - run: ${taskLayer.installCommand}`);
+    lines.push(...options.checkPlan.environmentNeeds.map((need) => `      - run: ${renderCiEnvironmentNeedCommand(need)}`));
+    lines.push(`      - run: ${taskLayer.checkCommand}`, "");
+    return lines.join("\n");
+}
+export function projectDependabotConfig(policy) {
+    return [
+        "version: 2",
+        "updates:",
+        ...policy.ecosystems.flatMap((ecosystem) => [
+            `  - package-ecosystem: ${ecosystem}`,
+            "    directory: /",
+            "    schedule:",
+            `      interval: ${policy.interval}`,
+        ]),
+        "",
+    ].join("\n");
+}
+function renderCiEnvironmentNeedCommand(need) {
+    if (need.kind === "playwright-browser-assets" &&
+        need.owner.path === "apps/web") {
+        return `pnpm --filter ./apps/web exec playwright install --with-deps ${need.browser}`;
+    }
+    return `pnpm exec playwright install --with-deps ${need.browser}`;
+}

package/dist/src/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/renderer.ts"],"names":[],"mappings":"AAgBA,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,kBAAkB,GAClB,sBAAsB,GACtB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAmfF,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkChF;AAiCD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBnF"}

package/dist/{renderer.js → src/renderer.js}

@@ -169,9 +169,6 @@ function assertFoundationTextPath(relativePath) {
         ["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;
     }

package/dist/src/runtime-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function packageTemplateRoot(moduleDir: string, ...segments: string[]): string;
+//# sourceMappingURL=runtime-paths.d.ts.map

package/dist/src/runtime-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-paths.d.ts","sourceRoot":"","sources":["../../src/runtime-paths.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,GAAG,QAAQ,EAAE,MAAM,EAAE,GACpB,MAAM,CASR"}

package/dist/src/runtime-paths.js

@@ -0,0 +1,11 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+export function packageTemplateRoot(moduleDir, ...segments) {
+    const candidates = [
+        path.join(moduleDir, "..", "..", "templates", ...segments),
+        path.join(moduleDir, "..", "templates", ...segments),
+        path.join(moduleDir, "..", "..", "..", "templates", ...segments),
+    ];
+    const found = candidates.find((candidate) => existsSync(candidate));
+    return found ?? candidates[0];
+}

package/dist/src/toolchain-resolution.d.ts

@@ -0,0 +1,35 @@
+export type ToolchainResolutionSource = "online" | "bundled-fallback";
+export type NodeLtsMajor = {
+    readonly kind: "NodeLtsMajor";
+    readonly value: string;
+};
+export type PackageManagerPin = {
+    readonly kind: "PackageManagerPin";
+    readonly value: `pnpm@${string}`;
+};
+export type ResolvedToolchainVersions = {
+    readonly nodeLtsMajor: NodeLtsMajor;
+    readonly packageManagerPin: PackageManagerPin;
+    readonly source: ToolchainResolutionSource;
+    readonly diagnostics: string[];
+};
+export type ResolveToolchainVersionsOptions = {
+    readonly source?: ToolchainResolutionSource | "auto";
+    readonly fetchJson?: (url: string) => Promise<unknown>;
+    readonly nodeReleaseIndexUrl?: string;
+    readonly pnpmRegistryUrl?: string;
+};
+export declare const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
+export declare const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
+type OnlineToolchainResolutionContractOptions = {
+    readonly fetchJson?: (url: string) => Promise<unknown>;
+};
+export type OnlineToolchainResolutionContractResult = {
+    readonly nodeLtsMajor: NodeLtsMajor;
+    readonly packageManagerPin: PackageManagerPin;
+    readonly diagnostics: string[];
+};
+export declare function resolveToolchainVersions(options?: ResolveToolchainVersionsOptions): Promise<ResolvedToolchainVersions>;
+export declare function checkOnlineToolchainResolutionContract(options?: OnlineToolchainResolutionContractOptions): Promise<OnlineToolchainResolutionContractResult>;
+export {};
+//# sourceMappingURL=toolchain-resolution.d.ts.map

package/dist/src/toolchain-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolchain-resolution.d.ts","sourceRoot":"","sources":["../../src/toolchain-resolution.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,QAAQ,GAAG,kBAAkB,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,GAAG,MAAM,CAAC;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF,eAAO,MAAM,mBAAmB,uCAAuC,CAAC;AACxE,eAAO,MAAM,eAAe,oCAAoC,CAAC;AAEjE,KAAK,wCAAwC,GAAG;IAC9C,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAmBF,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,yBAAyB,CAAC,CAiCpC;AAED,wBAAsB,sCAAsC,CAC1D,OAAO,GAAE,wCAA6C,GACrD,OAAO,CAAC,uCAAuC,CAAC,CAwBlD"}

package/dist/src/toolchain-resolution.js

@@ -0,0 +1,192 @@
+export const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
+export const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
+const bundledFallbackToolchain = {
+    nodeLtsMajor: nodeLtsMajor("24"),
+    packageManagerPin: packageManagerPin("10.0.0"),
+};
+export async function resolveToolchainVersions(options = {}) {
+    const source = options.source ?? "online";
+    if (source === "bundled-fallback") {
+        return fallbackResult([]);
+    }
+    try {
+        const fetchJson = options.fetchJson ?? fetchOfficialJson;
+        const nodeReleases = parseNodeReleaseIndex(await fetchJson(options.nodeReleaseIndexUrl ?? nodeReleaseIndexUrl));
+        const nodeMajor = latestLtsMajor(nodeReleases);
+        const pnpmMetadata = parsePnpmRegistryMetadata(await fetchJson(options.pnpmRegistryUrl ?? pnpmRegistryUrl));
+        const pnpmVersion = latestCompatiblePnpmVersion(pnpmMetadata, Number(nodeMajor.value));
+        return {
+            nodeLtsMajor: nodeMajor,
+            packageManagerPin: packageManagerPin(pnpmVersion),
+            source: "online",
+            diagnostics: [],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return fallbackResult([
+            `Using bundled fallback toolchain metadata because online resolution failed: ${message}`,
+        ]);
+    }
+}
+export async function checkOnlineToolchainResolutionContract(options = {}) {
+    const fetchJson = options.fetchJson ?? fetchOfficialJson;
+    const nodeMajor = await contractPhase("Node source parsing", async () => {
+        const nodeReleases = parseNodeReleaseIndex(await fetchJson(nodeReleaseIndexUrl));
+        return latestLtsMajor(nodeReleases);
+    });
+    const pnpmMetadata = await contractPhase("pnpm source parsing", async () => parsePnpmRegistryMetadata(await fetchJson(pnpmRegistryUrl)));
+    const pnpmVersion = await contractPhase("compatibility selection", async () => latestCompatiblePnpmVersion(pnpmMetadata, Number(nodeMajor.value)));
+    return {
+        nodeLtsMajor: nodeMajor,
+        packageManagerPin: packageManagerPin(pnpmVersion),
+        diagnostics: [
+            `Node source parsing succeeded; latest LTS major is ${nodeMajor.value}.`,
+            `pnpm source parsing succeeded; latest compatible pnpm release is ${pnpmVersion}.`,
+            `Compatibility selection succeeded for pnpm@${pnpmVersion} on Node ${nodeMajor.value}.`,
+        ],
+    };
+}
+async function contractPhase(phase, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Online toolchain resolution contract failed during ${phase}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+    }
+}
+function fallbackResult(diagnostics) {
+    return {
+        nodeLtsMajor: bundledFallbackToolchain.nodeLtsMajor,
+        packageManagerPin: bundledFallbackToolchain.packageManagerPin,
+        source: "bundled-fallback",
+        diagnostics,
+    };
+}
+function nodeLtsMajor(value) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`Invalid Node LTS major: ${value}`);
+    }
+    return { kind: "NodeLtsMajor", value };
+}
+function packageManagerPin(version) {
+    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error(`Invalid pnpm version: ${version}`);
+    }
+    return { kind: "PackageManagerPin", value: `pnpm@${version}` };
+}
+async function fetchOfficialJson(url) {
+    const response = await fetch(url, {
+        headers: { accept: "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`GET ${url} failed with HTTP ${response.status}`);
+    }
+    return response.json();
+}
+function parseNodeReleaseIndex(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("Node release index was not an array");
+    }
+    return value.map((entry) => {
+        if (!isRecord(entry)) {
+            throw new Error("Node release entry was not an object");
+        }
+        const version = entry.version;
+        const lts = entry.lts;
+        if (typeof version !== "string" ||
+            (typeof lts !== "string" && typeof lts !== "boolean")) {
+            throw new Error("Node release entry is missing version or lts");
+        }
+        return { version, lts };
+    });
+}
+function latestLtsMajor(releases) {
+    const majors = releases
+        .filter((release) => release.lts !== false)
+        .map((release) => release.version.match(/^v(\d+)\./)?.[1])
+        .filter((major) => major !== undefined)
+        .map(Number);
+    if (majors.length === 0) {
+        throw new Error("Node release index did not contain any LTS releases");
+    }
+    return nodeLtsMajor(String(Math.max(...majors)));
+}
+function parsePnpmRegistryMetadata(value) {
+    if (!isRecord(value) || !isRecord(value.versions)) {
+        throw new Error("pnpm registry metadata is missing versions");
+    }
+    const versions = {};
+    for (const [version, metadata] of Object.entries(value.versions)) {
+        if (!isRecord(metadata)) {
+            continue;
+        }
+        versions[version] = {
+            engines: isRecord(metadata.engines)
+                ? {
+                    node: typeof metadata.engines.node === "string"
+                        ? metadata.engines.node
+                        : undefined,
+                }
+                : undefined,
+        };
+    }
+    return { versions };
+}
+function latestCompatiblePnpmVersion(metadata, nodeMajor) {
+    const candidates = Object.entries(metadata.versions)
+        .filter(([version]) => /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+        .filter(([, packageMetadata]) => nodeSatisfiesRange(nodeMajor, packageMetadata.engines?.node))
+        .map(([version]) => version)
+        .sort(compareSemver);
+    const latest = candidates.at(-1);
+    if (!latest) {
+        throw new Error(`pnpm registry metadata did not contain a release compatible with Node ${nodeMajor}`);
+    }
+    return latest;
+}
+function nodeSatisfiesRange(nodeMajor, range) {
+    if (!range) {
+        return true;
+    }
+    return range
+        .split(/\s+/)
+        .filter(Boolean)
+        .every((comparator) => nodeSatisfiesComparator(nodeMajor, comparator));
+}
+function nodeSatisfiesComparator(nodeMajor, comparator) {
+    const match = comparator.match(/^(>=|>|<=|<|=)?(\d+)(?:\.\d+){0,2}$/);
+    if (!match) {
+        return false;
+    }
+    const operator = match[1] ?? "=";
+    const major = Number(match[2]);
+    if (operator === ">=") {
+        return nodeMajor >= major;
+    }
+    if (operator === ">") {
+        return nodeMajor > major;
+    }
+    if (operator === "<=") {
+        return nodeMajor <= major;
+    }
+    if (operator === "<") {
+        return nodeMajor < major;
+    }
+    return nodeMajor === major;
+}
+function compareSemver(left, right) {
+    const leftParts = left.split(/[.-]/).slice(0, 3).map(Number);
+    const rightParts = right.split(/[.-]/).slice(0, 3).map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return left.localeCompare(right);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/templates/hono-api/projection.d.ts

@@ -0,0 +1,7 @@
+import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
+import type { PresetProjection } from "../../src/preset-projection.js";
+export declare const honoApiPresetMetadata: BuiltInPreset;
+export declare function honoApiBlueprint(): ProjectBlueprint;
+export declare function projectHonoApiPackageScripts(): Record<string, string>;
+export declare const honoApiPresetProjection: PresetProjection;
+//# sourceMappingURL=projection.d.ts.map

package/dist/templates/hono-api/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../templates/hono-api/projection.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAUnC,OAAO,KAAK,EAGV,gBAAgB,EAEjB,MAAM,gCAAgC,CAAC;AAexC,eAAO,MAAM,qBAAqB,EAAE,aAiBnC,CAAC;AAOF,wBAAgB,gBAAgB,IAAI,gBAAgB,CAQnD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAarE;AAoUD,eAAO,MAAM,uBAAuB,EAAE,gBA4CrC,CAAC"}