@ykdz/template 0.0.3 → 0.0.5

package/dist/templates/ts-lib/projection.js

@@ -1,11 +1,12 @@
 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 { 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 { projectCheckWorkflow, projectDependabotConfig, } from "../../src/project-github.js";
+import { PackageAdditionSupport } from "../../src/package-addition-support.js";
+import { packageManifestExposureFields, planPackageLinks, } from "../../src/package-linking.js";
 import { renderNewProject } from "../../src/renderer.js";
 const generatedBy = {
     packageName: "@ykdz/template",
@@ -18,7 +19,8 @@ export const tsLibPresetMetadata = {
     description: "Strict TypeScript package with pnpm catalog tooling.",
     generation: "supported",
     supportedPackageManagers: ["pnpm"],
-    supportedProjectKinds: ["single-package"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Supported,
     features: [
         "pnpm-catalog",
         "oxc-format-lint",
@@ -31,14 +33,22 @@ export const tsLibPresetMetadata = {
     ],
 };
 const dependencyMaintenancePolicy = {
-    ecosystems: ["npm", "github-actions"],
+    ecosystems: ["npm", "github-actions", "docker"],
     interval: "weekly",
 };
 const tsLibPackageBoundary = {
     kind: "package-boundary",
     path: ".",
 };
-function planTsLibChecks() {
+const tsLibRootBoundary = {
+    kind: "workspace-orchestration",
+    path: ".",
+};
+const tsLibWorkspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "packages/*",
+};
+function planTsLibPackageChecks() {
     return {
         components: [
             { kind: "typescript-typecheck", owner: tsLibPackageBoundary },
@@ -48,7 +58,19 @@ function planTsLibChecks() {
         environmentNeeds: [],
     };
 }
-function planTsLibFixes() {
+function planTsLibRootChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: tsLibRootBoundary },
+            { kind: "oxc-lint", owner: tsLibRootBoundary },
+            { kind: "typescript-typecheck", owner: tsLibRootBoundary },
+            { kind: "turbo-package-typecheck", owner: tsLibWorkspacePackageBoundary },
+            { kind: "turbo-package-check", owner: tsLibWorkspacePackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planTsLibPackageFixes() {
     return {
         components: [
             { kind: "oxc-format-write", owner: tsLibPackageBoundary },
@@ -56,48 +78,84 @@ function planTsLibFixes() {
         ],
     };
 }
-export function tsLibBlueprint() {
+function planTsLibRootFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: tsLibRootBoundary },
+            { kind: "oxc-lint-fix", owner: tsLibRootBoundary },
+            { kind: "turbo-package-fix", owner: tsLibWorkspacePackageBoundary },
+        ],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function packageName(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: "single-package",
+        projectKind: "multi-package",
         features: [...tsLibPresetMetadata.features],
+        packages: [
+            {
+                name: packageName(packageScope, packageLeafName),
+                path: `packages/${packageLeafName}`,
+            },
+        ],
+    };
+}
+function workspacePackagePath(context) {
+    return `packages/${context.projectName.value}`;
+}
+function workspacePackageName(context) {
+    const packageDefinition = context.blueprint.packages?.find((pkg) => pkg.path === workspacePackagePath(context));
+    return (packageDefinition?.name ??
+        packageName(context.projectName.value, context.projectName.value));
+}
+function projectTsLibRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planTsLibRootChecks()),
+        fix: renderFixCommand(planTsLibRootFixes()),
+        "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 projectTsLibPackageScripts() {
-    const checkPlan = planTsLibChecks();
-    const fixPlan = planTsLibFixes();
+    const checkPlan = planTsLibPackageChecks();
+    const fixPlan = planTsLibPackageFixes();
     return {
-        build: "tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
         check: renderRootCheckCommand(checkPlan),
         fix: renderFixCommand(fixPlan),
-        "format:check": "oxfmt --check .",
-        "format:write": "oxfmt --write .",
-        lint: "oxlint . --deny-warnings",
-        "lint:fix": "oxlint . --fix --deny-warnings",
+        "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 packageJson(context, packageScripts) {
+function rootPackageJson(context, packageScripts) {
     return {
         name: context.projectName.value,
         version: "0.0.0",
         private: true,
-        files: ["dist"],
         type: "module",
-        exports: {
-            ".": {
-                default: "./dist/index.js",
-                types: "./dist/index.d.ts",
-            },
-        },
         scripts: packageScripts,
         devDependencies: {
-            "@types/node": "catalog:",
             oxfmt: "catalog:",
             oxlint: "catalog:",
-            "tsc-alias": "catalog:",
+            turbo: "catalog:",
             typescript: "catalog:",
         },
         engines: {
@@ -106,6 +164,30 @@ function packageJson(context, packageScripts) {
         packageManager: context.toolchain.packageManagerPin.value,
     };
 }
+function libraryPackageJson(context, exposure) {
+    const exposureFields = packageManifestExposureFields(exposure);
+    return {
+        name: workspacePackageName(context),
+        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: context.toolchain.nodeLtsMajor.value,
+        },
+    };
+}
 function generationRecord(context) {
     return {
         ...generatedBy,
@@ -120,40 +202,101 @@ function operationsForTsLib(context, packageScripts, checkPlan) {
     const editorCustomization = editorCustomizationForCapabilities([
         "oxc-format-lint",
     ]);
+    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 packageLinkPlan = planPackageLinks([
+        {
+            name: workspacePackageName(context),
+            path: workspacePackagePath(context),
+            role: "shared-library",
+            sourcePreset: "ts-lib",
+        },
+    ]);
+    const packageExposure = packageLinkPlan.exposuresByPackagePath.get(workspacePackagePath(context));
+    if (packageExposure === undefined) {
+        throw new Error(`Missing Package Exposure for ${workspacePackagePath(context)}`);
+    }
+    const packageManifest = libraryPackageJson(context, packageExposure);
     return [
         {
             kind: "writeJson",
             to: "package.json",
-            value: packageJson(context, packageScripts),
-            multilineArrays: ["files"],
+            value: rootManifest,
         },
         {
             kind: "writeText",
             to: "pnpm-workspace.yaml",
             text: renderGeneratedPnpmWorkspaceYaml({
-                dependencies: [
-                    "@types/node",
-                    "oxfmt",
-                    "oxlint",
-                    "tsc-alias",
-                    "typescript",
-                ],
+                packages: ["packages/*"],
+                dependencies: collectGeneratedManifestCatalogDependencies([
+                    rootManifest,
+                    packageManifest,
+                ]),
             }),
         },
+        {
+            kind: "writeJson",
+            to: "turbo.json",
+            value: {
+                tasks: {
+                    build: packageLinkPlan.turboTasks.build,
+                    check: packageLinkPlan.turboTasks.check,
+                    typecheck: packageLinkPlan.turboTasks.typecheck,
+                    test: packageLinkPlan.turboTasks.test,
+                    "test:e2e": packageLinkPlan.turboTasks["test:e2e"],
+                    fix: {
+                        cache: false,
+                    },
+                },
+            },
+        },
         {
             kind: "writeJson",
             to: "tsconfig.json",
+            value: {
+                files: [],
+            },
+        },
+        {
+            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: `${workspacePackagePath(context)}/package.json`,
+            value: packageManifest,
+            multilineArrays: ["files"],
+        },
+        {
+            kind: "writeJson",
+            to: `${workspacePackagePath(context)}/tsconfig.json`,
             value: {
                 compilerOptions: {
+                    composite: true,
                     declaration: true,
                     declarationMap: true,
                     module: "NodeNext",
                     moduleResolution: "NodeNext",
                     noEmitOnError: true,
-                    outDir: "dist",
-                    paths: {
-                        "@/*": ["./src/*"],
-                    },
                     rootDir: "src",
                     skipLibCheck: false,
                     strict: true,
@@ -178,33 +321,45 @@ function operationsForTsLib(context, packageScripts, checkPlan) {
         {
             kind: "writeText",
             to: ".gitignore",
-            text: ["node_modules", "dist", ".env", ""].join("\n"),
+            text: [
+                "node_modules",
+                "dist",
+                ".env",
+                ".template/",
+                ".pnpm-store/",
+                "",
+            ].join("\n"),
         },
         {
             kind: "copyFile",
             from: "src/index.ts",
-            to: "src/index.ts",
+            to: `${workspacePackagePath(context)}/src/index.ts`,
+        },
+        {
+            kind: "copyFile",
+            from: "src/name-schema.ts",
+            to: `${workspacePackagePath(context)}/src/name-schema.ts`,
         },
         {
             kind: "writeJson",
-            to: ".project-kit/blueprint.json",
-            value: tsLibBlueprint(),
+            to: ".template/blueprint.json",
+            value: context.blueprint,
         },
         {
             kind: "writeJson",
-            to: ".project-kit/generated-by.json",
+            to: ".template/generated-by.json",
             value: generationRecord(context),
         },
         {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
-            value: nodePnpmDevcontainer({
-                name: `${context.projectName.value} development`,
-                nodeVersion: context.toolchain.nodeLtsMajor.value,
-                packageManagerPin: context.toolchain.packageManagerPin.value,
-                extensions: editorCustomization.extensions,
-                settings: editorCustomization.settings,
-            }),
+            value: developmentContainer.devcontainer,
+        },
+        {
+            kind: "copyFile",
+            sourceRoot: "sharedDevcontainer",
+            from: "node-pnpm.Dockerfile",
+            to: ".devcontainer/Dockerfile",
         },
         {
             kind: "writeJson",
@@ -220,18 +375,30 @@ function operationsForTsLib(context, packageScripts, checkPlan) {
             value: editorCustomization.settings,
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/workflows/check.yml",
             to: ".github/workflows/check.yml",
-            text: projectCheckWorkflow({ checkPlan }),
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/dependabot.yml",
             to: ".github/dependabot.yml",
-            text: projectDependabotConfig(dependencyMaintenancePolicy),
         },
     ];
 }
 function packageAdditionOperations(packagePath, packageName, nodeVersion) {
+    const packageExposure = planPackageLinks([
+        {
+            name: packageName,
+            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",
@@ -240,20 +407,17 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
                 name: packageName,
                 version: "0.0.0",
                 private: true,
-                files: ["dist"],
                 type: "module",
-                exports: {
-                    ".": {
-                        default: "./dist/index.js",
-                        types: "./dist/index.d.ts",
-                    },
+                imports: exposureFields.imports,
+                exports: exposureFields.exports,
+                dependencies: {
+                    valibot: "catalog:",
                 },
                 scripts: projectTsLibPackageScripts(),
                 devDependencies: {
                     "@types/node": "catalog:",
                     oxfmt: "catalog:",
                     oxlint: "catalog:",
-                    "tsc-alias": "catalog:",
                     typescript: "catalog:",
                 },
                 engines: {
@@ -273,10 +437,6 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
                     module: "NodeNext",
                     moduleResolution: "NodeNext",
                     noEmitOnError: true,
-                    outDir: "dist",
-                    paths: {
-                        "@/*": ["./src/*"],
-                    },
                     rootDir: "src",
                     skipLibCheck: false,
                     strict: true,
@@ -288,29 +448,23 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
         },
         {
             kind: "copyFile",
-            sourceRoot: "sharedOxc",
-            from: "node/oxlint.config.ts",
-            to: `${packagePath}/oxlint.config.ts`,
+            from: "src/index.ts",
+            to: `${packagePath}/src/index.ts`,
         },
         {
             kind: "copyFile",
-            sourceRoot: "sharedOxc",
-            from: "oxfmt.config.ts",
-            to: `${packagePath}/oxfmt.config.ts`,
-        },
-        {
-            kind: "copyFile",
-            from: "src/index.ts",
-            to: `${packagePath}/src/index.ts`,
+            from: "src/name-schema.ts",
+            to: `${packagePath}/src/name-schema.ts`,
         },
     ];
 }
-function packageAdditionPlan(packageLeafName, packageName, nodeVersion) {
-    const packagePath = `packages/${packageLeafName}`;
+function packageAdditionPlan(packageName, packagePath, nodeVersion) {
+    const [workspaceCollection] = packagePath.split("/");
     return {
         packagePath,
-        workspacePackageGlob: "packages/*",
-        rootTsconfigReferences: [`./${packagePath}/tsconfig.json`],
+        workspacePackageGlob: `${workspaceCollection}/*`,
+        packageRole: "shared-library",
+        packageSourcePreset: "ts-lib",
         sourceRoot: templateSourceRoot(),
         sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         operations: packageAdditionOperations(packagePath, packageName, nodeVersion),
@@ -330,23 +484,33 @@ function sharedOxcSourceRoot() {
         ? 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 tsLibPresetProjection = {
     metadata: tsLibPresetMetadata,
     capabilities: {
         packageAddition: {
-            planPackageAddition({ packageLeafName, packageName, nodeVersion, }) {
-                return packageAdditionPlan(packageLeafName, packageName, nodeVersion);
+            planPackageAddition({ packageName, packagePath, nodeVersion, }) {
+                return packageAdditionPlan(packageName, packagePath, nodeVersion);
             },
         },
     },
     blueprint: tsLibBlueprint,
     project(context) {
-        const checkPlan = planTsLibChecks();
-        const fixPlan = planTsLibFixes();
-        const packageScripts = projectTsLibPackageScripts();
+        const checkPlan = planTsLibRootChecks();
+        const fixPlan = planTsLibRootFixes();
+        const packageScripts = projectTsLibRootPackageScripts();
         return {
             sourceRoot: templateSourceRoot(),
-            sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+            sourceRoots: {
+                sharedDevcontainer: sharedDevcontainerSourceRoot(),
+                sharedOxc: sharedOxcSourceRoot(),
+            },
             operations: operationsForTsLib(context, packageScripts, checkPlan),
             checkPlan,
             fixPlan,

package/dist/templates/vue-app/projection.d.ts

@@ -1,7 +1,6 @@
 import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
-import type { PresetProjection } from "../../src/preset-projection.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
 export declare const vueAppPresetMetadata: BuiltInPreset;
-export declare function vueAppBlueprint(): ProjectBlueprint;
+export declare function vueAppBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
 export declare function projectVueAppPackageScripts(): Record<string, string>;
 export declare const vueAppPresetProjection: PresetProjection;
-//# sourceMappingURL=projection.d.ts.map