@ykdz/template 0.0.8 → 0.0.9

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import * as v from "valibot";
 const capabilityOrder = [
     "oxc-format-lint",
     "vue",
@@ -12,6 +13,19 @@ const defaultOxcConfigPaths = {
     formatter: "./oxfmt.config.ts",
     lint: "./oxlint.config.ts",
 };
+const capabilityProjectionSchema = v.object({
+    extensions: v.array(v.string()),
+    settings: v.record(v.string(), v.unknown()),
+});
+const editorCustomizationDeclarationsSchema = v.object({
+    capabilities: v.object({
+        "oxc-format-lint": capabilityProjectionSchema,
+        vue: capabilityProjectionSchema,
+        tailwind: capabilityProjectionSchema,
+        "rust-tooling": capabilityProjectionSchema,
+        vitest: capabilityProjectionSchema,
+    }),
+});
 const declarations = loadEditorCustomizationDeclarations();
 function editorCustomizationDeclarationPath() {
     const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
@@ -28,38 +42,15 @@ function editorCustomizationDeclarationPath() {
     }
     return declarationPath;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assertCapabilityProjection(capability, value) {
-    if (!isRecord(value)) {
-        throw new Error(`Editor customization ${capability} must be an object`);
-    }
-    const extensions = value.extensions;
-    const settings = value.settings;
-    if (!Array.isArray(extensions) ||
-        extensions.some((extension) => typeof extension !== "string")) {
-        throw new Error(`Editor customization ${capability} must declare string extensions`);
-    }
-    if (!isRecord(settings)) {
-        throw new Error(`Editor customization ${capability} must declare object settings`);
-    }
-}
 function loadEditorCustomizationDeclarations() {
     const source = JSON.parse(readFileSync(editorCustomizationDeclarationPath(), "utf8"));
-    if (!isRecord(source) || !isRecord(source.capabilities)) {
-        throw new Error("Editor customization declarations must contain capabilities");
+    const result = v.safeParse(editorCustomizationDeclarationsSchema, source);
+    if (!result.success) {
+        throw new Error(`Editor customization declarations are invalid: ${result.issues
+            .map((issue) => issue.message)
+            .join("; ")}`);
     }
-    const capabilities = source.capabilities;
-    for (const capability of capabilityOrder) {
-        assertCapabilityProjection(capability, capabilities[capability]);
-    }
-    return {
-        capabilities: Object.fromEntries(capabilityOrder.map((capability) => [
-            capability,
-            capabilities[capability],
-        ])),
-    };
+    return result.output;
 }
 function oxcConfigPathSettings(configPaths) {
     if (configPaths === "nested") {

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

@@ -29,8 +29,8 @@ export type GeneratedScenarioCommandStep = {
     readonly display: string;
 };
 export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
-    readonly env?: Record<string, string>;
-    readonly logPrefix?: string;
+    readonly env?: Record<string, string> | undefined;
+    readonly logPrefix?: string | undefined;
 }) => Promise<void>;
 export type GeneratedScenarioReporter = {
     readonly info?: (message: string) => void;
@@ -54,8 +54,8 @@ export declare function generatedScenarioLabel(scenario: Pick<GeneratedScenario,
 export declare function selectGeneratedScenarios(manifest: PresetSourceManifest, set: GeneratedScenarioSet): GeneratedScenarioSelection;
 export declare function packageLeafNameForAddedPreset(manifest: PresetSourceManifest, presetName: string): string;
 export declare function defaultGeneratedScenarioCommandRunner(command: string, args: readonly string[], cwd: string, options?: {
-    readonly env?: Record<string, string>;
-    readonly logPrefix?: string;
+    readonly env?: Record<string, string> | undefined;
+    readonly logPrefix?: string | undefined;
 }): Promise<void>;
 export declare function generatedScenarioQualityGateSteps(manifest: PresetSourceManifest, scenario: GeneratedScenario, projectDir: string, addedPackagePath: string | undefined, options: GeneratedScenarioRunnerOptions): GeneratedScenarioCommandStep[];
 export declare function fixtureConcurrency(scenarioCount: number): number;

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

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { execa } from "execa";
+import * as v from "valibot";
 import { assembleGenerationContext } from "./generation-context.js";
 import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 import { planNextStepInstructions } from "./next-step-instructions.js";
@@ -10,6 +11,12 @@ const defaultDeterministicToolchainEnv = {
     TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
 };
 const defaultFixtureConcurrency = 2;
+const storedBlueprintSchema = v.object({
+    packages: v.optional(v.array(v.object({
+        name: v.string(),
+        path: v.string(),
+    }))),
+});
 function cliSourceExecutionEnv(options, env = {}) {
     return {
         ...env,
@@ -60,8 +67,10 @@ function createGeneratedScenario(set, input) {
     return {
         set,
         basePreset: input.basePreset,
-        addedPreset: input.addedPreset,
-        linkFrom: input.linkFrom ? [...input.linkFrom] : undefined,
+        ...(input.addedPreset === undefined
+            ? {}
+            : { addedPreset: input.addedPreset }),
+        ...(input.linkFrom === undefined ? {} : { linkFrom: [...input.linkFrom] }),
         id: generatedScenarioId(input),
         label: generatedScenarioLabel(input),
     };
@@ -78,7 +87,9 @@ export function selectGeneratedScenarios(manifest, set) {
     const matrixScenarios = contract.supportedCombinations.map((combination) => createGeneratedScenario(set, {
         basePreset: combination.basePreset,
         addedPreset: combination.addedPreset,
-        linkFrom: combination.linkFrom,
+        ...(combination.linkFrom === undefined
+            ? {}
+            : { linkFrom: combination.linkFrom }),
     }));
     const skipped = contract.semanticSkips.map((skip) => ({
         set,
@@ -105,7 +116,7 @@ export async function defaultGeneratedScenarioCommandRunner(command, args, cwd,
     console.log(`${prefix}$ ${[command, ...args].join(" ")}`);
     await execa(command, [...args], {
         cwd,
-        env: options.env,
+        ...(options.env === undefined ? {} : { env: options.env }),
         stdio: "inherit",
     });
 }
@@ -163,7 +174,7 @@ async function linkedConsumerSourceSnapshots(projectDir, packagePaths) {
 async function sourceFileSnapshot(sourceDir, currentDir = sourceDir) {
     const snapshot = {};
     const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    for (const entry of entries.toSorted((left, right) => left.name.localeCompare(right.name))) {
         const entryPath = path.join(currentDir, entry.name);
         if (entry.isDirectory()) {
             Object.assign(snapshot, await sourceFileSnapshot(sourceDir, entryPath));
@@ -184,8 +195,14 @@ async function assertLinkedConsumerSourcesUnchanged(projectDir, beforeSnapshots)
     }
 }
 async function readAddedPackagePath(projectDir, packageLeafName) {
-    const blueprint = JSON.parse(await readFile(path.join(projectDir, ".template", "blueprint.json"), "utf8"));
-    const packageDefinition = blueprint.packages?.find((pkg) => path.basename(pkg.path) === packageLeafName);
+    const input = JSON.parse(await readFile(path.join(projectDir, ".template", "blueprint.json"), "utf8"));
+    const result = v.safeParse(storedBlueprintSchema, input);
+    if (!result.success) {
+        throw new Error(`Generated Repository blueprint is invalid: ${result.issues
+            .map((issue) => issue.message)
+            .join("; ")}`);
+    }
+    const packageDefinition = result.output.packages?.find((pkg) => path.basename(pkg.path) === packageLeafName);
     if (!packageDefinition) {
         throw new Error(`Package Addition fixture did not record package leaf ${packageLeafName}`);
     }
@@ -198,7 +215,7 @@ function projectionPlanForPreset(presetName, projectDir, manifest, options, pack
     }
     const blueprint = blueprintForPresetSourcePreset(preset, {
         targetDir: projectDir,
-        scope: packageScope,
+        ...(packageScope === undefined ? {} : { scope: packageScope }),
     });
     return projectPresetSourcePreset({
         preset,
@@ -248,6 +265,9 @@ function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackag
 function environmentNeedStep(need, projectDir) {
     const display = renderPlaywrightBrowserInstallCommand(need);
     const [command, ...args] = display.split(" ");
+    if (command === undefined) {
+        throw new Error(`Cannot parse environment setup command: ${display}`);
+    }
     return {
         id: `install-${need.owner.path}-playwright-browsers`,
         command,
@@ -282,7 +302,7 @@ async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, a
         const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
         const runStep = async () => {
             await options.runCommand(step.command, [...step.args], step.cwd, {
-                env,
+                ...(env === undefined ? {} : { env }),
                 logPrefix: scenario.label,
             });
         };

package/node_modules/@ykdz/template-core/dist/generation-context.js

@@ -6,9 +6,14 @@ export function assembleGenerationContext(options) {
             value: path.basename(path.resolve(options.targetDir)),
         },
         preset: options.blueprint.preset,
-        packageManager: options.blueprint.packageManager
-            ? { kind: "PackageManager", value: options.blueprint.packageManager }
-            : undefined,
+        ...(options.blueprint.packageManager
+            ? {
+                packageManager: {
+                    kind: "PackageManager",
+                    value: options.blueprint.packageManager,
+                },
+            }
+            : {}),
         blueprint: options.blueprint,
         toolchain: options.toolchain,
     };

package/node_modules/@ykdz/template-core/dist/next-step-instructions.js

@@ -73,6 +73,9 @@ function checkEnvironmentInstructions(plan) {
     return plan.checkPlan.environmentNeeds.map((need) => {
         const display = renderPlaywrightBrowserInstallCommand(need);
         const [command, ...args] = display.split(" ");
+        if (command === undefined) {
+            throw new Error(`Cannot parse environment setup command: ${display}`);
+        }
         return {
             id: need.owner.path === "apps/web"
                 ? "install-web-playwright-browsers"

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

@@ -4,8 +4,8 @@ export type AddPackageOptions = {
     cwd: string;
     preset: string;
     name: string;
-    path?: string;
-    linkFrom?: readonly string[];
+    path?: string | undefined;
+    linkFrom?: readonly string[] | undefined;
     presetSourceManifest: PresetSourceManifest;
     projectionSourceRoots: PresetProjectionSourceRoots;
 };

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

@@ -10,7 +10,7 @@ import { renderProject } from "./renderer.js";
 function projectNameFromBlueprint(blueprint, fallbackProjectName) {
     const firstPackage = blueprint.packages?.[0];
     const match = firstPackage?.name.match(/^@([^/]+)\//);
-    if (match) {
+    if (match?.[1]) {
         return match[1];
     }
     if (/^[a-z0-9][a-z0-9._-]*$/.test(fallbackProjectName)) {
@@ -314,9 +314,17 @@ async function packageManifestsForTaskGraph(options) {
     for (const packageDefinition of options.blueprint.packages ?? []) {
         const manifestOverride = options.manifestOverrides?.get(packageDefinition.path);
         const manifestFromOperations = generatedPackageManifestFromOperations(options.operations, packageDefinition.path);
-        manifests.push(manifestOverride ??
-            manifestFromOperations ??
-            (await readJson(path.join(options.root, packageDefinition.path, "package.json"))));
+        if (manifestOverride !== undefined) {
+            manifests.push(manifestOverride);
+            continue;
+        }
+        if (manifestFromOperations !== undefined) {
+            manifests.push(manifestFromOperations);
+            continue;
+        }
+        const manifest = await readJson(path.join(options.root, packageDefinition.path, "package.json"));
+        assertObjectManifest(manifest, packageDefinition.path);
+        manifests.push(manifest);
     }
     return manifests;
 }
@@ -348,7 +356,7 @@ function assertObjectManifest(input, packagePath) {
     }
 }
 function recordSortedByKey(record) {
-    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+    return Object.fromEntries(Object.entries(record).toSorted(([left], [right]) => left.localeCompare(right)));
 }
 async function consumerManifestUpdatesForPackageLinkIntents(options) {
     const updates = [];
@@ -425,16 +433,21 @@ function rootPackageJsonWithPackageTaskFilters(input, blueprint, packageManifest
     assertRootPackageJson(input);
     const workspacePackageGlobs = workspacePackageGlobsFromBlueprint(blueprint);
     const taskNames = turboTaskNamesForPackageManifests(packageManifests);
+    const checkScript = input.scripts.check;
+    const fixScript = input.scripts.fix;
+    if (checkScript === undefined || fixScript === undefined) {
+        throw new Error("Cannot update root Package Addition scripts: check and fix scripts are required");
+    }
     return {
         ...input,
         scripts: {
             ...input.scripts,
             check: rootScriptWithTurboPackageTasks({
-                script: input.scripts.check,
+                script: checkScript,
                 taskNames,
                 workspacePackageGlobs,
             }),
-            fix: rootScriptWithTurboPackageTask(input.scripts.fix, "fix", workspacePackageGlobs),
+            fix: rootScriptWithTurboPackageTask(fixScript, "fix", workspacePackageGlobs),
         },
     };
 }
@@ -483,6 +496,7 @@ function rootPackageJsonWithSharedOxcRuntimeDependencies(input, requiresSharedOx
             ...input.devDependencies,
             oxfmt: input.devDependencies?.oxfmt ?? "catalog:",
             oxlint: input.devDependencies?.oxlint ?? "catalog:",
+            "oxlint-tsgolint": input.devDependencies?.["oxlint-tsgolint"] ?? "catalog:",
         },
     };
 }
@@ -491,7 +505,7 @@ function catalogDependenciesWithSharedOxcRuntimeDependencies(catalogDependencies
     if (!requiresSharedOxcConfiguration) {
         return dependencies;
     }
-    for (const dependency of ["oxfmt", "oxlint"]) {
+    for (const dependency of ["oxfmt", "oxlint", "oxlint-tsgolint"]) {
         if (!dependencies.includes(dependency)) {
             dependencies.push(dependency);
         }

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -14,6 +14,7 @@ catalog:
   hono: ^4.12.27
   oxfmt: ^0.57.0
   oxlint: ^1.72.0
+  oxlint-tsgolint: ^0.24.0
   pinia: ^3.0.4
   tailwindcss: ^4.3.2
   tsc-alias: ^1.8.17

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

@@ -20,7 +20,7 @@ export type PresetPackageAdditionPlan = {
     readonly packageRole: PackageRole;
     readonly packageSourcePreset: PackageSourcePreset;
     readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string>;
+    readonly sourceRoots?: Record<string, string> | undefined;
     readonly operations: readonly RenderOperation[];
     readonly textFiles?: readonly {
         readonly path: string;
@@ -32,7 +32,7 @@ export type PresetPackageAdditionCapability = {
 };
 export type PresetProjectionPlan = {
     readonly sourceRoot: string;
-    readonly sourceRoots?: Record<string, string>;
+    readonly sourceRoots?: Record<string, string> | undefined;
     readonly operations: readonly RenderOperation[];
     readonly checkPlan: CheckPlan;
     readonly fixPlan: FixPlan;
@@ -48,7 +48,7 @@ export type PresetProjectionPlan = {
 };
 export type PresetBlueprintOptions = {
     readonly targetDir: string;
-    readonly scope?: string;
+    readonly scope?: string | undefined;
 };
 export type RenderPresetProjectionOptions = {
     readonly targetDir: string;

package/node_modules/@ykdz/template-core/dist/preset-projection.js

@@ -1,3 +1,4 @@
+import {} from "./module-graph.js";
 import { planNextStepInstructions, } from "./next-step-instructions.js";
 export function planNextStepInstructionsForProjection(options) {
     return planNextStepInstructions({

package/node_modules/@ykdz/template-core/dist/preset-source.js

@@ -797,6 +797,64 @@ function supportedProjectionDeclarationIssues(presets) {
         ]
         : []);
 }
+function normalizePresetSourceManifestOutput(manifest) {
+    return {
+        schemaVersion: manifest.schemaVersion,
+        name: manifest.name,
+        sharedResources: manifest.sharedResources.map((resource) => ({
+            ...resource,
+        })),
+        ...(manifest.fixtureMatrix
+            ? {
+                fixtureMatrix: {
+                    initSupport: manifest.fixtureMatrix.initSupport.map((support) => ({
+                        ...support,
+                    })),
+                    packageAdditionSupport: manifest.fixtureMatrix.packageAdditionSupport.map((support) => ({
+                        ...support,
+                    })),
+                    supportedCombinations: manifest.fixtureMatrix.supportedCombinations.map((combination) => ({
+                        basePreset: combination.basePreset,
+                        addedPreset: combination.addedPreset,
+                        linkFrom: [...combination.linkFrom],
+                    })),
+                    semanticSkips: manifest.fixtureMatrix.semanticSkips.map((skip) => ({
+                        ...skip,
+                    })),
+                    checkRequirements: [...manifest.fixtureMatrix.checkRequirements],
+                    environmentPreparation: [
+                        ...manifest.fixtureMatrix.environmentPreparation,
+                    ],
+                },
+            }
+            : {}),
+        presets: manifest.presets.map((preset) => ({
+            name: preset.name,
+            title: preset.title,
+            description: preset.description,
+            generation: preset.generation,
+            packageAdditionSupport: preset.packageAdditionSupport,
+            supportedPackageManagers: [...preset.supportedPackageManagers],
+            supportedProjectKinds: [...preset.supportedProjectKinds],
+            features: [...preset.features],
+            dependencyCatalog: [...preset.dependencyCatalog],
+            ...(preset.projection
+                ? {
+                    projection: normalizePresetProjectionDeclaration(preset.projection),
+                }
+                : {}),
+            ...(preset.source
+                ? {
+                    source: {
+                        roots: [...preset.source.roots],
+                        files: [...preset.source.files],
+                        sharedResources: [...preset.source.sharedResources],
+                    },
+                }
+                : {}),
+        })),
+    };
+}
 export function validatePresetSourceManifest(input, options = {}) {
     const inlineDependencyIssues = inlineDependencyCatalogSpecifierIssues(input);
     if (inlineDependencyIssues.length > 0) {
@@ -823,50 +881,7 @@ export function validatePresetSourceManifest(input, options = {}) {
     }
     return {
         ok: true,
-        value: {
-            ...result.output,
-            sharedResources: result.output.sharedResources.map((resource) => ({
-                ...resource,
-            })),
-            fixtureMatrix: result.output.fixtureMatrix
-                ? {
-                    initSupport: result.output.fixtureMatrix.initSupport.map((support) => ({ ...support })),
-                    packageAdditionSupport: result.output.fixtureMatrix.packageAdditionSupport.map((support) => ({ ...support })),
-                    supportedCombinations: result.output.fixtureMatrix.supportedCombinations.map((combination) => ({
-                        ...combination,
-                        linkFrom: [...(combination.linkFrom ?? [])],
-                    })),
-                    semanticSkips: result.output.fixtureMatrix.semanticSkips.map((skip) => ({ ...skip })),
-                    checkRequirements: [
-                        ...result.output.fixtureMatrix.checkRequirements,
-                    ],
-                    environmentPreparation: [
-                        ...result.output.fixtureMatrix.environmentPreparation,
-                    ],
-                }
-                : undefined,
-            presets: parsedManifest.presets.map((preset) => ({
-                ...preset,
-                supportedPackageManagers: [
-                    ...preset.supportedPackageManagers,
-                ],
-                supportedProjectKinds: [
-                    ...preset.supportedProjectKinds,
-                ],
-                features: [...preset.features],
-                dependencyCatalog: [...(preset.dependencyCatalog ?? [])],
-                projection: preset.projection
-                    ? normalizePresetProjectionDeclaration(preset.projection)
-                    : undefined,
-                source: preset.source
-                    ? {
-                        roots: [...preset.source.roots],
-                        files: [...preset.source.files],
-                        sharedResources: [...preset.source.sharedResources],
-                    }
-                    : undefined,
-            })),
-        },
+        value: normalizePresetSourceManifestOutput(parsedManifest),
     };
 }
 export function validateBuiltInPresetSourceManifest(input, options = {}) {
@@ -908,7 +923,7 @@ export function manifestReferencedSourceFiles(manifest, sourceRoot) {
             addReference(file);
         }
     }
-    return [...files].sort();
+    return [...files].toSorted();
 }
 export function loadPresetSourceManifestFile(filePath) {
     const result = validatePresetSourceManifest(JSON.parse(readFileSync(filePath, "utf8")), { sourceRoot: path.dirname(filePath) });

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

@@ -21,9 +21,9 @@ export type DependencyMaintenancePolicy = {
 };
 type ProjectCheckWorkflowOptions = {
     readonly checkPlan: CheckPlan;
-    readonly capability?: CiCapability;
-    readonly environmentPreparation?: Partial<CiEnvironmentPreparation>;
-    readonly taskLayer?: PnpmTaskLayer;
+    readonly capability?: CiCapability | undefined;
+    readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
+    readonly taskLayer?: PnpmTaskLayer | undefined;
 };
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;

package/node_modules/@ykdz/template-core/dist/project-github.js

@@ -1,3 +1,4 @@
+import {} from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",

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

@@ -11,9 +11,10 @@ export type WorkspaceLibraryPackageCapabilityDeclaration = {
     readonly sourceFiles: readonly string[];
 };
 export type WorkspaceNodePackageKind = "hono-api" | "vue-app";
+type WorkspaceNodePackagePath = "apps/api" | "apps/web";
 export type WorkspaceNodePackageDeclaration = {
     readonly kind: WorkspaceNodePackageKind;
-    readonly path: "apps/api" | "apps/web";
+    readonly path: WorkspaceNodePackagePath;
     readonly sourceFiles: readonly string[];
 };
 export type WorkspaceNodePackagesCapabilityDeclaration = {
@@ -53,8 +54,10 @@ export type PresetProjectionSourceRoots = {
     readonly sharedDevcontainer: () => string;
 };
 export declare function validateProjectionCapabilities(input: unknown): ValidationResult<PresetProjectionDeclaration>;
-export declare function projectionCapabilityIssues(presets: readonly PresetSourceManifestPreset[]): ValidationIssue[];
-export declare function normalizePresetProjectionDeclaration(declaration: PresetProjectionDeclaration): PresetProjectionDeclaration;
+export declare function projectionCapabilityIssues(presets: readonly {
+    readonly projection?: unknown;
+}[]): ValidationIssue[];
+export declare function normalizePresetProjectionDeclaration(declaration: unknown): PresetProjectionDeclaration;
 export declare function interpretPresetProjectionDeclaration(options: {
     readonly preset: PresetSourceManifestPreset;
     readonly declaration: PresetProjectionDeclaration;
@@ -73,3 +76,4 @@ export declare function planPresetSourcePackageAddition(options: {
     readonly sourceRoots: PresetProjectionSourceRoots;
 }): Promise<PresetPackageAdditionPlan>;
 export declare function defaultPackagePathForPresetSourcePackageAddition(preset: PresetSourceManifestPreset, packageLeafName: string, sourceRoots: PresetProjectionSourceRoots): string;
+export {};