@ykdz/template 0.0.6 → 0.0.8

package/node_modules/@ykdz/template-builtin-source/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/node_modules/@ykdz/template-builtin-source/dist/templates/registry.d.ts

@@ -0,0 +1,2 @@
+import type { PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare function findBuiltInPresetProjection(name: string): PresetProjection | undefined;

package/node_modules/@ykdz/template-builtin-source/dist/templates/registry.js

@@ -0,0 +1,15 @@
+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 testOnlyPresetProjections = [
+    tsLibPresetProjection,
+    honoApiPresetProjection,
+    vueAppPresetProjection,
+    vueHonoAppPresetProjection,
+    rustBinPresetProjection,
+];
+export function findBuiltInPresetProjection(name) {
+    return testOnlyPresetProjections.find((projection) => projection.metadata.name === name);
+}

package/node_modules/@ykdz/template-builtin-source/dist/templates/rust-bin/projection.d.ts

@@ -0,0 +1,9 @@
+import type { BuiltInPreset, ProjectBlueprint } from "@ykdz/template-core/declarations";
+import { type CheckPlan, type FixPlan } from "@ykdz/template-core/module-graph";
+import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare const rustBinPresetMetadata: BuiltInPreset;
+export declare function planRustBinChecks(): CheckPlan;
+export declare function planRustBinFixes(): FixPlan;
+export declare function rustBinBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectRustBinPackageScripts(): Record<string, string>;
+export declare const rustBinPresetProjection: PresetProjection;

package/node_modules/@ykdz/template-builtin-source/dist/templates/rust-bin/projection.js

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject } from "@ykdz/template-core/renderer";
+export const rustBinPresetMetadata = {
+    name: "rust-bin",
+    title: "Rust binary",
+    description: "Rust native binary workspace with rustfmt, clippy, and cargo tests.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Unsupported,
+    features: [
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+        "rustfmt-clippy",
+        "cargo-test",
+    ],
+};
+const rustPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+function cargoPackageNameFromProjectName(projectName) {
+    const slug = projectName
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "rust-bin";
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function rustWorkspacePackageName(projectName) {
+    return `${cargoPackageNameFromProjectName(projectName)}-native`;
+}
+function rustWorkspacePackagePath(projectName) {
+    return `packages/${cargoPackageNameFromProjectName(projectName)}`;
+}
+export function planRustBinChecks() {
+    return {
+        components: [
+            { kind: "rustfmt-check", owner: rustPackageBoundary },
+            { kind: "cargo-clippy", owner: rustPackageBoundary },
+            { kind: "cargo-test", owner: rustPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+export function planRustBinFixes() {
+    return {
+        components: [{ kind: "rustfmt-write", owner: rustPackageBoundary }],
+    };
+}
+export function rustBinBlueprint(options = { targetDir: process.cwd() }) {
+    const projectName = projectNameFromDir(options.targetDir);
+    return {
+        schemaVersion: 1,
+        preset: "rust-bin",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...rustBinPresetMetadata.features],
+        packages: [
+            {
+                name: rustWorkspacePackageName(projectName),
+                path: rustWorkspacePackagePath(projectName),
+            },
+        ],
+    };
+}
+export function projectRustBinPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planRustBinChecks()),
+        fix: renderFixCommand(planRustBinFixes()),
+    };
+}
+export const rustBinPresetProjection = {
+    metadata: rustBinPresetMetadata,
+    blueprint: rustBinBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: rustBinPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("rust-bin"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/dist/templates/ts-lib/projection.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltInPreset, ProjectBlueprint } from "@ykdz/template-core/declarations";
+import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare const tsLibPresetMetadata: BuiltInPreset;
+export declare function tsLibBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectTsLibPackageScripts(): Record<string, string>;
+export declare const tsLibPresetProjection: PresetProjection;

package/node_modules/@ykdz/template-builtin-source/dist/templates/ts-lib/projection.js

@@ -0,0 +1,214 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { builtInPresetProjectionSourceRoots, loadBuiltInPresetProjectionDeclaration, } from "@ykdz/template-builtin-source";
+import { renderFixCommand, renderRootCheckCommand, } from "@ykdz/template-core/module-graph";
+import { PackageAdditionSupport } from "@ykdz/template-core/package-addition-support";
+import { packageManifestExposureFields, planPackageLinks, } from "@ykdz/template-core/package-linking";
+import { interpretPresetProjectionDeclaration } from "@ykdz/template-core/projection-capabilities";
+import { renderNewProject, } from "@ykdz/template-core/renderer";
+export const tsLibPresetMetadata = {
+    name: "ts-lib",
+    title: "TypeScript library",
+    description: "Strict TypeScript package with pnpm catalog tooling.",
+    generation: "supported",
+    supportedPackageManagers: ["pnpm"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Supported,
+    features: [
+        "pnpm-catalog",
+        "oxc-format-lint",
+        "strict-typescript",
+        "root-check",
+        "fix-command",
+        "devcontainer",
+        "github-actions",
+        "dependabot",
+    ],
+};
+const tsLibPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+function planTsLibPackageChecks() {
+    return {
+        components: [
+            { kind: "typescript-typecheck", owner: tsLibPackageBoundary },
+            { kind: "oxc-lint", owner: tsLibPackageBoundary },
+            { kind: "oxc-format-check", owner: tsLibPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planTsLibPackageFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: tsLibPackageBoundary },
+            { kind: "oxc-lint-fix", owner: tsLibPackageBoundary },
+        ],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function scopedPackageName(packageScope, packageLeafName) {
+    return `@${packageScope}/${packageLeafName}`;
+}
+export function tsLibBlueprint(options = { targetDir: process.cwd() }) {
+    const packageScope = packageScopeFromOptions(options);
+    const packageLeafName = projectNameFromDir(options.targetDir);
+    return {
+        schemaVersion: 1,
+        preset: "ts-lib",
+        packageManager: "pnpm",
+        projectKind: "multi-package",
+        features: [...tsLibPresetMetadata.features],
+        packages: [
+            {
+                name: scopedPackageName(packageScope, packageLeafName),
+                path: `packages/${packageLeafName}`,
+            },
+        ],
+    };
+}
+export function projectTsLibPackageScripts() {
+    const checkPlan = planTsLibPackageChecks();
+    const fixPlan = planTsLibPackageFixes();
+    return {
+        check: renderRootCheckCommand(checkPlan),
+        fix: renderFixCommand(fixPlan),
+        "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",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
+function packageAdditionOperations(packagePath, packageNameValue, nodeVersion) {
+    const packageExposure = planPackageLinks([
+        {
+            name: packageNameValue,
+            path: packagePath,
+            role: "shared-library",
+            sourcePreset: "ts-lib",
+        },
+    ]).exposuresByPackagePath.get(packagePath);
+    if (packageExposure === undefined) {
+        throw new Error(`Missing Package Exposure for ${packagePath}`);
+    }
+    const exposureFields = packageManifestExposureFields(packageExposure);
+    return [
+        {
+            kind: "writeJson",
+            to: `${packagePath}/package.json`,
+            value: {
+                name: packageNameValue,
+                version: "0.0.0",
+                private: true,
+                type: "module",
+                imports: exposureFields.imports,
+                exports: exposureFields.exports,
+                dependencies: {
+                    valibot: "catalog:",
+                },
+                scripts: projectTsLibPackageScripts(),
+                devDependencies: {
+                    "@types/node": "catalog:",
+                    oxfmt: "catalog:",
+                    oxlint: "catalog:",
+                    typescript: "catalog:",
+                },
+                engines: {
+                    node: nodeVersion,
+                },
+            },
+            multilineArrays: ["files"],
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.json`,
+            value: {
+                compilerOptions: {
+                    composite: true,
+                    declaration: true,
+                    declarationMap: true,
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    noEmitOnError: true,
+                    rootDir: "src",
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "ES2022",
+                    types: ["node"],
+                },
+                include: ["src/**/*.ts"],
+            },
+        },
+        {
+            kind: "copyFile",
+            from: "src/index.ts",
+            to: `${packagePath}/src/index.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "src/name-schema.ts",
+            to: `${packagePath}/src/name-schema.ts`,
+        },
+    ];
+}
+function packageAdditionPlan(packageNameValue, packagePath, nodeVersion) {
+    const [workspaceCollection] = packagePath.split("/");
+    return {
+        packagePath,
+        workspacePackageGlob: `${workspaceCollection}/*`,
+        packageRole: "shared-library",
+        packageSourcePreset: "ts-lib",
+        sourceRoot: templateSourceRoot(),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+        operations: packageAdditionOperations(packagePath, packageNameValue, nodeVersion),
+    };
+}
+function templateSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedTemplateRoot = path.join(projectionDir, "..", "..", "..", "templates", "ts-lib");
+    return existsSync(path.join(publishedTemplateRoot, "src", "index.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 tsLibPresetProjection = {
+    metadata: tsLibPresetMetadata,
+    capabilities: {
+        packageAddition: {
+            planPackageAddition({ packageName, packagePath, nodeVersion, }) {
+                return packageAdditionPlan(packageName, packagePath, nodeVersion);
+            },
+        },
+    },
+    blueprint: tsLibBlueprint,
+    project(context) {
+        return interpretPresetProjectionDeclaration({
+            preset: tsLibPresetMetadata,
+            declaration: loadBuiltInPresetProjectionDeclaration("ts-lib"),
+            context,
+            sourceRoots: builtInPresetProjectionSourceRoots(),
+        });
+    },
+    async render({ targetDir, plan }) {
+        await renderNewProject({
+            sourceRoot: plan.sourceRoot,
+            sourceRoots: plan.sourceRoots,
+            targetRoot: targetDir,
+            operations: [...plan.operations],
+        });
+    },
+};

package/node_modules/@ykdz/template-builtin-source/dist/templates/vue-app/projection.d.ts

@@ -0,0 +1,6 @@
+import type { BuiltInPreset, ProjectBlueprint } from "@ykdz/template-core/declarations";
+import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
+export declare const vueAppPresetMetadata: BuiltInPreset;
+export declare function vueAppBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
+export declare function projectVueAppPackageScripts(): Record<string, string>;
+export declare const vueAppPresetProjection: PresetProjection;