@ykdz/template 0.0.4 → 0.0.6

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

@@ -1,538 +0,0 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { collectGeneratedManifestCatalogDependencies, renderGeneratedPnpmWorkspaceYaml, } from "../../src/dependency-catalog.js";
-import { checkedDockerfileFirstNodePnpmDevcontainer, nodePnpmToolLayer, } 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 hono-api",
-};
-export const honoApiPresetMetadata = {
-    name: "hono-api",
-    title: "Hono API",
-    description: "Hono Node API workspace with strict TypeScript tooling.",
-    generation: "supported",
-    supportedPackageManagers: ["pnpm"],
-    supportedProjectKinds: ["multi-package"],
-    features: [
-        "pnpm-catalog",
-        "oxc-format-lint",
-        "strict-typescript",
-        "root-check",
-        "fix-command",
-        "devcontainer",
-        "github-actions",
-        "dependabot",
-    ],
-};
-const dependencyMaintenancePolicy = {
-    ecosystems: ["npm", "github-actions", "docker"],
-    interval: "weekly",
-};
-const apiPackageBoundary = {
-    kind: "package-boundary",
-    path: ".",
-};
-const rootBoundary = {
-    kind: "workspace-orchestration",
-    path: ".",
-};
-const workspacePackageBoundary = {
-    kind: "package-boundary",
-    path: "apps/*",
-};
-function planHonoApiPackageChecks() {
-    return {
-        components: [
-            { kind: "oxc-format-check", owner: apiPackageBoundary },
-            { kind: "oxc-lint", owner: apiPackageBoundary },
-            { kind: "typescript-typecheck", owner: apiPackageBoundary },
-            { kind: "build", owner: apiPackageBoundary },
-            { kind: "unit-test", owner: apiPackageBoundary },
-        ],
-        environmentNeeds: [],
-    };
-}
-function planHonoApiRootChecks() {
-    return {
-        components: [
-            { kind: "oxc-format-check", owner: rootBoundary },
-            { kind: "oxc-lint", owner: rootBoundary },
-            { kind: "typescript-typecheck", owner: rootBoundary },
-            { kind: "turbo-package-check", owner: workspacePackageBoundary },
-        ],
-        environmentNeeds: [],
-    };
-}
-function planHonoApiPackageFixes() {
-    return {
-        components: [
-            { kind: "oxc-format-write", owner: apiPackageBoundary },
-            { kind: "oxc-lint-fix", owner: apiPackageBoundary },
-        ],
-    };
-}
-function planHonoApiRootFixes() {
-    return {
-        components: [
-            { kind: "oxc-format-write", owner: rootBoundary },
-            { kind: "oxc-lint-fix", owner: rootBoundary },
-            { kind: "turbo-package-fix", owner: workspacePackageBoundary },
-        ],
-    };
-}
-function projectNameFromDir(targetDir) {
-    return path.basename(path.resolve(targetDir));
-}
-function packageScopeFromOptions(options) {
-    return options.scope ?? projectNameFromDir(options.targetDir);
-}
-function packageName(packageScope) {
-    return `@${packageScope}/api`;
-}
-export function honoApiBlueprint(options = { targetDir: process.cwd() }) {
-    const packageScope = packageScopeFromOptions(options);
-    return {
-        schemaVersion: 1,
-        preset: "hono-api",
-        packageManager: "pnpm",
-        projectKind: "multi-package",
-        features: [...honoApiPresetMetadata.features],
-        packages: [{ name: packageName(packageScope), path: "apps/api" }],
-    };
-}
-function projectHonoApiRootPackageScripts() {
-    return {
-        check: renderRootCheckCommand(planHonoApiRootChecks()),
-        fix: renderFixCommand(planHonoApiRootFixes()),
-        "format:check": "oxfmt --check --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
-        "format:write": "oxfmt --write --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
-        lint: "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --deny-warnings",
-        "lint:fix": "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix --deny-warnings",
-        typecheck: "tsc -p tsconfig.config.json --noEmit",
-    };
-}
-export function projectHonoApiPackageScripts() {
-    return {
-        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-        check: renderRootCheckCommand(planHonoApiPackageChecks()),
-        fix: renderFixCommand(planHonoApiPackageFixes()),
-        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
-        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
-        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
-        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
-        start: "node dist/server.js",
-        test: "vitest run",
-        typecheck: "tsc -p tsconfig.json --noEmit",
-    };
-}
-function rootPackageJson(context, packageScripts) {
-    return {
-        name: context.projectName.value,
-        version: "0.0.0",
-        private: true,
-        type: "module",
-        scripts: packageScripts,
-        devDependencies: {
-            oxfmt: "catalog:",
-            oxlint: "catalog:",
-            turbo: "catalog:",
-            typescript: "catalog:",
-        },
-        engines: {
-            node: context.toolchain.nodeLtsMajor.value,
-        },
-        packageManager: context.toolchain.packageManagerPin.value,
-    };
-}
-function apiPackageName(context) {
-    const apiPackage = context.blueprint.packages?.find((pkg) => pkg.path === "apps/api");
-    return apiPackage?.name ?? packageName(context.projectName.value);
-}
-function apiPackageJson(context) {
-    return {
-        name: apiPackageName(context),
-        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: 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 operationsForHonoApi(context, packageScripts, checkPlan) {
-    const editorCustomization = editorCustomizationForCapabilities([
-        "oxc-format-lint",
-        "vitest",
-    ]);
-    const developmentContainer = checkedDockerfileFirstNodePnpmDevcontainer({
-        name: context.projectName.value,
-        layer: nodePnpmToolLayer({
-            nodeVersion: context.toolchain.nodeLtsMajor.value,
-            packageManagerPin: context.toolchain.packageManagerPin.value,
-        }),
-        extensions: editorCustomization.extensions,
-        settings: editorCustomization.settings,
-    });
-    const rootManifest = rootPackageJson(context, packageScripts);
-    const apiManifest = apiPackageJson(context);
-    return [
-        {
-            kind: "writeJson",
-            to: "package.json",
-            value: rootManifest,
-        },
-        {
-            kind: "writeText",
-            to: "pnpm-workspace.yaml",
-            text: renderGeneratedPnpmWorkspaceYaml({
-                packages: ["apps/*"],
-                dependencies: collectGeneratedManifestCatalogDependencies([
-                    rootManifest,
-                    apiManifest,
-                ]),
-            }),
-        },
-        {
-            kind: "writeJson",
-            to: "turbo.json",
-            value: {
-                tasks: {
-                    build: {
-                        dependsOn: ["^build"],
-                        outputs: ["dist/**"],
-                    },
-                    check: {
-                        dependsOn: ["^build"],
-                    },
-                    fix: {
-                        cache: false,
-                    },
-                },
-            },
-        },
-        {
-            kind: "writeJson",
-            to: "tsconfig.json",
-            value: {
-                files: [],
-                references: [{ path: "./apps/api/tsconfig.json" }],
-            },
-        },
-        {
-            kind: "writeJson",
-            to: "tsconfig.config.json",
-            value: {
-                compilerOptions: {
-                    module: "NodeNext",
-                    moduleResolution: "NodeNext",
-                    noEmitOnError: true,
-                    skipLibCheck: false,
-                    strict: true,
-                    target: "ES2022",
-                },
-                include: ["oxlint.config.ts", "oxfmt.config.ts"],
-            },
-        },
-        {
-            kind: "writeJson",
-            to: "apps/api/package.json",
-            value: apiManifest,
-        },
-        {
-            kind: "writeJson",
-            to: "apps/api/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: "apps/api/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",
-                ".template/",
-                ".pnpm-store/",
-                "",
-            ].join("\n"),
-        },
-        { kind: "copyFile", from: "src/app.ts", to: "apps/api/src/app.ts" },
-        {
-            kind: "copyFile",
-            from: "src/server.ts",
-            to: "apps/api/src/server.ts",
-        },
-        {
-            kind: "copyFile",
-            from: "test/app.test.ts",
-            to: "apps/api/test/app.test.ts",
-        },
-        {
-            kind: "copyFile",
-            from: "vitest.config.ts",
-            to: "apps/api/vitest.config.ts",
-        },
-        {
-            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,
-        },
-        {
-            ...developmentContainer.dockerfileOperation,
-        },
-        {
-            kind: "writeJson",
-            to: ".vscode/extensions.json",
-            value: {
-                recommendations: editorCustomization.extensions,
-            },
-            multilineArrays: ["recommendations"],
-        },
-        {
-            kind: "writeJson",
-            to: ".vscode/settings.json",
-            value: editorCustomization.settings,
-        },
-        {
-            kind: "copyFile",
-            from: ".github/workflows/check.yml",
-            to: ".github/workflows/check.yml",
-        },
-        {
-            kind: "copyFile",
-            from: ".github/dependabot.yml",
-            to: ".github/dependabot.yml",
-        },
-    ];
-}
-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", 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(packageName, packagePath, nodeVersion) {
-    const [workspaceCollection] = packagePath.split("/");
-    return {
-        packagePath,
-        workspacePackageGlob: `${workspaceCollection}/*`,
-        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");
-}
-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 honoApiPresetProjection = {
-    metadata: honoApiPresetMetadata,
-    capabilities: {
-        packageAddition: {
-            planPackageAddition({ packageName, packagePath, nodeVersion, }) {
-                return packageAdditionPlan(packageName, packagePath, nodeVersion);
-            },
-        },
-    },
-    blueprint: honoApiBlueprint,
-    project(context) {
-        const checkPlan = planHonoApiRootChecks();
-        const fixPlan = planHonoApiRootFixes();
-        const packageScripts = projectHonoApiRootPackageScripts();
-        return {
-            sourceRoot: templateSourceRoot(),
-            sourceRoots: {
-                sharedDevcontainer: sharedDevcontainerSourceRoot(),
-                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

@@ -1,7 +0,0 @@
-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;

package/dist/templates/projection-plans.js

@@ -1,94 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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;

package/dist/templates/registry.js

@@ -1,42 +0,0 @@
-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: ["multi-package"],
-        features: [],
-    },
-    {
-        name: "node-cli",
-        title: "Node.js CLI",
-        description: "Future command-line preset metadata.",
-        generation: "future",
-        supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["multi-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);
-}