@ykdz/template 0.0.9 → 0.0.11

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

@@ -1,203 +1,2 @@
-import * as v from "valibot";
-import type { PackageAdditionSupport } from "./package-addition-support.js";
-import type { PackageLinkIntent, PackageRole, PackageSourcePreset } from "./package-linking.js";
-export type BuiltInPreset = {
-    name: string;
-    title: string;
-    description: string;
-    generation: "supported" | "future";
-    supportedPackageManagers: readonly PackageManager[];
-    supportedProjectKinds: readonly ProjectKind[];
-    packageAdditionSupport: PackageAdditionSupport;
-    features: readonly FeatureName[];
-};
-export type PackageManager = "pnpm";
-export type ProjectKind = "single-package" | "multi-package";
-export type FeatureName = "pnpm-catalog" | "oxc-format-lint" | "strict-typescript" | "root-check" | "fix-command" | "devcontainer" | "github-actions" | "dependabot" | "rustfmt-clippy" | "cargo-test" | "native-binary-release";
-export type PresetFile = {
-    schemaVersion: 1;
-    name: string;
-    title: string;
-    description: string;
-    supportedPackageManagers: PackageManager[];
-    supportedProjectKinds: ProjectKind[];
-    features: FeatureName[];
-};
-export type ProjectPackage = {
-    name: string;
-    path: string;
-    role?: PackageRole;
-    sourcePreset?: PackageSourcePreset;
-};
-export type ProjectBlueprint = {
-    schemaVersion: 1;
-    preset: string;
-    packageManager?: PackageManager;
-    projectKind: ProjectKind;
-    features: FeatureName[];
-    packages?: ProjectPackage[];
-    packageLinkIntents?: PackageLinkIntent[];
-};
-export declare const presetFileJsonSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://ykdz.dev/schemas/project-kit/preset-file.schema.json";
-    readonly title: "Project Kit Preset File";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["schemaVersion", "name", "title", "description", "supportedPackageManagers", "supportedProjectKinds", "features"];
-    readonly properties: {
-        readonly schemaVersion: {
-            readonly const: 1;
-        };
-        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 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 features: {
-            readonly type: "array";
-            readonly items: {
-                readonly enum: FeatureName[];
-            };
-            readonly uniqueItems: true;
-        };
-    };
-};
-export declare const blueprintJsonSchema: {
-    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://ykdz.dev/schemas/project-kit/blueprint.schema.json";
-    readonly title: "Project Kit Blueprint";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["schemaVersion", "preset", "projectKind", "features"];
-    readonly properties: {
-        readonly schemaVersion: {
-            readonly const: 1;
-        };
-        readonly preset: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly packageManager: {
-            readonly enum: readonly ["pnpm"];
-        };
-        readonly projectKind: {
-            readonly enum: readonly ["multi-package"];
-        };
-        readonly features: {
-            readonly type: "array";
-            readonly items: {
-                readonly enum: FeatureName[];
-            };
-            readonly uniqueItems: true;
-        };
-        readonly packages: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["name", "path"];
-                readonly properties: {
-                    readonly name: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly path: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly role: {
-                        readonly enum: readonly ["runtime-service", "shared-library"];
-                    };
-                    readonly sourcePreset: {
-                        readonly enum: readonly ["hono-api", "ts-lib", "vue-app"];
-                    };
-                };
-            };
-        };
-        readonly packageLinkIntents: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["consumerPackagePath", "providerPackagePath"];
-                readonly properties: {
-                    readonly consumerPackagePath: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly providerPackagePath: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-            };
-        };
-    };
-};
-export declare const presetFileSchema: v.StrictObjectSchema<{
-    readonly schemaVersion: v.LiteralSchema<1, undefined>;
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly supportedPackageManagers: v.ArraySchema<v.PicklistSchema<["pnpm"], undefined>, undefined>;
-    readonly supportedProjectKinds: v.SchemaWithPipe<readonly [v.ArraySchema<v.PicklistSchema<["single-package", "multi-package"], undefined>, undefined>, v.MinLengthAction<("single-package" | "multi-package")[], 1, undefined>]>;
-    readonly features: v.ArraySchema<v.PicklistSchema<FeatureName[], undefined>, undefined>;
-}, undefined>;
-export declare const projectBlueprintSchema: v.StrictObjectSchema<{
-    readonly schemaVersion: v.LiteralSchema<1, undefined>;
-    readonly preset: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly packageManager: v.OptionalSchema<v.PicklistSchema<["pnpm"], undefined>, undefined>;
-    readonly projectKind: v.PicklistSchema<["single-package", "multi-package"], undefined>;
-    readonly features: v.ArraySchema<v.PicklistSchema<FeatureName[], undefined>, undefined>;
-    readonly packages: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
-        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly role: v.OptionalSchema<v.PicklistSchema<["runtime-service", "shared-library"], undefined>, undefined>;
-        readonly sourcePreset: v.OptionalSchema<v.PicklistSchema<["hono-api", "ts-lib", "vue-app"], undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
-        readonly consumerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly providerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type ValidationIssue = {
-    path: string;
-    message: string;
-};
-export type ValidationResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    issues: ValidationIssue[];
-};
-export type PresetCatalogValidationOptions = {
-    readonly presets?: readonly BuiltInPreset[];
-    readonly presetLabel?: string;
-};
-export declare function validatePresetFile(input: unknown, options?: PresetCatalogValidationOptions): ValidationResult<PresetFile>;
-export declare function findPreset(presets: readonly BuiltInPreset[], name: string): BuiltInPreset | undefined;
-export declare function validateProjectBlueprint(input: unknown, options?: PresetCatalogValidationOptions): ValidationResult<ProjectBlueprint>;
+export { blueprintJsonSchema, findPreset, presetFileJsonSchema, presetFileSchema, projectBlueprintSchema, validatePresetFile, validateProjectBlueprint, } from "@ykdz/template-shared";
+export type { BuiltInPreset, FeatureName, PackageManager, PresetCatalogValidationOptions, PresetFile, ProjectBlueprint, ProjectKind, ProjectPackage, ValidationIssue, ValidationResult, } from "@ykdz/template-shared";

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 {};