@ykdz/template 0.0.10 → 0.0.11

package/node_modules/@ykdz/template-core/dist/declarations.js

@@ -1,303 +1 @@
-import * as v from "valibot";
-const featureNames = [
-    "pnpm-catalog",
-    "oxc-format-lint",
-    "strict-typescript",
-    "root-check",
-    "fix-command",
-    "devcontainer",
-    "github-actions",
-    "dependabot",
-    "rustfmt-clippy",
-    "cargo-test",
-    "native-binary-release",
-];
-export const presetFileJsonSchema = {
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://ykdz.dev/schemas/project-kit/preset-file.schema.json",
-    title: "Project Kit Preset File",
-    type: "object",
-    additionalProperties: false,
-    required: [
-        "schemaVersion",
-        "name",
-        "title",
-        "description",
-        "supportedPackageManagers",
-        "supportedProjectKinds",
-        "features",
-    ],
-    properties: {
-        schemaVersion: { const: 1 },
-        name: { type: "string", minLength: 1 },
-        title: { type: "string", minLength: 1 },
-        description: { type: "string", minLength: 1 },
-        supportedPackageManagers: {
-            type: "array",
-            items: { enum: ["pnpm"] },
-            uniqueItems: true,
-        },
-        supportedProjectKinds: {
-            type: "array",
-            minItems: 1,
-            items: { enum: ["multi-package"] },
-            uniqueItems: true,
-        },
-        features: {
-            type: "array",
-            items: { enum: featureNames },
-            uniqueItems: true,
-        },
-    },
-};
-export const blueprintJsonSchema = {
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://ykdz.dev/schemas/project-kit/blueprint.schema.json",
-    title: "Project Kit Blueprint",
-    type: "object",
-    additionalProperties: false,
-    required: ["schemaVersion", "preset", "projectKind", "features"],
-    properties: {
-        schemaVersion: { const: 1 },
-        preset: { type: "string", minLength: 1 },
-        packageManager: { enum: ["pnpm"] },
-        projectKind: { enum: ["multi-package"] },
-        features: {
-            type: "array",
-            items: { enum: featureNames },
-            uniqueItems: true,
-        },
-        packages: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                required: ["name", "path"],
-                properties: {
-                    name: { type: "string", minLength: 1 },
-                    path: { type: "string", minLength: 1 },
-                    role: { enum: ["runtime-service", "shared-library"] },
-                    sourcePreset: { enum: ["hono-api", "ts-lib", "vue-app"] },
-                },
-            },
-        },
-        packageLinkIntents: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                required: ["consumerPackagePath", "providerPackagePath"],
-                properties: {
-                    consumerPackagePath: { type: "string", minLength: 1 },
-                    providerPackagePath: { type: "string", minLength: 1 },
-                },
-            },
-        },
-    },
-};
-const nonEmptyString = v.pipe(v.string(), v.minLength(1));
-const packageManagerSchema = v.picklist(["pnpm"]);
-const projectKindSchema = v.picklist([
-    "single-package",
-    "multi-package",
-]);
-const featureNameSchema = v.picklist(featureNames);
-const packageRoleSchema = v.picklist([
-    "runtime-service",
-    "shared-library",
-]);
-const packageSourcePresetSchema = v.picklist([
-    "hono-api",
-    "ts-lib",
-    "vue-app",
-]);
-export const presetFileSchema = v.strictObject({
-    schemaVersion: v.literal(1),
-    name: nonEmptyString,
-    title: nonEmptyString,
-    description: nonEmptyString,
-    supportedPackageManagers: v.array(packageManagerSchema),
-    supportedProjectKinds: v.pipe(v.array(projectKindSchema), v.minLength(1)),
-    features: v.array(featureNameSchema),
-});
-export const projectBlueprintSchema = v.strictObject({
-    schemaVersion: v.literal(1),
-    preset: nonEmptyString,
-    packageManager: v.optional(packageManagerSchema),
-    projectKind: projectKindSchema,
-    features: v.array(featureNameSchema),
-    packages: v.optional(v.array(v.strictObject({
-        name: nonEmptyString,
-        path: nonEmptyString,
-        role: v.optional(packageRoleSchema),
-        sourcePreset: v.optional(packageSourcePresetSchema),
-    }))),
-    packageLinkIntents: v.optional(v.array(v.strictObject({
-        consumerPackagePath: nonEmptyString,
-        providerPackagePath: nonEmptyString,
-    }))),
-});
-function formatIssuePath(issue) {
-    if (!issue.path || issue.path.length === 0) {
-        return "$";
-    }
-    return issue.path.reduce((path, item) => `${path}.${String(item.key)}`, "$");
-}
-function shapeIssues(issues) {
-    return issues.map((issue) => ({
-        path: formatIssuePath(issue),
-        message: issue.message,
-    }));
-}
-function duplicateIssues(values, path) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const value of values) {
-        if (seen.has(value)) {
-            duplicates.add(value);
-        }
-        seen.add(value);
-    }
-    return [...duplicates].map((value) => ({
-        path,
-        message: `Duplicate value: ${value}`,
-    }));
-}
-function generationSupportIssue(preset, path) {
-    if (preset.generation === "supported") {
-        return undefined;
-    }
-    return {
-        path,
-        message: `Preset ${preset.name} is not supported for generation in this version`,
-    };
-}
-function unsupportedSinglePackageProjectShapeIssue(path) {
-    return {
-        path,
-        message: "single-package Project Shape is unsupported in V1; use the workspace monorepo Project Shape",
-    };
-}
-export function validatePresetFile(input, options = {}) {
-    const result = v.safeParse(presetFileSchema, input);
-    if (!result.success) {
-        return { ok: false, issues: shapeIssues(result.issues) };
-    }
-    const semanticIssues = [
-        ...duplicateIssues(result.output.supportedPackageManagers, "$.supportedPackageManagers"),
-        ...duplicateIssues(result.output.supportedProjectKinds, "$.supportedProjectKinds"),
-        ...duplicateIssues(result.output.features, "$.features"),
-    ];
-    if (result.output.supportedProjectKinds.includes("single-package")) {
-        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.supportedProjectKinds"));
-    }
-    const catalogPreset = findPreset(options.presets ?? [], result.output.name);
-    const unsupportedGeneration = catalogPreset
-        ? generationSupportIssue(catalogPreset, "$.name")
-        : undefined;
-    if (unsupportedGeneration) {
-        semanticIssues.push(unsupportedGeneration);
-    }
-    if (semanticIssues.length > 0) {
-        return { ok: false, issues: semanticIssues };
-    }
-    return { ok: true, value: result.output };
-}
-export function findPreset(presets, name) {
-    return presets.find((preset) => preset.name === name);
-}
-function normalizeProjectBlueprint(blueprint) {
-    return {
-        schemaVersion: blueprint.schemaVersion,
-        preset: blueprint.preset,
-        ...(blueprint.packageManager === undefined
-            ? {}
-            : { packageManager: blueprint.packageManager }),
-        projectKind: blueprint.projectKind,
-        features: [...blueprint.features],
-        ...(blueprint.packages === undefined
-            ? {}
-            : {
-                packages: blueprint.packages.map((projectPackage) => ({
-                    name: projectPackage.name,
-                    path: projectPackage.path,
-                    ...(projectPackage.role === undefined
-                        ? {}
-                        : { role: projectPackage.role }),
-                    ...(projectPackage.sourcePreset === undefined
-                        ? {}
-                        : { sourcePreset: projectPackage.sourcePreset }),
-                })),
-            }),
-        ...(blueprint.packageLinkIntents === undefined
-            ? {}
-            : {
-                packageLinkIntents: blueprint.packageLinkIntents.map((intent) => ({
-                    consumerPackagePath: intent.consumerPackagePath,
-                    providerPackagePath: intent.providerPackagePath,
-                })),
-            }),
-    };
-}
-export function validateProjectBlueprint(input, options = {}) {
-    const result = v.safeParse(projectBlueprintSchema, input);
-    if (!result.success) {
-        return { ok: false, issues: shapeIssues(result.issues) };
-    }
-    const blueprint = normalizeProjectBlueprint(result.output);
-    const preset = findPreset(options.presets ?? [], blueprint.preset);
-    const semanticIssues = [
-        ...duplicateIssues(blueprint.features, "$.features"),
-    ];
-    if (blueprint.projectKind === "single-package") {
-        semanticIssues.push(unsupportedSinglePackageProjectShapeIssue("$.projectKind"));
-    }
-    if (options.presets && !preset) {
-        semanticIssues.push({
-            path: "$.preset",
-            message: `Unknown ${options.presetLabel ?? "built-in"} preset: ${blueprint.preset}`,
-        });
-    }
-    else if (preset) {
-        const unsupportedGeneration = generationSupportIssue(preset, "$.preset");
-        if (unsupportedGeneration) {
-            semanticIssues.push(unsupportedGeneration);
-        }
-        if (blueprint.packageManager &&
-            !preset.supportedPackageManagers.includes(blueprint.packageManager)) {
-            semanticIssues.push({
-                path: "$.packageManager",
-                message: `${blueprint.packageManager} is not supported by preset ${preset.name}`,
-            });
-        }
-        if (!blueprint.packageManager &&
-            preset.supportedPackageManagers.length > 0) {
-            semanticIssues.push({
-                path: "$.packageManager",
-                message: `packageManager is required by preset ${preset.name}`,
-            });
-        }
-        if (!preset.supportedProjectKinds.includes(blueprint.projectKind)) {
-            semanticIssues.push({
-                path: "$.projectKind",
-                message: `${blueprint.projectKind} is not supported by preset ${preset.name}`,
-            });
-        }
-        const supportedFeatures = new Set(preset.features);
-        for (const feature of blueprint.features) {
-            if (!supportedFeatures.has(feature)) {
-                semanticIssues.push({
-                    path: "$.features",
-                    message: `${feature} is not supported by preset ${preset.name}`,
-                });
-            }
-        }
-    }
-    if (blueprint.packages) {
-        semanticIssues.push(...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.name), "$.packages.name"), ...duplicateIssues(blueprint.packages.map((projectPackage) => projectPackage.path), "$.packages.path"));
-    }
-    if (semanticIssues.length > 0) {
-        return { ok: false, issues: semanticIssues };
-    }
-    return { ok: true, value: blueprint };
-}
+export { blueprintJsonSchema, findPreset, presetFileJsonSchema, presetFileSchema, projectBlueprintSchema, validatePresetFile, validateProjectBlueprint, } from "@ykdz/template-shared";

package/node_modules/@ykdz/template-core/dist/devcontainer.d.ts

@@ -13,6 +13,21 @@ export type DevelopmentContainerRustLayer = {
     readonly toolchain: string;
 };
 type DevelopmentContainerCapabilityLayer = DevelopmentContainerBrowserTestLayer | DevelopmentContainerRustLayer;
+export type DevelopmentContainerDockerfileFragments = {
+    readonly sourceRoot: string;
+    readonly nodePnpm: {
+        readonly from: string;
+        readonly text: string;
+    };
+    readonly browserTest?: {
+        readonly from: string;
+        readonly text: string;
+    } | undefined;
+    readonly rust?: {
+        readonly from: string;
+        readonly text: string;
+    } | undefined;
+};
 export type DevelopmentContainerPlan = {
     readonly devcontainer: Record<string, unknown>;
     readonly dockerfile: string;
@@ -43,6 +58,7 @@ export declare function dockerfileFirstNodePnpmDevcontainer(options: {
 export declare function checkedDockerfileFirstNodePnpmDevcontainer(options: {
     readonly name: string;
     readonly layer: DevelopmentContainerNodePnpmLayer;
+    readonly dockerfileFragments: DevelopmentContainerDockerfileFragments;
     readonly additionalLayers?: readonly DevelopmentContainerCapabilityLayer[] | undefined;
     readonly extensions: readonly string[];
     readonly settings?: Record<string, unknown> | undefined;
@@ -52,6 +68,7 @@ export declare function dockerfileFirstRustPnpmDevcontainer(options: {
     readonly name: string;
     readonly nodeLayer: DevelopmentContainerNodePnpmLayer;
     readonly rustLayer: DevelopmentContainerRustLayer;
+    readonly dockerfileFragments: DevelopmentContainerDockerfileFragments;
     readonly extensions: readonly string[];
     readonly settings?: Record<string, unknown> | undefined;
 }): DevelopmentContainerPlan;

package/node_modules/@ykdz/template-core/dist/devcontainer.js

@@ -1,8 +1,11 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { loadTemplateDependencyCatalog } from "./dependency-catalog.js";
-import { packageTemplateRoot } from "./runtime-paths.js";
+function requireDockerfileFragment(fragments, name) {
+    const fragment = fragments[name];
+    if (fragment === undefined) {
+        throw new Error(`Development Container Dockerfile fragment is missing: ${name}`);
+    }
+    return fragment;
+}
 const runtimeDockerfileInstructions = new Set([
     "CMD",
     "ENTRYPOINT",
@@ -61,19 +64,13 @@ export function browserTestToolLayer() {
 export function rustToolLayer(options = {}) {
     return { kind: "rust", toolchain: options.toolchain ?? "stable" };
 }
-function sharedDevcontainerSourceRoot() {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "devcontainer");
-}
-function checkedDockerfileFragment(name) {
-    return readFileSync(path.join(sharedDevcontainerSourceRoot(), name), "utf8");
-}
-function checkedNodePnpmDockerfile(options = {}) {
+function checkedNodePnpmDockerfile(options) {
     return composeDevelopmentContainerDockerfile({
         layers: [
             {
                 kind: "base",
                 name: "node-pnpm",
-                text: checkedDockerfileFragment("node-pnpm.Dockerfile"),
+                text: options.dockerfileFragments.nodePnpm.text,
             },
             ...(options.additionalLayers ?? []).map((layer) => {
                 switch (layer.kind) {
@@ -81,36 +78,37 @@ function checkedNodePnpmDockerfile(options = {}) {
                         return {
                             kind: "capability",
                             name: "browser-test",
-                            text: checkedDockerfileFragment("browser-test.Dockerfile"),
+                            text: requireDockerfileFragment(options.dockerfileFragments, "browserTest").text,
                         };
                     case "rust":
                         return {
                             kind: "capability",
                             name: "rust",
-                            text: checkedDockerfileFragment("rust.Dockerfile"),
+                            text: requireDockerfileFragment(options.dockerfileFragments, "rust").text,
                         };
                 }
             }),
         ],
     });
 }
-function checkedNodePnpmDockerfileFragments(options = {}) {
+function checkedNodePnpmDockerfileFragments(options) {
     return [
         {
-            sourceRoot: "sharedDevcontainer",
-            from: "node-pnpm.Dockerfile",
+            sourceRoot: options.dockerfileFragments.sourceRoot,
+            from: options.dockerfileFragments.nodePnpm.from,
         },
         ...(options.additionalLayers ?? []).map((layer) => {
             switch (layer.kind) {
                 case "browser-test":
                     return {
-                        sourceRoot: "sharedDevcontainer",
-                        from: "browser-test.Dockerfile",
+                        sourceRoot: options.dockerfileFragments.sourceRoot,
+                        from: requireDockerfileFragment(options.dockerfileFragments, "browserTest").from,
                     };
                 case "rust":
                     return {
-                        sourceRoot: "sharedDevcontainer",
-                        from: "rust.Dockerfile",
+                        sourceRoot: options.dockerfileFragments.sourceRoot,
+                        from: requireDockerfileFragment(options.dockerfileFragments, "rust")
+                            .from,
                     };
             }
         }),
@@ -175,12 +173,14 @@ export function checkedDockerfileFirstNodePnpmDevcontainer(options) {
             ...(options.mounts ? { mounts: options.mounts } : {}),
         },
         dockerfile: checkedNodePnpmDockerfile({
+            dockerfileFragments: options.dockerfileFragments,
             additionalLayers: options.additionalLayers,
         }),
         dockerfileOperation: {
             kind: "writeTextFromFragments",
             to: ".devcontainer/Dockerfile",
             fragments: checkedNodePnpmDockerfileFragments({
+                dockerfileFragments: options.dockerfileFragments,
                 additionalLayers: options.additionalLayers,
             }),
         },
@@ -190,6 +190,7 @@ export function dockerfileFirstRustPnpmDevcontainer(options) {
     return checkedDockerfileFirstNodePnpmDevcontainer({
         name: options.name,
         layer: options.nodeLayer,
+        dockerfileFragments: options.dockerfileFragments,
         additionalLayers: [options.rustLayer],
         extensions: options.extensions,
         settings: options.settings,

package/node_modules/@ykdz/template-core/dist/editor-customization.d.ts

@@ -9,4 +9,13 @@ export type EditorCustomizationOptions = {
         readonly formatter?: string;
     };
 };
-export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], options?: EditorCustomizationOptions): EditorCustomization;
+type CapabilityProjection = {
+    readonly extensions: readonly string[];
+    readonly settings: Record<string, unknown>;
+};
+export type EditorCustomizationDeclarations = {
+    readonly capabilities: Record<EditorCustomizationCapability, CapabilityProjection>;
+};
+export declare function loadEditorCustomizationDeclarations(resourcePath: string): EditorCustomizationDeclarations;
+export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], declarations: EditorCustomizationDeclarations, options?: EditorCustomizationOptions): EditorCustomization;
+export {};

package/node_modules/@ykdz/template-core/dist/editor-customization.js

@@ -1,6 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 import * as v from "valibot";
 const capabilityOrder = [
     "oxc-format-lint",
@@ -26,28 +24,40 @@ const editorCustomizationDeclarationsSchema = v.object({
         vitest: capabilityProjectionSchema,
     }),
 });
-const declarations = loadEditorCustomizationDeclarations();
-function editorCustomizationDeclarationPath() {
-    const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
-    const relativeDeclarationPath = "builtin-source/templates/shared/editor-customization/capabilities.json";
-    const candidates = [
-        path.resolve(moduleDirectory, "..", relativeDeclarationPath),
-        path.resolve(moduleDirectory, "..", "..", relativeDeclarationPath),
-        path.resolve(moduleDirectory, "..", "..", "template-builtin-source", "templates", "shared", "editor-customization", "capabilities.json"),
-        path.resolve(moduleDirectory, "..", "..", "..", "packages", relativeDeclarationPath),
-    ];
-    const declarationPath = candidates.find((candidate) => existsSync(candidate));
-    if (!declarationPath) {
-        throw new Error(`Unable to find editor customization declarations at ${relativeDeclarationPath}`);
-    }
-    return declarationPath;
+function editorCustomizationDeclarationIssuePath(issue) {
+    const segments = issue.path?.flatMap((item) => typeof item.key === "string" || typeof item.key === "number"
+        ? [String(item.key)]
+        : []) ?? [];
+    return segments.length === 0 ? "$" : `$.${segments.join(".")}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-function loadEditorCustomizationDeclarations() {
-    const source = JSON.parse(readFileSync(editorCustomizationDeclarationPath(), "utf8"));
+function editorCustomizationSharedResourceLabel(resourcePath) {
+    return `Editor Customization Shared Resource ${resourcePath}`;
+}
+export function loadEditorCustomizationDeclarations(resourcePath) {
+    const resourceLabel = editorCustomizationSharedResourceLabel(resourcePath);
+    let resourceText;
+    try {
+        resourceText = readFileSync(resourcePath, "utf8");
+    }
+    catch (error) {
+        throw new Error(`${resourceLabel} is unreadable: ${errorMessage(error)}`, {
+            cause: error,
+        });
+    }
+    let source;
+    try {
+        source = JSON.parse(resourceText);
+    }
+    catch (error) {
+        throw new Error(`${resourceLabel} is invalid: invalid JSON: ${errorMessage(error)}`, { cause: error });
+    }
     const result = v.safeParse(editorCustomizationDeclarationsSchema, source);
     if (!result.success) {
-        throw new Error(`Editor customization declarations are invalid: ${result.issues
-            .map((issue) => issue.message)
+        throw new Error(`${resourceLabel} is invalid: ${result.issues
+            .map((issue) => `${editorCustomizationDeclarationIssuePath(issue)}: ${issue.message}`)
             .join("; ")}`);
     }
     return result.output;
@@ -66,19 +76,19 @@ function oxcConfigPathSettings(configPaths) {
     };
 }
 function oxcProjection(options) {
-    const baseProjection = declarations.capabilities["oxc-format-lint"];
+    const baseProjection = options.declarations.capabilities["oxc-format-lint"];
     return {
         extensions: baseProjection.extensions,
         settings: {
             ...baseProjection.settings,
-            ...oxcConfigPathSettings(options?.oxcConfigPaths),
+            ...oxcConfigPathSettings(options.editorOptions?.oxcConfigPaths),
         },
     };
 }
 function mergeSettings(base, patch) {
     return { ...base, ...patch };
 }
-export function editorCustomizationForCapabilities(capabilities, options) {
+export function editorCustomizationForCapabilities(capabilities, declarations, options) {
     const selected = new Set(capabilities);
     const extensions = new Set();
     let settings = {};
@@ -87,7 +97,7 @@ export function editorCustomizationForCapabilities(capabilities, options) {
             continue;
         }
         const projection = capability === "oxc-format-lint"
-            ? oxcProjection(options)
+            ? oxcProjection({ declarations, editorOptions: options })
             : declarations.capabilities[capability];
         for (const extension of projection.extensions) {
             extensions.add(extension);

package/node_modules/@ykdz/template-core/dist/generated-scenarios.d.ts

@@ -1,3 +1,4 @@
+import { type CheckEnvironmentNeed } from "./module-graph.js";
 import type { PresetSourceManifest } from "./preset-source.js";
 import { type PresetProjectionSourceRoots } from "./projection-capabilities.js";
 export type GeneratedScenarioSet = "init" | "package-addition-matrix";
@@ -27,6 +28,7 @@ export type GeneratedScenarioCommandStep = {
     readonly args: readonly string[];
     readonly cwd: string;
     readonly display: string;
+    readonly environmentNeedKind?: CheckEnvironmentNeed["kind"];
 };
 export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
     readonly env?: Record<string, string> | undefined;
@@ -58,6 +60,8 @@ export declare function defaultGeneratedScenarioCommandRunner(command: string, a
     readonly env?: Record<string, string> | undefined;
     readonly logPrefix?: string | undefined;
 }): Promise<void>;
+export declare function generatedScenarioEnvironmentNeedSteps(needs: readonly CheckEnvironmentNeed[], projectDir: string): GeneratedScenarioCommandStep[];
+export declare function generatedScenarioRequiresSerializedRootCheck(steps: readonly GeneratedScenarioCommandStep[]): boolean;
 export declare function generatedScenarioQualityGateSteps(manifest: PresetSourceManifest, scenario: GeneratedScenario, projectDir: string, addedPackagePath: string | undefined, options: GeneratedScenarioRunnerOptions): GeneratedScenarioCommandStep[];
 export declare function fixtureConcurrency(scenarioCount: number): number;
 export declare function errorForFailedGeneratedScenario(scenario: GeneratedScenario, error: unknown): Error;