@ykdz/template 0.0.1 → 0.0.3

package/pnpm-workspace.yaml

@@ -0,0 +1,34 @@
+packages:
+  - .
+
+catalog:
+  "@hono/node-server": ^2.0.6
+  "@playwright/test": ^1.61.1
+  "@tailwindcss/vite": ^4.3.2
+  "@types/node": ^24.0.0
+  "@types/web-bluetooth": ^0.0.21
+  "@vitejs/plugin-vue": ^6.0.7
+  "@vue/tsconfig": ^0.9.1
+  "@vueuse/core": ^14.3.0
+  hono: ^4.12.27
+  oxfmt: ^0.57.0
+  oxlint: ^1.72.0
+  pinia: ^3.0.4
+  tailwindcss: ^4.3.2
+  tsc-alias: ^1.8.17
+  tsx: ^4.22.4
+  turbo: ^2.10.2
+  typescript: ^6.0.3
+  vite: ^8.1.2
+  vitest: ^4.1.9
+  vue: ^3.5.39
+  vue-tsc: ^3.3.6
+
+allowBuilds:
+  esbuild: true
+
+minimumReleaseAgeExclude:
+  - valibot@1.4.2
+
+onlyBuiltDependencies:
+  - esbuild

package/templates/hono-api/projection.ts

@@ -0,0 +1,453 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type {
+  BuiltInPreset,
+  ProjectBlueprint,
+} from "../../src/declarations.js";
+import { renderGeneratedPnpmWorkspaceYaml } from "../../src/dependency-catalog.js";
+import { nodePnpmDevcontainer } from "../../src/devcontainer.js";
+import { editorCustomizationForCapabilities } from "../../src/editor-customization.js";
+import type { GenerationContext } from "../../src/generation-context.js";
+import {
+  type CheckPlan,
+  renderFixCommand,
+  renderRootCheckCommand,
+} from "../../src/module-graph.js";
+import type {
+  PresetPackageAdditionOptions,
+  PresetPackageAdditionPlan,
+  PresetProjection,
+  PresetProjectionPlan,
+} from "../../src/preset-projection.js";
+import {
+  projectCheckWorkflow,
+  projectDependabotConfig,
+  type DependencyMaintenancePolicy,
+} from "../../src/project-github.js";
+import { renderNewProject, type RenderOperation } 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: BuiltInPreset = {
+  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: DependencyMaintenancePolicy = {
+  ecosystems: ["npm", "github-actions"],
+  interval: "weekly",
+};
+
+export function honoApiBlueprint(): ProjectBlueprint {
+  return {
+    schemaVersion: 1,
+    preset: "hono-api",
+    packageManager: "pnpm",
+    projectKind: "single-package",
+    features: [...honoApiPresetMetadata.features],
+  };
+}
+
+export function projectHonoApiPackageScripts(): Record<string, string> {
+  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: GenerationContext,
+  packageScripts: Record<string, string>,
+): Record<string, unknown> {
+  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: GenerationContext): Record<string, unknown> {
+  return {
+    ...generatedBy,
+    toolchain: {
+      nodeLtsMajor: context.toolchain.nodeLtsMajor.value,
+      packageManagerPin: context.toolchain.packageManagerPin.value,
+      source: context.toolchain.source,
+    },
+  };
+}
+
+function operationsForHonoApi(
+  context: GenerationContext,
+  packageScripts: Record<string, string>,
+  checkPlan: CheckPlan,
+): RenderOperation[] {
+  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: string,
+  packageName: string,
+  nodeVersion: string,
+): RenderOperation[] {
+  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: string,
+  packageName: string,
+  nodeVersion: string,
+): PresetPackageAdditionPlan {
+  const packagePath = `apps/${packageLeafName}`;
+
+  return {
+    packagePath,
+    workspacePackageGlob: "apps/*",
+    rootTsconfigReferences: [`./${packagePath}/tsconfig.json`],
+    sourceRoot: templateSourceRoot(),
+    sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+    operations: packageAdditionOperations(
+      packagePath,
+      packageName,
+      nodeVersion,
+    ),
+  };
+}
+
+function templateSourceRoot(): string {
+  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(): string {
+  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: PresetProjection = {
+  metadata: honoApiPresetMetadata,
+  capabilities: {
+    packageAddition: {
+      planPackageAddition({
+        packageLeafName,
+        packageName,
+        nodeVersion,
+      }: PresetPackageAdditionOptions) {
+        return packageAdditionPlan(packageLeafName, packageName, nodeVersion);
+      },
+    },
+  },
+  blueprint: honoApiBlueprint,
+  project(context: GenerationContext): PresetProjectionPlan {
+    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 }): Promise<void> {
+    await renderNewProject({
+      sourceRoot: plan.sourceRoot,
+      sourceRoots: plan.sourceRoots,
+      targetRoot: targetDir,
+      operations: [...plan.operations],
+    });
+  },
+};

package/templates/projection-plans.ts

@@ -0,0 +1,135 @@
+import type {
+  CheckComponent,
+  CheckEnvironmentNeed,
+  CheckPlan,
+  ComponentOwner,
+  FixComponent,
+  FixPlan,
+} from "../src/module-graph.js";
+
+const rootPackageBoundary: ComponentOwner = {
+  kind: "package-boundary",
+  path: ".",
+};
+
+const apiPackageBoundary: ComponentOwner = {
+  kind: "package-boundary",
+  path: "apps/api",
+};
+
+const webPackageBoundary: ComponentOwner = {
+  kind: "package-boundary",
+  path: "apps/web",
+};
+
+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";
+
+function honoApiCheckComponents(owner: ComponentOwner): CheckComponent[] {
+  return [
+    { kind: "oxc-format-check", owner },
+    { kind: "oxc-lint", owner },
+    { kind: "typescript-typecheck", owner },
+    { kind: "build", owner },
+    { kind: "unit-test", owner },
+  ];
+}
+
+function vueAppCheckComponents(owner: ComponentOwner): CheckComponent[] {
+  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: ComponentOwner): FixComponent[] {
+  return [
+    { kind: "oxc-format-write", owner },
+    { kind: "oxc-lint-fix", owner },
+  ];
+}
+
+export function selectNodeCheckComponents(
+  target: NodeCheckPlanTarget,
+): CheckComponent[] {
+  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: NodeFixPlanTarget,
+): FixComponent[] {
+  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: NodeCheckPlanTarget,
+): CheckEnvironmentNeed[] {
+  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: NodeCheckPlanTarget): CheckPlan {
+  return {
+    components: selectNodeCheckComponents(target),
+    environmentNeeds: checkEnvironmentNeeds(target),
+  };
+}
+
+export function planNodeFixes(target: NodeFixPlanTarget): FixPlan {
+  return { components: selectNodeFixComponents(target) };
+}

package/templates/registry.ts

@@ -0,0 +1,59 @@
+import type { BuiltInPreset } from "../src/declarations.js";
+import type { GenerationContext } from "../src/generation-context.js";
+import type {
+  PresetProjection,
+  PresetProjectionPlan,
+} from "../src/preset-projection.js";
+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: [],
+  },
+] satisfies readonly BuiltInPreset[];
+
+export const builtInPresetProjections: readonly PresetProjection[] = [
+  tsLibPresetProjection,
+  honoApiPresetProjection,
+  vueAppPresetProjection,
+  vueHonoAppPresetProjection,
+  rustBinPresetProjection,
+];
+
+export const builtInPresetMetadata: readonly BuiltInPreset[] = [
+  ...builtInPresetProjections.map((projection) => projection.metadata),
+  ...futurePresetMetadata,
+];
+
+export function findBuiltInPresetProjection(
+  name: string,
+): PresetProjection | undefined {
+  return builtInPresetProjections.find(
+    (projection) => projection.metadata.name === name,
+  );
+}
+
+export function projectPresetThroughRegistry(
+  context: GenerationContext,
+): PresetProjectionPlan | undefined {
+  return findBuiltInPresetProjection(context.preset)?.project(context);
+}

package/templates/rust-bin/.github/dependabot.yml

@@ -1,5 +1,9 @@
 version: 2
 updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
   - package-ecosystem: cargo
     directory: /
     schedule:

package/templates/rust-bin/.github/workflows/check.yml

@@ -11,8 +11,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version-file: package.json
+      - run: corepack enable
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt, clippy
       - uses: Swatinem/rust-cache@v2
-      - run: ./scripts/check
+      - run: pnpm install
+      - run: pnpm run check