create-next-hydra 0.3.0 → 0.4.1

package/dist/composition/typescript-paths.js

@@ -1,157 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
-import { z } from "zod";
-import { pathExists } from "../fs-utils.js";
-import { CompositionValidationError } from "./errors.js";
-const typeScriptConfigSchema = z
-    .object({
-    compilerOptions: z
-        .object({
-        paths: z.record(z.string(), z.array(z.string())).optional(),
-    })
-        .passthrough()
-        .optional(),
-})
-    .passthrough();
-const formattingOptions = {
-    eol: "\n",
-    insertFinalNewline: true,
-    insertSpaces: true,
-    tabSize: 2,
-};
-const parseTypeScriptConfig = (source, label) => {
-    const errors = [];
-    // SAFETY: jsonc-parser types its decoded JSON value as any; Zod validates it
-    // immediately below before it enters the composition domain.
-    const value = parse(source, errors, {
-        allowTrailingComma: true,
-        disallowComments: false,
-    });
-    if (errors.length > 0) {
-        throw new CompositionValidationError(`${label} is not valid JSONC.`, [
-            ...new Set(errors.map((error) => printParseErrorCode(error.error))),
-        ]);
-    }
-    const result = typeScriptConfigSchema.safeParse(value);
-    if (!result.success) {
-        throw new CompositionValidationError(`${label} is not a valid tsconfig.json file.`, result.error.issues.map((issue) => issue.message));
-    }
-    return result.data;
-};
-const toPosixRelative = (from, to) => {
-    const relative = path.relative(from, to).split(path.sep).join(path.posix.sep);
-    return relative.startsWith(".") ? relative : `./${relative}`;
-};
-const expectedPaths = (workspaceRoot, requirement) => {
-    const consumerRoot = path.join(workspaceRoot, requirement.cwd);
-    const targetRoot = path.join(workspaceRoot, requirement.sourcePath);
-    const relativeTarget = toPosixRelative(consumerRoot, targetRoot);
-    return [
-        { alias: requirement.alias, expected: [relativeTarget] },
-        {
-            alias: `${requirement.alias}/*`,
-            expected: [`${relativeTarget}/*`],
-        },
-    ];
-};
-const insertBeforeWorkspaceWildcard = (properties) => {
-    const wildcardIndex = properties.indexOf("@repo/*");
-    return wildcardIndex === -1 ? properties.length : wildcardIndex;
-};
-const samePath = (actual, expected) => actual !== undefined &&
-    actual.length === expected.length &&
-    actual.every((value, index) => value === expected[index]);
-const typeScriptConfigPath = (cwd) => path.posix.join(cwd, "tsconfig.json");
-const typeScriptConfigPlans = (plan) => {
-    const byConfig = new Map();
-    for (const target of plan.catalogTypeScriptPathAliases) {
-        const config = typeScriptConfigPath(target.cwd);
-        const entry = byConfig.get(config) ?? {
-            desired: [],
-            governed: new Set(),
-        };
-        entry.governed.add(target.alias);
-        byConfig.set(config, entry);
-    }
-    for (const alias of plan.typeScriptPathAliases) {
-        const config = typeScriptConfigPath(alias.cwd);
-        const entry = byConfig.get(config) ?? {
-            desired: [],
-            governed: new Set(),
-        };
-        entry.desired.push(alias);
-        entry.governed.add(alias.alias);
-        byConfig.set(config, entry);
-    }
-    const configs = [...byConfig].map(([config, entry]) => ({
-        config,
-        desired: entry.desired,
-        governed: [...entry.governed],
-    }));
-    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
-    return configs.sort((left, right) => left.config.localeCompare(right.config));
-};
-const governedPathAliases = (alias) => [alias, `${alias}/*`];
-export const applyTypeScriptPathAliases = async (workspaceRoot, plan) => {
-    await Promise.all(typeScriptConfigPlans(plan).map(async ({ config, desired, governed }) => {
-        const absoluteConfigPath = path.join(workspaceRoot, config);
-        if (desired.length === 0 && !(await pathExists(absoluteConfigPath))) {
-            return;
-        }
-        let source = await readFile(absoluteConfigPath, "utf-8");
-        const configValue = parseTypeScriptConfig(source, config);
-        const paths = configValue.compilerOptions?.paths ?? {};
-        const updates = desired.flatMap((entry) => expectedPaths(workspaceRoot, entry));
-        const desiredAliases = new Set(desired.map((entry) => entry.alias));
-        const removals = governed
-            .filter((alias) => !desiredAliases.has(alias))
-            .flatMap(governedPathAliases)
-            .filter((alias) => paths[alias] !== undefined);
-        if (removals.length === 0 &&
-            updates.every(({ alias, expected }) => samePath(paths[alias], expected))) {
-            return;
-        }
-        for (const alias of removals) {
-            source = applyEdits(source, modify(source, ["compilerOptions", "paths", alias], undefined, {
-                formattingOptions,
-            }));
-        }
-        for (const { alias, expected } of updates) {
-            source = applyEdits(source, modify(source, ["compilerOptions", "paths", alias], expected, {
-                formattingOptions,
-                getInsertionIndex: insertBeforeWorkspaceWildcard,
-            }));
-        }
-        await writeFile(absoluteConfigPath, source, "utf-8");
-    }));
-};
-export const checkTypeScriptPathAliases = async (workspaceRoot, plan) => {
-    const issues = await Promise.all(typeScriptConfigPlans(plan).map(async ({ config, desired, governed }) => {
-        const absoluteConfigPath = path.join(workspaceRoot, config);
-        if (!(await pathExists(absoluteConfigPath))) {
-            return desired.length === 0 ? [] : [`${config}: file is missing`];
-        }
-        const source = await readFile(absoluteConfigPath, "utf-8");
-        const configValue = parseTypeScriptConfig(source, config);
-        const paths = configValue.compilerOptions?.paths ?? {};
-        const desiredAliases = new Set(desired.map((entry) => entry.alias));
-        const pathIssues = desired
-            .flatMap((entry) => expectedPaths(workspaceRoot, entry))
-            .filter(({ alias, expected }) => !samePath(paths[alias], expected))
-            .map(({ alias, expected }) => `${config}: expected compilerOptions.paths.${alias} to be ${JSON.stringify(expected)}`);
-        const stalePathIssues = governed
-            .filter((alias) => !desiredAliases.has(alias))
-            .flatMap(governedPathAliases)
-            .flatMap((alias) => {
-            const actual = paths[alias];
-            return actual === undefined
-                ? []
-                : [
-                    `${config}: expected compilerOptions.paths.${alias} to be absent, found ${JSON.stringify(actual)}`,
-                ];
-        });
-        return [...pathIssues, ...stalePathIssues];
-    }));
-    return issues.flat();
-};

package/dist/composition/use.d.ts

@@ -1,23 +0,0 @@
-import { confirm } from "@clack/prompts";
-import { runCommand } from "../git.js";
-export type UseCompositionOptions = {
-    cwd?: string;
-    auth?: string;
-    cms?: string;
-    commerce?: string;
-    addOns?: string[];
-    preset?: string;
-    check?: boolean;
-    dryRun?: boolean;
-    yes?: boolean;
-    verbose?: boolean;
-};
-type ConfirmPrompt = (options: Parameters<typeof confirm>[0]) => ReturnType<typeof confirm>;
-type UseDependencies = {
-    confirm?: ConfirmPrompt;
-    install?: (cwd: string, verbose: boolean) => Promise<void>;
-};
-export declare function installCompositionDependencies(cwd: string, verbose: boolean, execute?: typeof runCommand): Promise<void>;
-export declare function useComposition(options: UseCompositionOptions, dependencies?: UseDependencies): Promise<void>;
-export {};
-//# sourceMappingURL=use.d.ts.map

package/dist/composition/use.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use.d.ts","sourceRoot":"","sources":["../../src/composition/use.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAY,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAyB,UAAU,EAAE,MAAM,WAAW,CAAC;AA2B9D,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,aAAa,GAAG,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,KACnC,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAEhC,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D,CAAC;AA+DF,wBAAsB,8BAA8B,CAClD,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,OAAO,UAAuB,GACtC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,EAC9B,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,IAAI,CAAC,CA4Jf"}

package/dist/composition/use.js

@@ -1,187 +0,0 @@
-import path from "node:path";
-import { confirm, isCancel } from "@clack/prompts";
-import { CommandExecutionError, runCommand } from "../git.js";
-import { info, printInstructions, success } from "../logger.js";
-import { addCatalogReferences, loadSourceRegistryCatalog } from "./catalog.js";
-import { CompositionValidationError } from "./errors.js";
-import { formatCompositionPlan, formatCompositionPreview, formatCompositionResult, hasCompositionChanges, } from "./format.js";
-import { installPreparedComposition, prepareComposition, validatePackageRequirementTargets, } from "./install.js";
-import { planComposition, selectionFromPreset } from "./planner.js";
-import { applyTypeScriptPathAliases } from "./typescript-paths.js";
-import { applyPackageRequirements, applyPnpmPatches, checkWorkspaceComposition, readWorkspaceSelection, removeWorkspaceTargets, writeWorkspaceSelection, } from "./workspace.js";
-function requestedSelection(current, options, presetSelection) {
-    const providers = presetSelection
-        ? { ...presetSelection.providers }
-        : { ...current.providers };
-    const providerOverrides = {
-        auth: options.auth,
-        cms: options.cms,
-        commerce: options.commerce,
-    };
-    for (const [slot, reference] of Object.entries(providerOverrides)) {
-        if (reference) {
-            providers[slot] = reference;
-        }
-    }
-    const presetAddOns = presetSelection ? presetSelection.addOns : [];
-    let addOns = presetSelection ? presetAddOns : current.addOns;
-    if (options.addOns) {
-        addOns = [...presetAddOns, ...options.addOns];
-    }
-    return {
-        ...current,
-        addOns: [...new Set(addOns)],
-        providers,
-    };
-}
-function operationFailure(error, failed, completed, pending) {
-    let cause = error instanceof Error ? error.message : String(error);
-    if (error instanceof CommandExecutionError) {
-        const output = error.stderr.trim() || error.stdout.trim();
-        if (output) {
-            cause = `${cause}\n${output}`;
-        }
-    }
-    return new Error([
-        `Composition stopped while ${failed}.`,
-        `Completed: ${completed.length > 0 ? completed.join(", ") : "none"}.`,
-        `Not attempted: ${pending.length > 0 ? pending.join(", ") : "none"}.`,
-        "The workspace changes have been left in place for inspection or repair.",
-        "",
-        cause,
-    ].join("\n"));
-}
-export async function installCompositionDependencies(cwd, verbose, execute = runCommand) {
-    await execute("pnpm", ["install", "--no-frozen-lockfile"], {
-        cwd,
-        verbose,
-    });
-}
-export async function useComposition(options, dependencies = {}) {
-    const cwd = path.resolve(options.cwd ?? process.cwd());
-    const current = await readWorkspaceSelection(cwd);
-    if (options.check &&
-        (options.auth ||
-            options.cms ||
-            options.commerce ||
-            options.preset ||
-            options.addOns)) {
-        throw new Error("`use --check` reads next-hydra.json and accepts no selections.");
-    }
-    if (options.check && options.dryRun) {
-        throw new Error("`use --check` cannot be combined with `--dry-run`.");
-    }
-    if (options.preset && (options.auth || options.cms || options.commerce)) {
-        throw new Error("`use --preset` cannot be combined with provider flags.");
-    }
-    let catalog = await loadSourceRegistryCatalog(cwd);
-    catalog = await addCatalogReferences(catalog, [
-        ...Object.values(current.providers),
-        ...current.addOns,
-        ...[options.auth, options.cms, options.commerce, options.preset].filter((value) => Boolean(value)),
-        ...(options.addOns ?? []),
-    ]);
-    const presetSelection = options.preset
-        ? selectionFromPreset(catalog, options.preset)
-        : undefined;
-    const selection = options.check
-        ? current
-        : requestedSelection(current, options, presetSelection);
-    catalog = await addCatalogReferences(catalog, [
-        ...Object.values(selection.providers),
-        ...selection.addOns,
-    ]);
-    const plan = planComposition(catalog, selection);
-    const prepared = await prepareComposition(catalog, plan);
-    await validatePackageRequirementTargets(cwd, plan, prepared, plan.catalogManagedTargets);
-    if (options.check) {
-        info("Checking the maintainer workspace against next-hydra.json.");
-        if (options.verbose) {
-            info(`Composition plan:\n${formatCompositionPlan(plan)}`);
-        }
-        const drift = await checkWorkspaceComposition(cwd, plan, prepared.managedFiles);
-        if (drift.length > 0) {
-            throw new CompositionValidationError("The maintainer workspace differs from next-hydra.json.", drift);
-        }
-        success("The maintainer workspace matches next-hydra.json.");
-        return;
-    }
-    info(formatCompositionPreview(current, plan.selection));
-    if (options.verbose) {
-        info(`Composition plan:\n${formatCompositionPlan(plan)}`);
-    }
-    if (!hasCompositionChanges(current, plan.selection)) {
-        success(formatCompositionResult(current, plan.selection));
-        return;
-    }
-    if (options.dryRun) {
-        success("Dry run complete. No changes were made.");
-        return;
-    }
-    if (!options.yes) {
-        const approved = await (dependencies.confirm ?? confirm)({
-            initialValue: false,
-            message: "Apply these composition changes?",
-        });
-        if (isCancel(approved) || !approved) {
-            throw new Error("Composition cancelled. No changes were made.");
-        }
-    }
-    const completed = [];
-    const pending = [
-        "write next-hydra.json",
-        "remove managed application files",
-        "install selected source",
-        "update package aliases",
-        "update TypeScript paths",
-        "update pnpm patches",
-        "install dependencies",
-    ];
-    const runStep = async (label, operation) => {
-        pending.shift();
-        try {
-            await operation();
-            completed.push(label);
-        }
-        catch (error) {
-            throw operationFailure(error, label, completed, pending);
-        }
-    };
-    await runStep("write next-hydra.json", async () => {
-        await writeWorkspaceSelection(cwd, plan.selection);
-    });
-    await runStep("remove managed application files", async () => {
-        await removeWorkspaceTargets(cwd, plan.catalogManagedTargets);
-    });
-    await runStep("install selected source", async () => {
-        await installPreparedComposition(cwd, prepared);
-    });
-    await runStep("update package aliases", async () => {
-        await applyPackageRequirements(cwd, plan);
-    });
-    await runStep("update TypeScript paths", async () => {
-        await applyTypeScriptPathAliases(cwd, plan);
-    });
-    await runStep("update pnpm patches", async () => {
-        await applyPnpmPatches(cwd, plan);
-    });
-    await runStep("install dependencies", async () => {
-        if (dependencies.install) {
-            await dependencies.install(cwd, options.verbose ?? false);
-            return;
-        }
-        await installCompositionDependencies(cwd, options.verbose ?? false);
-    });
-    if (plan.instructions.length > 0) {
-        printInstructions([
-            {
-                entries: plan.instructions.map((text) => ({
-                    kind: "text",
-                    text,
-                })),
-                title: "Provider setup",
-            },
-        ]);
-    }
-    success(formatCompositionResult(current, plan.selection));
-}

package/dist/composition/workspace.d.ts

@@ -1,10 +0,0 @@
-import type { CompositionPlan, PreparedComposition, WorkspaceSelection } from "./types.js";
-export declare const WORKSPACE_SELECTION_FILE = "next-hydra.json";
-export declare function readWorkspaceSelection(workspaceRoot: string): Promise<WorkspaceSelection>;
-export declare function writeWorkspaceSelection(workspaceRoot: string, selection: WorkspaceSelection): Promise<void>;
-export declare function applyPackageRequirements(workspaceRoot: string, plan: CompositionPlan): Promise<void>;
-export declare function applyPackageEntries(workspaceRoot: string, requirements: CompositionPlan["packageRequirements"]): Promise<void>;
-export declare function applyPnpmPatches(workspaceRoot: string, plan: CompositionPlan): Promise<void>;
-export declare function removeWorkspaceTargets(workspaceRoot: string, targets: string[]): Promise<void>;
-export declare function checkWorkspaceComposition(workspaceRoot: string, plan: CompositionPlan, managedFiles: PreparedComposition["managedFiles"]): Promise<string[]>;
-//# sourceMappingURL=workspace.d.ts.map

package/dist/composition/workspace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/composition/workspace.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,eAAO,MAAM,wBAAwB,oBAAoB,CAAC;AAE1D,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAyB7B;AAED,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,kBAAkB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,wBAAwB,CAC5C,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CA6Cf;AAED,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,eAAe,CAAC,qBAAqB,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,CAgCf;AAuBD,wBAAsB,gBAAgB,CACpC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAyBD,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAsB,yBAAyB,CAC7C,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAuGnB"}

package/dist/composition/workspace.js

@@ -1,210 +0,0 @@
-import { readdir, readFile, rmdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { parseDocument } from "yaml";
-import { pathExists, readJsonFile, removePath, writeJsonFile, } from "../fs-utils.js";
-import { CompositionValidationError } from "./errors.js";
-import { readPackageJson } from "./packages.js";
-import { formatZodError, workspaceSelectionSchema } from "./schema.js";
-import { checkTypeScriptPathAliases } from "./typescript-paths.js";
-export const WORKSPACE_SELECTION_FILE = "next-hydra.json";
-export async function readWorkspaceSelection(workspaceRoot) {
-    const filePath = path.join(workspaceRoot, WORKSPACE_SELECTION_FILE);
-    if (!(await pathExists(filePath))) {
-        throw new Error(`${WORKSPACE_SELECTION_FILE} was not found. The \`use\` command only operates on a Next Hydra maintainer workspace.`);
-    }
-    const value = await readJsonFile(filePath);
-    const result = workspaceSelectionSchema.safeParse(value);
-    if (!result.success) {
-        throw new CompositionValidationError(`${WORKSPACE_SELECTION_FILE} is invalid.`, formatZodError(result.error));
-    }
-    // Preserve existing top-level and nested key positions, appending only
-    // schema-defaulted keys that were absent from the file.
-    const selection = value;
-    for (const [key, defaultedValue] of Object.entries(result.data)) {
-        if (!Object.hasOwn(selection, key)) {
-            selection[key] = defaultedValue;
-        }
-    }
-    return value;
-}
-export async function writeWorkspaceSelection(workspaceRoot, selection) {
-    await writeJsonFile(path.join(workspaceRoot, WORKSPACE_SELECTION_FILE), selection);
-}
-export async function applyPackageRequirements(workspaceRoot, plan) {
-    const selected = new Set(plan.packageRequirements.map((requirement) => `${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
-    const removals = plan.catalogPackageRequirementTargets.filter((requirement) => !selected.has(`${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
-    const byManifest = new Map();
-    for (const requirement of removals) {
-        const manifest = path.posix.join(requirement.cwd, "package.json");
-        const entries = byManifest.get(manifest) ?? [];
-        entries.push(requirement);
-        byManifest.set(manifest, entries);
-    }
-    await Promise.all([...byManifest].map(async ([manifest, entries]) => {
-        const manifestPath = path.join(workspaceRoot, manifest);
-        if (!(await pathExists(manifestPath))) {
-            return;
-        }
-        const packageJson = await readPackageJson(manifestPath, manifest);
-        let changed = false;
-        for (const requirement of entries) {
-            const section = packageJson[requirement.section];
-            if (!(section && Object.hasOwn(section, requirement.name))) {
-                continue;
-            }
-            delete section[requirement.name];
-            changed = true;
-        }
-        if (changed) {
-            await writeJsonFile(manifestPath, packageJson);
-        }
-    }));
-    await applyPackageEntries(workspaceRoot, plan.packageRequirements);
-}
-export async function applyPackageEntries(workspaceRoot, requirements) {
-    const byManifest = new Map();
-    for (const requirement of requirements) {
-        const manifest = path.posix.join(requirement.cwd, "package.json");
-        const existing = byManifest.get(manifest) ?? [];
-        existing.push(requirement);
-        byManifest.set(manifest, existing);
-    }
-    await Promise.all([...byManifest].map(async ([manifest, manifestRequirements]) => {
-        const manifestPath = path.join(workspaceRoot, manifest);
-        const packageJson = await readPackageJson(manifestPath, manifest);
-        let changed = false;
-        for (const requirement of manifestRequirements) {
-            const section = packageJson[requirement.section] ?? {};
-            if (Object.hasOwn(section, requirement.name) &&
-                section[requirement.name] === requirement.specifier) {
-                continue;
-            }
-            section[requirement.name] = requirement.specifier;
-            packageJson[requirement.section] = section;
-            changed = true;
-        }
-        if (changed) {
-            await writeJsonFile(manifestPath, packageJson);
-        }
-    }));
-}
-function readPnpmWorkspaceConfig(source) {
-    const document = parseDocument(source);
-    if (document.errors.length > 0) {
-        throw new CompositionValidationError("pnpm-workspace.yaml is invalid.", document.errors.map((error) => error.message));
-    }
-    return {
-        config: document.toJS(),
-        document,
-    };
-}
-export async function applyPnpmPatches(workspaceRoot, plan) {
-    if (plan.catalogPnpmPatches.length === 0) {
-        return;
-    }
-    const workspaceFile = path.join(workspaceRoot, "pnpm-workspace.yaml");
-    const { config, document } = readPnpmWorkspaceConfig(await readFile(workspaceFile, "utf-8"));
-    const governedDependencies = new Set(plan.catalogPnpmPatches.map((patch) => patch.dependency));
-    const patches = Object.fromEntries(Object.entries(config.patchedDependencies ?? {}).filter(([dependency]) => !governedDependencies.has(dependency)));
-    for (const patch of plan.pnpmPatches) {
-        patches[patch.dependency] = patch.path;
-    }
-    const sortedPatches = Object.fromEntries(Object.entries(patches).sort(([left], [right]) => left.localeCompare(right)));
-    if (Object.keys(sortedPatches).length === 0) {
-        document.delete("patchedDependencies");
-    }
-    else {
-        document.set("patchedDependencies", sortedPatches);
-    }
-    await writeFile(workspaceFile, document.toString(), "utf-8");
-}
-async function pruneEmptyParents(workspaceRoot, relativeTarget) {
-    let current = path.dirname(path.join(workspaceRoot, relativeTarget));
-    const root = path.resolve(workspaceRoot);
-    while (current.startsWith(`${root}${path.sep}`)) {
-        try {
-            // Parent directories must be checked from the leaf toward the root.
-            // oxlint-disable-next-line no-await-in-loop -- Each iteration depends on the previous parent.
-            const entries = await readdir(current);
-            if (entries.length > 0) {
-                return;
-            }
-            await rmdir(current);
-            current = path.dirname(current);
-        }
-        catch {
-            return;
-        }
-    }
-}
-export async function removeWorkspaceTargets(workspaceRoot, targets) {
-    const deepestFirst = [...targets].sort((left, right) => right.split("/").length - left.split("/").length);
-    for (const target of deepestFirst) {
-        // Targets are deepest-first so pruning one target cannot race another.
-        // oxlint-disable-next-line no-await-in-loop -- Ordered removal keeps parent pruning deterministic.
-        await removePath(path.join(workspaceRoot, target));
-        await pruneEmptyParents(workspaceRoot, target);
-    }
-}
-export async function checkWorkspaceComposition(workspaceRoot, plan, managedFiles) {
-    const drift = [];
-    const selected = new Set(plan.packageRequirements.map((requirement) => `${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
-    const unselectedPackageDrift = await Promise.all(plan.catalogPackageRequirementTargets.map(async (requirement) => {
-        const key = `${requirement.cwd}\0${requirement.section}\0${requirement.name}`;
-        if (selected.has(key)) {
-            return;
-        }
-        const manifest = path.posix.join(requirement.cwd, "package.json");
-        const manifestPath = path.join(workspaceRoot, manifest);
-        if (!(await pathExists(manifestPath))) {
-            return;
-        }
-        const packageJson = await readPackageJson(manifestPath, manifest);
-        const actual = packageJson[requirement.section]?.[requirement.name];
-        return actual === undefined
-            ? undefined
-            : `${manifest}: expected unselected ${requirement.section}.${requirement.name} to be absent, found ${actual}`;
-    }));
-    drift.push(...unselectedPackageDrift.filter((issue) => issue !== undefined));
-    const selectedPackageDrift = await Promise.all(plan.packageRequirements.map(async (requirement) => {
-        const manifest = path.posix.join(requirement.cwd, "package.json");
-        const packageJson = await readPackageJson(path.join(workspaceRoot, manifest), manifest);
-        const actual = packageJson[requirement.section]?.[requirement.name];
-        return actual === requirement.specifier
-            ? undefined
-            : `${manifest}: expected ${requirement.section}.${requirement.name} to be ${requirement.specifier}, found ${actual ?? "missing"}`;
-    }));
-    const typeScriptPathDrift = await checkTypeScriptPathAliases(workspaceRoot, plan);
-    drift.push(...selectedPackageDrift.filter((issue) => issue !== undefined), ...typeScriptPathDrift);
-    if (plan.catalogPnpmPatches.length > 0) {
-        const workspaceFile = path.join(workspaceRoot, "pnpm-workspace.yaml");
-        const { config } = readPnpmWorkspaceConfig(await readFile(workspaceFile, "utf-8"));
-        const selectedPatches = new Map(plan.pnpmPatches.map((patch) => [patch.dependency, patch.path]));
-        for (const patch of plan.catalogPnpmPatches) {
-            const expected = selectedPatches.get(patch.dependency);
-            const actual = config.patchedDependencies?.[patch.dependency];
-            if (actual !== expected) {
-                drift.push(`pnpm-workspace.yaml: expected patchedDependencies.${patch.dependency} to be ${expected ?? "absent"}, found ${actual ?? "missing"}`);
-            }
-        }
-    }
-    const expectedManagedFiles = new Map(managedFiles.map((file) => [file.target, file.content]));
-    const managedFileDrift = await Promise.all(plan.catalogManagedTargets.map(async (target) => {
-        const filePath = path.join(workspaceRoot, target);
-        const expected = expectedManagedFiles.get(target);
-        if (!expected) {
-            return (await pathExists(filePath))
-                ? `${target}: managed file should not exist for this composition`
-                : undefined;
-        }
-        if (!(await pathExists(filePath))) {
-            return `${target}: managed file is missing`;
-        }
-        const actual = await readFile(filePath, "utf-8");
-        return actual === expected
-            ? undefined
-            : `${target}: managed file differs from the composition plan`;
-    }));
-    drift.push(...managedFileDrift.filter((issue) => issue !== undefined));
-    return drift.sort((left, right) => left.localeCompare(right));
-}

package/dist/constants.d.ts

@@ -1,11 +0,0 @@
-import type { StarterDefinition } from "./types.js";
-export declare const CLI_NAME = "create-next-hydra";
-export declare const DEFAULT_REPO_URL = "https://github.com/jakala-na/next-hydra.git";
-export declare const DEFAULT_COMMIT_MESSAGE = "Initial commit";
-export declare const DEFAULT_PACKAGE_MANAGER = "pnpm";
-export declare const DEFAULT_STARTER: StarterDefinition;
-export declare const SANITIZE_REMOVE_PATHS: readonly [".changeset", ".git", ".github/workflows/e2e.yml", ".github/workflows/registry-integrity.yml", ".github/workflows/release-create-next-hydra.yml", ".scratch", "RELEASING.md", "apps/docs", "next-hydra.json", "packages/create-next-hydra", "scripts/release-create-next-hydra.mjs", "scripts/sync-registry-files.ts"];
-export declare const SANITIZE_REMOVE_SCRIPTS: readonly ["changeset", "changeset:status", "publish:cli", "registry:check", "registry:sync", "release:create-next-hydra", "release:create-next-hydra:dry-run", "version:cli"];
-export declare const SANITIZE_REMOVE_ROOT_DEPENDENCIES: readonly ["@clack/prompts", "commander"];
-export declare const SANITIZE_REMOVE_ROOT_DEV_DEPENDENCIES: readonly ["@changesets/cli"];
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,eAAO,MAAM,QAAQ,sBAAsB,CAAC;AAC5C,eAAO,MAAM,gBAAgB,gDAAgD,CAAC;AAC9E,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,iBAG7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,YAChC,YAAY,EACZ,MAAM,EACN,2BAA2B,EAC3B,0CAA0C,EAC1C,iDAAiD,EACjD,UAAU,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,4BAA4B,EAC5B,uCAAuC,EACvC,gCAAgC,CACxB,CAAC;AAEX,eAAO,MAAM,uBAAuB,YAClC,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,2BAA2B,EAC3B,mCAAmC,EACnC,aAAa,CACL,CAAC;AAEX,eAAO,MAAM,iCAAiC,YAC5C,gBAAgB,EAChB,WAAW,CACH,CAAC;AAEX,eAAO,MAAM,qCAAqC,YAChD,iBAAiB,CACT,CAAC"}

package/dist/constants.js

@@ -1,39 +0,0 @@
-export const CLI_NAME = "create-next-hydra";
-export const DEFAULT_REPO_URL = "https://github.com/jakala-na/next-hydra.git";
-export const DEFAULT_COMMIT_MESSAGE = "Initial commit";
-export const DEFAULT_PACKAGE_MANAGER = "pnpm";
-export const DEFAULT_STARTER = {
-    id: "default",
-    repoUrl: DEFAULT_REPO_URL,
-};
-export const SANITIZE_REMOVE_PATHS = [
-    ".changeset",
-    ".git",
-    ".github/workflows/e2e.yml",
-    ".github/workflows/registry-integrity.yml",
-    ".github/workflows/release-create-next-hydra.yml",
-    ".scratch",
-    "RELEASING.md",
-    "apps/docs",
-    "next-hydra.json",
-    "packages/create-next-hydra",
-    "scripts/release-create-next-hydra.mjs",
-    "scripts/sync-registry-files.ts",
-];
-export const SANITIZE_REMOVE_SCRIPTS = [
-    "changeset",
-    "changeset:status",
-    "publish:cli",
-    "registry:check",
-    "registry:sync",
-    "release:create-next-hydra",
-    "release:create-next-hydra:dry-run",
-    "version:cli",
-];
-export const SANITIZE_REMOVE_ROOT_DEPENDENCIES = [
-    "@clack/prompts",
-    "commander",
-];
-export const SANITIZE_REMOVE_ROOT_DEV_DEPENDENCIES = [
-    "@changesets/cli",
-];

package/dist/fs-utils.d.ts

@@ -1,9 +0,0 @@
-export declare function pathExists(targetPath: string): Promise<boolean>;
-export declare function isDirectoryEmpty(targetPath: string): Promise<boolean>;
-export declare function ensureParentDirectory(targetPath: string): Promise<void>;
-export declare function removePath(targetPath: string): Promise<void>;
-export declare function readJsonFile<T>(filePath: string): Promise<T>;
-export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
-export declare function toDisplayPath(absolutePath: string, cwd?: string): string;
-export declare function normalizePackageName(input: string): string;
-//# sourceMappingURL=fs-utils.d.ts.map

package/dist/fs-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../src/fs-utils.ts"],"names":[],"mappings":"AAkBA,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrE;AAED,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ3E;AAED,wBAAsB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7E;AAED,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElE;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlE;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,aAAa,CAC3B,YAAY,EAAE,MAAM,EACpB,GAAG,SAAgB,GAClB,MAAM,CAYR;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB1D"}