@ykdz/template 0.0.4 → 0.0.6

package/dist/src/package-linking.js

@@ -0,0 +1,116 @@
+export function derivePackageExposure(definition) {
+    if (definition.role === "shared-library" &&
+        definition.sourcePreset === "ts-lib") {
+        return {
+            kind: "jit-source",
+            entrypoint: "./src/index.ts",
+            packageLocalImportPattern: "#/*",
+            packageLocalImportTarget: "./src/*.ts",
+        };
+    }
+    if (definition.role === "runtime-service" &&
+        definition.sourcePreset === "hono-api") {
+        return {
+            kind: "compiled",
+            entrypoint: "./dist/index.js",
+            sourceTypes: "./src/index.ts",
+            packageLocalImportPattern: "#/*",
+            packageLocalImportRuntimeTarget: "./dist/*.js",
+            packageLocalImportTypesTarget: "./src/*.ts",
+        };
+    }
+    throw new Error(`Unsupported Package Exposure for ${definition.name} at ${definition.path}`);
+}
+export function assertTypeScriptPackageBoundaryForLinkIntent(definition, direction) {
+    if (definition.role !== undefined && definition.sourcePreset !== undefined) {
+        return;
+    }
+    const relationship = direction === "consumer" ? "from native package" : "to native package";
+    throw new Error(`Package Link Intent ${relationship} ${definition.path} is unsupported in V1 TypeScript-only Project Linking`);
+}
+export function planPackageLinks(definitions, intents = []) {
+    const definitionsByPath = new Map(definitions.map((definition) => [definition.path, definition]));
+    const manifestDependenciesByPackagePath = new Map();
+    for (const intent of intents) {
+        const consumer = definitionsByPath.get(intent.consumerPackagePath);
+        const provider = definitionsByPath.get(intent.providerPackagePath);
+        if (consumer !== undefined) {
+            assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
+        }
+        if (provider === undefined) {
+            throw new Error(`Package Link Intent references unknown provider package at ${intent.providerPackagePath}`);
+        }
+        assertTypeScriptPackageBoundaryForLinkIntent(provider, "provider");
+    }
+    const exposuresByPackagePath = new Map(definitions.map((definition) => [
+        definition.path,
+        derivePackageExposure(definition),
+    ]));
+    let dependencyBuildsRequired = false;
+    for (const intent of intents) {
+        const provider = definitionsByPath.get(intent.providerPackagePath);
+        if (provider === undefined) {
+            throw new Error(`Package Link Intent references unknown provider package at ${intent.providerPackagePath}`);
+        }
+        if (exposuresByPackagePath.get(provider.path)?.kind === "compiled") {
+            dependencyBuildsRequired = true;
+        }
+        const dependencies = manifestDependenciesByPackagePath.get(intent.consumerPackagePath) ?? {};
+        dependencies[provider.name] = "workspace:*";
+        manifestDependenciesByPackagePath.set(intent.consumerPackagePath, dependencies);
+    }
+    return {
+        exposuresByPackagePath,
+        manifestDependenciesByPackagePath,
+        turboTasks: packageTurboTasks({ dependencyBuildsRequired }),
+    };
+}
+export function packageTurboTasks({ dependencyBuildsRequired, }) {
+    return {
+        typecheck: { dependsOn: ["^typecheck"] },
+        build: dependencyBuildsRequired
+            ? { dependsOn: ["^build"], outputs: ["dist/**"] }
+            : { outputs: ["dist/**"] },
+        test: { dependsOn: ["^typecheck"] },
+        "test:e2e": {
+            dependsOn: dependencyBuildsRequired ? ["build", "^build"] : ["build"],
+        },
+        check: { dependsOn: ["typecheck", "build", "test", "test:e2e"] },
+        fix: { cache: false },
+    };
+}
+export function packageManifestExposureFields(exposure) {
+    switch (exposure.kind) {
+        case "jit-source":
+            return {
+                imports: {
+                    [exposure.packageLocalImportPattern]: {
+                        default: exposure.packageLocalImportTarget,
+                        types: exposure.packageLocalImportTarget,
+                    },
+                },
+                exports: {
+                    ".": {
+                        default: exposure.entrypoint,
+                        types: exposure.entrypoint,
+                    },
+                },
+            };
+        case "compiled":
+            return {
+                types: exposure.sourceTypes,
+                imports: {
+                    [exposure.packageLocalImportPattern]: {
+                        default: exposure.packageLocalImportRuntimeTarget,
+                        types: exposure.packageLocalImportTypesTarget,
+                    },
+                },
+                exports: {
+                    ".": {
+                        default: exposure.entrypoint,
+                        types: exposure.sourceTypes,
+                    },
+                },
+            };
+    }
+}

package/dist/src/preset-projection.d.ts

@@ -2,6 +2,7 @@ import type { BuiltInPreset, ProjectBlueprint } from "./declarations.js";
 import type { GenerationContext } from "./generation-context.js";
 import { type CheckPlan, type FixPlan } from "./module-graph.js";
 import { type NextStepInstruction } from "./next-step-instructions.js";
+import type { PackageRole, PackageSourcePreset } from "./package-linking.js";
 import type { DependencyMaintenancePolicy } from "./project-github.js";
 import type { RenderOperation } from "./renderer.js";
 export type PresetPackageAdditionOptions = {
@@ -15,7 +16,9 @@ export type PresetPackageAdditionOptions = {
 export type PresetPackageAdditionPlan = {
     readonly packagePath: string;
     readonly workspacePackageGlob: string;
-    readonly rootTsconfigReferences: readonly string[];
+    readonly workspaceMembershipGlob?: string;
+    readonly packageRole: PackageRole;
+    readonly packageSourcePreset: PackageSourcePreset;
     readonly sourceRoot: string;
     readonly sourceRoots?: Record<string, string>;
     readonly operations: readonly RenderOperation[];

package/dist/src/preset-source.d.ts

@@ -0,0 +1,430 @@
+import type { BuiltInPreset, ValidationResult } from "./declarations.js";
+import { type TemplateDependencyCatalog } from "./dependency-catalog.js";
+import { type PresetProjectionDeclaration } from "./projection-capabilities.js";
+export type PresetSourceManifestPresetSource = {
+    roots: string[];
+    files: string[];
+    sharedResources: string[];
+};
+export type PresetSourceManifestPreset = BuiltInPreset & {
+    dependencyCatalog?: string[];
+    projection?: PresetProjectionDeclaration;
+    source?: PresetSourceManifestPresetSource;
+};
+export type PresetSourceManifestSharedResource = {
+    id: string;
+    path: string;
+};
+export type PresetSourceFixtureMatrixPresetSupport = {
+    preset: string;
+};
+export type PresetSourceFixtureMatrixPackageAdditionSupport = {
+    preset: string;
+    packageLeafName: string;
+};
+export type PresetSourceFixtureMatrixCombination = {
+    basePreset: string;
+    addedPreset: string;
+    linkFrom?: string[];
+};
+export type PresetSourceFixtureMatrixSemanticSkip = {
+    basePreset: string;
+    addedPreset: string;
+    reason: string;
+};
+export type PresetSourceFixtureMatrixContract = {
+    initSupport: PresetSourceFixtureMatrixPresetSupport[];
+    packageAdditionSupport: PresetSourceFixtureMatrixPackageAdditionSupport[];
+    supportedCombinations: PresetSourceFixtureMatrixCombination[];
+    semanticSkips: PresetSourceFixtureMatrixSemanticSkip[];
+    checkRequirements: string[];
+    environmentPreparation: string[];
+};
+export type PresetSourceManifest = {
+    schemaVersion: 1;
+    name: string;
+    sharedResources: PresetSourceManifestSharedResource[];
+    fixtureMatrix?: PresetSourceFixtureMatrixContract;
+    presets: PresetSourceManifestPreset[];
+};
+export type PresetSourceManifestValidationOptions = {
+    readonly sourceRoot?: string;
+    readonly dependencyCatalog?: TemplateDependencyCatalog;
+};
+export declare const presetSourceManifestJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://ykdz.dev/schemas/template/preset-source-manifest.schema.json";
+    readonly title: "Preset Source Manifest";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "name", "presets"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly sharedResources: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "path"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly path: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly fixtureMatrix: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["initSupport", "packageAdditionSupport", "supportedCombinations", "semanticSkips", "checkRequirements", "environmentPreparation"];
+            readonly properties: {
+                readonly initSupport: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["preset"];
+                        readonly properties: {
+                            readonly preset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                };
+                readonly packageAdditionSupport: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["preset", "packageLeafName"];
+                        readonly properties: {
+                            readonly preset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly packageLeafName: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly pattern: "^[a-z0-9][a-z0-9-]*$";
+                            };
+                        };
+                    };
+                };
+                readonly supportedCombinations: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["basePreset", "addedPreset"];
+                        readonly properties: {
+                            readonly basePreset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly addedPreset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly linkFrom: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly semanticSkips: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["basePreset", "addedPreset", "reason"];
+                        readonly properties: {
+                            readonly basePreset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly addedPreset: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                };
+                readonly checkRequirements: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ["machine-verifiable-next-steps", "root-check-ci"];
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly environmentPreparation: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ["playwright-browser-assets"];
+                    };
+                    readonly uniqueItems: true;
+                };
+            };
+        };
+        readonly presets: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["name", "title", "description", "generation", "supportedPackageManagers", "supportedProjectKinds", "packageAdditionSupport", "features"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly title: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly generation: {
+                        readonly enum: readonly ["supported", "future"];
+                    };
+                    readonly supportedPackageManagers: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly enum: readonly ["pnpm"];
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly supportedProjectKinds: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly enum: readonly ["multi-package"];
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly packageAdditionSupport: {
+                        readonly enum: readonly ["supported", "unsupported"];
+                    };
+                    readonly features: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly enum: ("devcontainer" | "oxc-format-lint" | "cargo-test" | "github-actions" | "dependabot" | "pnpm-catalog" | "strict-typescript" | "root-check" | "fix-command" | "rustfmt-clippy" | "native-binary-release")[];
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly dependencyCatalog: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly uniqueItems: true;
+                    };
+                    readonly projection: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["capabilities"];
+                        readonly properties: {
+                            readonly capabilities: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "workspacePackageGlob", "packageRole", "packageSourcePreset", "sourceFiles"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "workspace-library-package";
+                                            };
+                                            readonly workspacePackageGlob: {
+                                                readonly const: "packages/*";
+                                            };
+                                            readonly packageRole: {
+                                                readonly const: "shared-library";
+                                            };
+                                            readonly packageSourcePreset: {
+                                                readonly const: "ts-lib";
+                                            };
+                                            readonly sourceFiles: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                };
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "workspacePackageGlob", "packages"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "workspace-node-packages";
+                                            };
+                                            readonly workspacePackageGlob: {
+                                                readonly const: "apps/*";
+                                            };
+                                            readonly packages: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["kind", "path", "sourceFiles"];
+                                                    readonly properties: {
+                                                        readonly kind: {
+                                                            readonly enum: readonly ["hono-api", "vue-app"];
+                                                        };
+                                                        readonly path: {
+                                                            readonly enum: readonly ["apps/api", "apps/web"];
+                                                        };
+                                                        readonly sourceFiles: {
+                                                            readonly type: "array";
+                                                            readonly minItems: 1;
+                                                            readonly items: {
+                                                                readonly type: "string";
+                                                                readonly minLength: 1;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly packageLinks: {
+                                                readonly type: "array";
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly additionalProperties: false;
+                                                    readonly required: readonly ["consumerPackagePath", "providerPackagePath"];
+                                                    readonly properties: {
+                                                        readonly consumerPackagePath: {
+                                                            readonly const: "apps/web";
+                                                        };
+                                                        readonly providerPackagePath: {
+                                                            readonly const: "apps/api";
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind", "workspacePackageGlob", "sourceFiles"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "rust-binary-workspace";
+                                            };
+                                            readonly workspacePackageGlob: {
+                                                readonly const: "packages/*";
+                                            };
+                                            readonly sourceFiles: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                };
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "strict-typescript-root";
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "oxc-format-lint";
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "node-pnpm-devcontainer";
+                                            };
+                                        };
+                                    }, {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["kind"];
+                                        readonly properties: {
+                                            readonly kind: {
+                                                readonly const: "github-maintenance";
+                                            };
+                                        };
+                                    }];
+                                };
+                            };
+                        };
+                    };
+                    readonly source: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly roots: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly files: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly sharedResources: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function validatePresetSourceManifest(input: unknown, options?: PresetSourceManifestValidationOptions): ValidationResult<PresetSourceManifest>;
+export declare function validateBuiltInPresetSourceManifest(input: unknown, options?: PresetSourceManifestValidationOptions): ValidationResult<PresetSourceManifest>;
+export declare function manifestReferencedSourceFiles(manifest: PresetSourceManifest, sourceRoot: string): string[];
+export declare function loadPresetSourceManifestFile(filePath: string): PresetSourceManifest;
+export declare function loadBuiltInPresetSourceManifest(): PresetSourceManifest;
+export declare function findPresetSourceManifestPreset(manifest: PresetSourceManifest, presetName: string): PresetSourceManifestPreset | undefined;
+export declare function findBuiltInPresetSourceManifestPreset(presetName: string): PresetSourceManifestPreset | undefined;