@ykdz/template 0.0.2 → 0.0.3

package/dist/templates/hono-api/projection.js

@@ -0,0 +1,377 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderGeneratedPnpmWorkspaceYaml } from "../../src/dependency-catalog.js";
+import { nodePnpmDevcontainer } from "../../src/devcontainer.js";
+import { editorCustomizationForCapabilities } from "../../src/editor-customization.js";
+import { renderFixCommand, renderRootCheckCommand, } from "../../src/module-graph.js";
+import { projectCheckWorkflow, projectDependabotConfig, } from "../../src/project-github.js";
+import { renderNewProject } from "../../src/renderer.js";
+import { planNodeChecks, planNodeFixes } from "../projection-plans.js";
+const generatedBy = {
+    packageName: "@ykdz/template",
+    version: "0.0.0",
+    command: "template init --preset hono-api",
+};
+export const honoApiPresetMetadata = {
+    name: "hono-api",
+    title: "Hono API",
+    description: "Single-package Hono Node API with strict TypeScript tooling.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["single-package"],
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const dependencyMaintenancePolicy = {
+    ecosystems: ["npm", "github-actions"],
+    interval: "weekly",
+};
+export function honoApiBlueprint() {
+    return {
+        schemaVersion: 1,
+        preset: "hono-api",
+        packageManager: "pnpm",
+        projectKind: "single-package",
+        features: [...honoApiPresetMetadata.features],
+    };
+}
+export function projectHonoApiPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+        check: renderRootCheckCommand(planNodeChecks("hono-api")),
+        fix: renderFixCommand(planNodeFixes("hono-api")),
+        "format:check": "oxfmt --check .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint . --deny-warnings",
+        "lint:fix": "oxlint . --fix --deny-warnings",
+        start: "node dist/server.js",
+        test: "vitest run",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
+function packageJson(context, packageScripts) {
+    return {
+        name: context.projectName.value,
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        scripts: packageScripts,
+        dependencies: {
+            "@hono/node-server": "catalog:",
+            hono: "catalog:",
+        },
+        devDependencies: {
+            "@types/node": "catalog:",
+            oxfmt: "catalog:",
+            oxlint: "catalog:",
+            "tsc-alias": "catalog:",
+            typescript: "catalog:",
+            vitest: "catalog:",
+        },
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
+function generationRecord(context) {
+    return {
+        ...generatedBy,
+        toolchain: {
+            nodeLtsMajor: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+            source: context.toolchain.source,
+        },
+    };
+}
+function operationsForHonoApi(context, packageScripts, checkPlan) {
+    const editorCustomization = editorCustomizationForCapabilities([
+        "oxc-format-lint",
+        "vitest",
+    ]);
+    return [
+        {
+            kind: "writeJson",
+            to: "package.json",
+            value: packageJson(context, packageScripts),
+        },
+        {
+            kind: "writeText",
+            to: "pnpm-workspace.yaml",
+            text: renderGeneratedPnpmWorkspaceYaml({
+                dependencies: [
+                    "@hono/node-server",
+                    "@types/node",
+                    "hono",
+                    "oxfmt",
+                    "oxlint",
+                    "tsc-alias",
+                    "typescript",
+                    "vitest",
+                ],
+            }),
+        },
+        {
+            kind: "writeJson",
+            to: "tsconfig.json",
+            value: {
+                compilerOptions: {
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    noEmitOnError: true,
+                    paths: {
+                        "@/*": ["./src/*"],
+                    },
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "ES2022",
+                    types: ["node", "vitest/globals"],
+                },
+                include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: "tsconfig.build.json",
+            value: {
+                extends: "./tsconfig.json",
+                compilerOptions: {
+                    outDir: "dist",
+                    rootDir: "src",
+                    types: ["node"],
+                },
+                include: ["src/**/*.ts"],
+            },
+        },
+        {
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "node/oxlint.config.ts",
+            to: "oxlint.config.ts",
+        },
+        {
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: "oxfmt.config.ts",
+        },
+        {
+            kind: "writeText",
+            to: ".gitignore",
+            text: ["node_modules", "dist", ".env", ""].join("\n"),
+        },
+        { kind: "copyFile", from: "src/app.ts", to: "src/app.ts" },
+        { kind: "copyFile", from: "src/server.ts", to: "src/server.ts" },
+        { kind: "copyFile", from: "test/app.test.ts", to: "test/app.test.ts" },
+        { kind: "copyFile", from: "vitest.config.ts", to: "vitest.config.ts" },
+        {
+            kind: "writeJson",
+            to: ".project-kit/blueprint.json",
+            value: honoApiBlueprint(),
+        },
+        {
+            kind: "writeJson",
+            to: ".project-kit/generated-by.json",
+            value: generationRecord(context),
+        },
+        {
+            kind: "writeJson",
+            to: ".devcontainer/devcontainer.json",
+            value: nodePnpmDevcontainer({
+                name: `${context.projectName.value} API development`,
+                nodeVersion: context.toolchain.nodeLtsMajor.value,
+                packageManagerPin: context.toolchain.packageManagerPin.value,
+                extensions: editorCustomization.extensions,
+                settings: editorCustomization.settings,
+            }),
+        },
+        {
+            kind: "writeJson",
+            to: ".vscode/extensions.json",
+            value: {
+                recommendations: editorCustomization.extensions,
+            },
+            multilineArrays: ["recommendations"],
+        },
+        {
+            kind: "writeJson",
+            to: ".vscode/settings.json",
+            value: editorCustomization.settings,
+        },
+        {
+            kind: "writeText",
+            to: ".github/workflows/check.yml",
+            text: projectCheckWorkflow({ checkPlan }),
+        },
+        {
+            kind: "writeText",
+            to: ".github/dependabot.yml",
+            text: projectDependabotConfig(dependencyMaintenancePolicy),
+        },
+    ];
+}
+function packageAdditionOperations(packagePath, packageName, nodeVersion) {
+    return [
+        {
+            kind: "writeJson",
+            to: `${packagePath}/package.json`,
+            value: {
+                name: packageName,
+                version: "0.0.0",
+                private: true,
+                type: "module",
+                scripts: projectHonoApiPackageScripts(),
+                dependencies: {
+                    "@hono/node-server": "catalog:",
+                    hono: "catalog:",
+                },
+                devDependencies: {
+                    "@types/node": "catalog:",
+                    oxfmt: "catalog:",
+                    oxlint: "catalog:",
+                    "tsc-alias": "catalog:",
+                    typescript: "catalog:",
+                    vitest: "catalog:",
+                },
+                engines: {
+                    node: nodeVersion,
+                },
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.json`,
+            value: {
+                compilerOptions: {
+                    composite: true,
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    noEmitOnError: true,
+                    paths: {
+                        "@/*": ["./src/*"],
+                    },
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "ES2022",
+                    types: ["node", "vitest/globals"],
+                },
+                include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.build.json`,
+            value: {
+                extends: "./tsconfig.json",
+                compilerOptions: {
+                    outDir: "dist",
+                    rootDir: "src",
+                    types: ["node"],
+                },
+                include: ["src/**/*.ts"],
+            },
+        },
+        {
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "node/oxlint.config.ts",
+            to: `${packagePath}/oxlint.config.ts`,
+        },
+        {
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: `${packagePath}/oxfmt.config.ts`,
+        },
+        { kind: "copyFile", from: "src/app.ts", to: `${packagePath}/src/app.ts` },
+        {
+            kind: "copyFile",
+            from: "src/server.ts",
+            to: `${packagePath}/src/server.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "test/app.test.ts",
+            to: `${packagePath}/test/app.test.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "vitest.config.ts",
+            to: `${packagePath}/vitest.config.ts`,
+        },
+    ];
+}
+function packageAdditionPlan(packageLeafName, packageName, nodeVersion) {
+    const packagePath = `apps/${packageLeafName}`;
+    return {
+        packagePath,
+        workspacePackageGlob: "apps/*",
+        rootTsconfigReferences: [`./${packagePath}/tsconfig.json`],
+        sourceRoot: templateSourceRoot(),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+        operations: packageAdditionOperations(packagePath, packageName, nodeVersion),
+    };
+}
+function templateSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedTemplateRoot = path.join(projectionDir, "..", "..", "..", "templates", "hono-api");
+    return existsSync(path.join(publishedTemplateRoot, "src", "app.ts"))
+        ? publishedTemplateRoot
+        : projectionDir;
+}
+function sharedOxcSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedSharedRoot = path.join(projectionDir, "..", "..", "..", "templates", "shared", "oxc");
+    return existsSync(path.join(publishedSharedRoot, "oxfmt.config.ts"))
+        ? publishedSharedRoot
+        : path.join(projectionDir, "..", "shared", "oxc");
+}
+export const honoApiPresetProjection = {
+    metadata: honoApiPresetMetadata,
+    capabilities: {
+        packageAddition: {
+            planPackageAddition({ packageLeafName, packageName, nodeVersion, }) {
+                return packageAdditionPlan(packageLeafName, packageName, nodeVersion);
+            },
+        },
+    },
+    blueprint: honoApiBlueprint,
+    project(context) {
+        const checkPlan = planNodeChecks("hono-api");
+        const fixPlan = planNodeFixes("hono-api");
+        const packageScripts = projectHonoApiPackageScripts();
+        return {
+            sourceRoot: templateSourceRoot(),
+            sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+            operations: operationsForHonoApi(context, 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/projection-plans.d.ts

@@ -0,0 +1,8 @@
+import type { CheckComponent, CheckPlan, FixComponent, FixPlan } from "../src/module-graph.js";
+export type NodeCheckPlanTarget = "hono-api" | "vue-app" | "vue-hono-root" | "vue-hono-api" | "vue-hono-web";
+export type NodeFixPlanTarget = "hono-api" | "vue-app" | "vue-hono-root" | "vue-hono-api" | "vue-hono-web";
+export declare function selectNodeCheckComponents(target: NodeCheckPlanTarget): CheckComponent[];
+export declare function selectNodeFixComponents(target: NodeFixPlanTarget): FixComponent[];
+export declare function planNodeChecks(target: NodeCheckPlanTarget): CheckPlan;
+export declare function planNodeFixes(target: NodeFixPlanTarget): FixPlan;
+//# sourceMappingURL=projection-plans.d.ts.map

package/dist/templates/projection-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-plans.d.ts","sourceRoot":"","sources":["../../templates/projection-plans.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,SAAS,EAET,YAAY,EACZ,OAAO,EACR,MAAM,wBAAwB,CAAC;AAiBhC,MAAM,MAAM,mBAAmB,GAC3B,UAAU,GACV,SAAS,GACT,eAAe,GACf,cAAc,GACd,cAAc,CAAC;AAEnB,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,SAAS,GACT,eAAe,GACf,cAAc,GACd,cAAc,CAAC;AA8BnB,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,GAC1B,cAAc,EAAE,CAalB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,GACxB,YAAY,EAAE,CAYhB;AA4BD,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAKrE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAEhE"}

package/dist/templates/projection-plans.js

@@ -0,0 +1,94 @@
+const rootPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const apiPackageBoundary = {
+    kind: "package-boundary",
+    path: "apps/api",
+};
+const webPackageBoundary = {
+    kind: "package-boundary",
+    path: "apps/web",
+};
+function honoApiCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+    ];
+}
+function vueAppCheckComponents(owner) {
+    return [
+        { kind: "oxc-format-check", owner },
+        { kind: "oxc-lint", owner },
+        { kind: "typescript-typecheck", owner },
+        { kind: "build", owner },
+        { kind: "unit-test", owner },
+        { kind: "e2e-test", owner },
+    ];
+}
+function nodeFixComponents(owner) {
+    return [
+        { kind: "oxc-format-write", owner },
+        { kind: "oxc-lint-fix", owner },
+    ];
+}
+export function selectNodeCheckComponents(target) {
+    switch (target) {
+        case "hono-api":
+            return honoApiCheckComponents(rootPackageBoundary);
+        case "vue-app":
+            return vueAppCheckComponents(rootPackageBoundary);
+        case "vue-hono-root":
+            return [{ kind: "turbo-check", owner: rootPackageBoundary }];
+        case "vue-hono-api":
+            return honoApiCheckComponents(apiPackageBoundary);
+        case "vue-hono-web":
+            return vueAppCheckComponents(webPackageBoundary);
+    }
+}
+export function selectNodeFixComponents(target) {
+    switch (target) {
+        case "hono-api":
+        case "vue-app":
+            return nodeFixComponents(rootPackageBoundary);
+        case "vue-hono-root":
+            return [{ kind: "turbo-fix", owner: rootPackageBoundary }];
+        case "vue-hono-api":
+            return nodeFixComponents(apiPackageBoundary);
+        case "vue-hono-web":
+            return nodeFixComponents(webPackageBoundary);
+    }
+}
+function checkEnvironmentNeeds(target) {
+    if (target === "vue-app") {
+        return [
+            {
+                kind: "playwright-browser-assets",
+                browser: "chromium",
+                owner: rootPackageBoundary,
+            },
+        ];
+    }
+    if (target === "vue-hono-root" || target === "vue-hono-web") {
+        return [
+            {
+                kind: "playwright-browser-assets",
+                browser: "chromium",
+                owner: webPackageBoundary,
+            },
+        ];
+    }
+    return [];
+}
+export function planNodeChecks(target) {
+    return {
+        components: selectNodeCheckComponents(target),
+        environmentNeeds: checkEnvironmentNeeds(target),
+    };
+}
+export function planNodeFixes(target) {
+    return { components: selectNodeFixComponents(target) };
+}

package/dist/templates/registry.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltInPreset } from "../src/declarations.js";
+import type { GenerationContext } from "../src/generation-context.js";
+import type { PresetProjection, PresetProjectionPlan } from "../src/preset-projection.js";
+export declare const builtInPresetProjections: readonly PresetProjection[];
+export declare const builtInPresetMetadata: readonly BuiltInPreset[];
+export declare function findBuiltInPresetProjection(name: string): PresetProjection | undefined;
+export declare function projectPresetThroughRegistry(context: GenerationContext): PresetProjectionPlan | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/templates/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../templates/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AA4BrC,eAAO,MAAM,wBAAwB,EAAE,SAAS,gBAAgB,EAM/D,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,SAAS,aAAa,EAGzD,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,GACX,gBAAgB,GAAG,SAAS,CAI9B;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,iBAAiB,GACzB,oBAAoB,GAAG,SAAS,CAElC"}

package/dist/templates/registry.js

@@ -0,0 +1,42 @@
+import { honoApiPresetProjection } from "./hono-api/projection.js";
+import { rustBinPresetProjection } from "./rust-bin/projection.js";
+import { tsLibPresetProjection } from "./ts-lib/projection.js";
+import { vueAppPresetProjection } from "./vue-app/projection.js";
+import { vueHonoAppPresetProjection } from "./vue-hono-app/projection.js";
+const futurePresetMetadata = [
+    {
+        name: "ts-app",
+        title: "TypeScript application",
+        description: "Future application preset metadata.",
+        generation: "future",
+        supportedPackageManagers: ["pnpm"],
+        supportedProjectKinds: ["single-package"],
+        features: [],
+    },
+    {
+        name: "node-cli",
+        title: "Node.js CLI",
+        description: "Future command-line preset metadata.",
+        generation: "future",
+        supportedPackageManagers: ["pnpm"],
+        supportedProjectKinds: ["single-package"],
+        features: [],
+    },
+];
+export const builtInPresetProjections = [
+    tsLibPresetProjection,
+    honoApiPresetProjection,
+    vueAppPresetProjection,
+    vueHonoAppPresetProjection,
+    rustBinPresetProjection,
+];
+export const builtInPresetMetadata = [
+    ...builtInPresetProjections.map((projection) => projection.metadata),
+    ...futurePresetMetadata,
+];
+export function findBuiltInPresetProjection(name) {
+    return builtInPresetProjections.find((projection) => projection.metadata.name === name);
+}
+export function projectPresetThroughRegistry(context) {
+    return findBuiltInPresetProjection(context.preset)?.project(context);
+}

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

@@ -0,0 +1,10 @@
+import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
+import { type CheckPlan, type FixPlan } from "../../src/module-graph.js";
+import type { 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(): ProjectBlueprint;
+export declare function projectRustBinPackageScripts(): Record<string, string>;
+export declare const rustBinPresetProjection: PresetProjection;
+//# sourceMappingURL=projection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../templates/rust-bin/projection.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,OAAO,EAGb,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,gCAAgC,CAAC;AAcxC,eAAO,MAAM,qBAAqB,EAAE,aAiBnC,CAAC;AAuBF,wBAAgB,iBAAiB,IAAI,SAAS,CAS7C;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAI1C;AAED,wBAAgB,gBAAgB,IAAI,gBAAgB,CAQnD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKrE;AAsMD,eAAO,MAAM,uBAAuB,EAAE,gBAwCrC,CAAC"}